Changeset 4292

Timestamp:

10/26/09 21:56:40 (4 weeks ago)

Author:

sukyoungryu

Message:

[self type idiom] Added another self-type idiom test.
[overloading checker] Implemented overloading checking of inherited dotted methods and functional methods.

Location:

trunk/ProjectFortress

Files:

• compiler_tests/Compiled10.s.fss (added)
• compiler_tests/XXX10s.test (added)
• src/com/sun/fortress/scala_src/typechecker/ExclusionOracle.scala (modified) (8 diffs)
• src/com/sun/fortress/scala_src/typechecker/OverloadingChecker.scala (modified) (20 diffs)
• src/com/sun/fortress/scala_src/useful/STypesUtil.scala (modified) (4 diffs)

trunk/ProjectFortress/src/com/sun/fortress/scala_src/typechecker/ExclusionOracle.scala

@@ -30 +30 @@
 import com.sun.fortress.compiler.index.TypeConsIndex
 import com.sun.fortress.compiler.index.{Function => JavaFunction}
-import com.sun.fortress.compiler.typechecker.TypeAnalyzer
 import com.sun.fortress.exceptions.StaticError
 import com.sun.fortress.exceptions.TypeError
@@ -39 +38 @@
 import com.sun.fortress.parser_util.IdentifierUtil
 import com.sun.fortress.repository.FortressRepository
+import com.sun.fortress.scala_src.types.TypeAnalyzer
 import com.sun.fortress.scala_src.useful._
 import com.sun.fortress.scala_src.useful.ErrorLog
@@ -74 +74 @@
       case (_, SAnyType(_)) => false
       case (f@SVarType(_,_,_), s@SVarType(_,_,_)) =>
-        ( toOption(typeAnalyzer.kindEnv.staticParam(f.getName)),
-          toOption(typeAnalyzer.kindEnv.staticParam(s.getName)) ) match {
+        ( toOption(typeAnalyzer.env.staticParam(f.getName)),
+          toOption(typeAnalyzer.env.staticParam(s.getName)) ) match {
           case (Some(fp), Some(sp)) =>
             var result = false
@@ -105 +105 @@
         }
       case (f@SVarType(_,_,_), _) =>
-        toOption(typeAnalyzer.kindEnv.staticParam(f.getName)) match {
+        toOption(typeAnalyzer.env.staticParam(f.getName)) match {
           case Some(fp) =>
             var result = false
@@ -120 +120 @@
         }
       case (_, s@SVarType(_,_,_)) =>
-        toOption(typeAnalyzer.kindEnv.staticParam(s.getName)) match {
+        toOption(typeAnalyzer.env.staticParam(s.getName)) match {
           case Some(sp) =>
             var result = false
@@ -148 +148 @@
       case (_, _:TupleType) => true
       case (f:TraitType, s:TraitType) =>
-        ( toOption(typeAnalyzer.traitTable.typeCons(f.getName)),
-          toOption(typeAnalyzer.traitTable.typeCons(s.getName)) ) match {
+        ( toOption(typeAnalyzer.traits.typeCons(f.getName)),
+          toOption(typeAnalyzer.traits.typeCons(s.getName)) ) match {
           case (Some(fi), Some(si)) =>
             ( NodeUtil.isTraitOrObject(fi), NodeUtil.isTraitOrObject(si) ) match {
@@ -182 +182 @@
     for ( t <- toList(tIndex.extendsTypes) ) {
       if ( t.getBaseType.isInstanceOf[NamedType] ) {
-        result ++= transitivelyExcludes(typeAnalyzer.traitTable.typeCons(t.getBaseType.asInstanceOf[NamedType].getName).unwrap.asInstanceOf[ProperTraitIndex])
+        result ++= transitivelyExcludes(typeAnalyzer.traits.typeCons(t.getBaseType.asInstanceOf[NamedType].getName).unwrap.asInstanceOf[ProperTraitIndex])
       }
     }
@@ -254 +254 @@
           if (t.isInstanceOf[VarType]) result = false
           else {
-            toOption(typeAnalyzer.traitTable.typeCons(t.getName)) match {
+            toOption(typeAnalyzer.traits.typeCons(t.getName)) match {
               case None =>
                 errors.signal("Unrecognized name: " + t.getName, NodeUtil.getSpan(t))

trunk/ProjectFortress/src/com/sun/fortress/scala_src/typechecker/OverloadingChecker.scala

@@ -23 +23 @@
 import edu.rice.cs.plt.collect.Relation
 import edu.rice.cs.plt.tuple.{Option => JavaOption}
+import edu.rice.cs.plt.tuple.{Pair => JavaPair}
 import com.sun.fortress.compiler.GlobalEnvironment
 import com.sun.fortress.compiler.index.CompilationUnitIndex
@@ -33 +34 @@
 import com.sun.fortress.compiler.index.{Method => JavaMethod}
 import com.sun.fortress.compiler.index.{Variable => JavaVariable}
-import com.sun.fortress.compiler.typechecker.TypeAnalyzer
+import com.sun.fortress.compiler.typechecker.StaticTypeReplacer
 import com.sun.fortress.exceptions.InterpreterBug
 import com.sun.fortress.exceptions.StaticError
@@ -43 +44 @@
 import com.sun.fortress.nodes_util.Span
 import com.sun.fortress.parser_util.IdentifierUtil
+import com.sun.fortress.scala_src.types.TypeAnalyzer
 import com.sun.fortress.scala_src.useful._
 import com.sun.fortress.scala_src.useful.Lists._
@@ -71 +73 @@
                              f: IdOrOpOrAnonymousName)
                             : Set[((JavaList[StaticParam],Type,Type), Span)] = {
-      val fns = toSig(toSet(index.functions.matchFirst(f)).asInstanceOf[Set[JavaFunctional]])
+      val fns = toFunctionSig(toSet(index.functions.matchFirst(f)).asInstanceOf[Set[JavaFunctional]])
       if ( index.variables.keySet.contains(f) )
         index.variables.get(f) match {
@@ -84 +86 @@
     }
 
-    private def toSig(set: Set[JavaFunctional])
-                     : Set[((JavaList[StaticParam],Type,Type), Span)] =
-      set.filter(isDeclaredFunctional(_))
-         .map((f: JavaFunctional) =>
+    // for functions
+    private def toFunctionSig(set: Set[JavaFunctional])
+                             : Set[((JavaList[StaticParam],Type,Type), Span)] =
+      set.filter(isDeclaredFunction(_))
+         .map(f => ((f.staticParameters,
+                     paramsToType(f.parameters, f.getSpan),
+                     f.getReturnType.unwrap),
+                    f.getSpan))
+
+    // for functional methods
+    private def toFunctionalMethodSig(set: Set[(JavaFunction, StaticTypeReplacer)])
+                                     : Set[((JavaList[StaticParam],Type,Type), Span)] =
+      set.filter(p => isFunctionalMethod(p._1))
+         .map(p => {
+              val (f, replacer) = p
               ((f.staticParameters,
-                paramsToType(f.parameters, f.getSpan),
-                f.getReturnType.unwrap),
-               f.getSpan))
+                replacer.replaceIn(paramsToType(f.parameters, f.getSpan)),
+                replacer.replaceIn(f.getReturnType.unwrap)),
+               f.getSpan)})
+
+    // for dotted methods
+    private def toMethodSig(set: Set[(JavaMethod, StaticTypeReplacer)])
+                           : Set[((JavaList[StaticParam],Type,Type), Span)] =
+      set.filter(p => isDeclaredMethod(p._1))
+         .map(p => {
+              val (f, replacer) = p
+              ((f.staticParameters,
+                replacer.replaceIn(paramsToType(f.selfType.unwrap, f.parameters, f.getSpan)),
+                replacer.replaceIn(f.getReturnType.unwrap)),
+               f.getSpan)})
 
     /* Called by com.sun.fortress.compiler.StaticChecker.checkComponent
@@ -129 +153 @@
             }
           }
-          checkOverloading(f, set)
+          checkFunctionOverloading(f, set)
         }
         /* All inherited abstract methods in object expressions should be defined,
@@ -144 +168 @@
             // Extend the type analyzer with the collected static parameters
             val oldTypeAnalyzer = typeAnalyzer
-            val staticParameters = new ArrayList[StaticParam]()
             // Add static parameters of the enclosing trait or object
-            staticParameters.addAll( traitOrObject.staticParameters )
-            typeAnalyzer = typeAnalyzer.extend(staticParameters, none[WhereClause])
+            typeAnalyzer = typeAnalyzer.extend(toList(traitOrObject.staticParameters),
+                                               None)
             /* The parameter type of a setter must be the same as the return type
              * of a getter with the same name, if any.
@@ -166 +189 @@
                 }
             }
-            val methods = traitOrObject.dottedMethods
-            for ( f <- toSet(methods.firstSet) ; if isDeclaredName(f) ) {
-              checkOverloading(f, toSig(toSet(methods.matchFirst(f)).asInstanceOf[Set[JavaFunctional]]))
+            val identity = new StaticTypeReplacer(new ArrayList[StaticParam](),
+                                                  new ArrayList[StaticArg]())
+            var methods = toSet(traitOrObject.dottedMethods)
+                          .asInstanceOf[Set[JavaPair[IdOrOpOrAnonymousName, JavaFunctional]]]
+                          .map(p => new JavaPair(p.first, (p.second, identity)))
+            methods ++=
+              STypesUtil.inheritedMethods(typeAnalyzer.traits,
+                                          toList(traitOrObject.extendsTypes),
+                                          methods, typeAnalyzer)
+              .asInstanceOf[Set[JavaPair[IdOrOpOrAnonymousName, (JavaFunctional, StaticTypeReplacer)]]]
+
+            for ( f <- methods.map(x => x.first) ; if isDeclaredName(f) ) {
+              var ss = Set[(JavaMethod, StaticTypeReplacer)]()
+              methods.filter(p => (p.first == f && p.second._1.isInstanceOf[JavaMethod]) &&
+                             p.second._1.asInstanceOf[JavaMethod].selfType.isSome)
+                     .foreach(ss += _.second.asInstanceOf[(JavaMethod, StaticTypeReplacer)])
+              checkMethodOverloading(f, toMethodSig(ss))
+            }
+            for ( f <- methods.map(x => x.first) ; if isDeclaredName(f) ) {
+              var ss = Set[(JavaFunction, StaticTypeReplacer)]()
+              methods.filter(p => p.first == f && p.second._1.isInstanceOf[JavaFunction])
+                     .foreach(ss += _.second.asInstanceOf[(JavaFunction, StaticTypeReplacer)])
+              checkFunctionOverloading(f, toFunctionalMethodSig(ss))
             }
             typeAnalyzer = oldTypeAnalyzer
@@ -174 +217 @@
         toJavaList(errors)
     }
+
+    /* Checks the validity of the overloaded method declarations. */
+    private def checkMethodOverloading(name: IdOrOpOrAnonymousName,
+                                       set: Set[((JavaList[StaticParam],Type,Type), Span)])
+                                      : Unit =
+      checkOverloading(name, set, true)
+
+    /* Checks the validity of the overloaded function declarations. */
+    private def checkFunctionOverloading(name: IdOrOpOrAnonymousName,
+                                         set: Set[((JavaList[StaticParam],Type,Type), Span)])
+                                        : Unit =
+      checkOverloading(name, set, false)
 
     /* Checks the validity of the overloaded function declarations. */
     private def checkOverloading(name: IdOrOpOrAnonymousName,
-                                 set: Set[((JavaList[StaticParam],Type,Type), Span)])
+                                 set: Set[((JavaList[StaticParam],Type,Type), Span)],
+                                 isMethod: Boolean)
                                 : Unit = set.size match {
       case 0 =>
@@ -189 +245 @@
                     "There are multiple declarations of " +
                     name + " with the same type: " +
-                    param + " -> " + result)
+                    (if (isMethod) dropReceiver(param) else param) +
+                    " -> " + result)
             case _ =>
               // A functional which takes a single parameter of a parametric type
@@ -249 +306 @@
         staticParameters.addAll(sub_type._1._1)
         staticParameters.addAll(super_type._1._1)
-        typeAnalyzer = typeAnalyzer.extend(staticParameters, none[WhereClause])
+        typeAnalyzer = typeAnalyzer.extend(toList(staticParameters), None)
         val result = subtype(super_type._1._2, sub_type._1._2) &&
                      subtype(sub_type._1._3, super_type._1._3)
@@ -273 +330 @@
         staticParameters.addAll(first._1._1)
         staticParameters.addAll(second._1._1)
-        typeAnalyzer = typeAnalyzer.extend(staticParameters, none[WhereClause])
+        typeAnalyzer = typeAnalyzer.extend(toList(staticParameters), None)
         val result = new ExclusionOracle(typeAnalyzer,
                                          new ErrorLog()).excludes(first._1._2,
@@ -291 +348 @@
         staticParameters.addAll(first._1._1)
         staticParameters.addAll(second._1._1)
-        typeAnalyzer = typeAnalyzer.extend(staticParameters, none[WhereClause])
+        typeAnalyzer = typeAnalyzer.extend(toList(staticParameters), None)
         var result = false
         val exclusionOracle = new ExclusionOracle(typeAnalyzer, new ErrorLog())
@@ -333 +390 @@
                     var i = 0
                     while ( i < size ) {
-                        elems = elems ::: List(typeAnalyzer.meet(toJavaList(tuples.map(ty => NodeUtil.getTupleTypeElem(ty, i)))))
+                        elems = elems ::: List(typeAnalyzer.meet(tuples.map(ty => NodeUtil.getTupleTypeElem(ty, i))))
                         i += 1
                     }
@@ -419 +476 @@
         // add static parameters of "f"'s enclosing trait or object
         if ( NodeUtil.isFunctionalMethod(f) ) {
-            val ind = typeAnalyzer.traitTable.typeCons(NodeUtil.getDeclaringTrait(f))
+            val ind = typeAnalyzer.traits.typeCons(NodeUtil.getDeclaringTrait(f))
             if ( ind.isSome && NodeUtil.isTraitOrObject(ind.unwrap) ) {
                 staticParameters.addAll( NodeUtil.getStaticParameters(ind.unwrap) )
@@ -427 +484 @@
         // add static parameters of "g"'s enclosing trait or object
         if ( NodeUtil.isFunctionalMethod(g) ) {
-            val ind = typeAnalyzer.traitTable.typeCons(NodeUtil.getDeclaringTrait(g))
+            val ind = typeAnalyzer.traits.typeCons(NodeUtil.getDeclaringTrait(g))
             if ( ind.isSome && NodeUtil.isTraitOrObject(ind.unwrap) ) {
                 staticParameters.addAll( NodeUtil.getStaticParameters(ind.unwrap) )
@@ -438 +495 @@
         // Whether "g"'s parameter type is a subtype of "f"'s parameter type
         // and "f"'s return type is a subtype of "g"'s return type
-        typeAnalyzer = typeAnalyzer.extend(staticParameters, none[WhereClause])
+        typeAnalyzer = typeAnalyzer.extend(toList(staticParameters), None)
         val result = subtype(paramsToType(g.parameters, g.getSpan),
                              paramsToType(f.parameters, f.getSpan)) &&
@@ -446 +503 @@
     }
 
+    /* Drop the first element denoting the receiver type of the given type. */
+    private def dropReceiver(param: Type) = param match {
+      case STupleType(info, _::ty::Nil, None, Nil) => ty
+      case STupleType(info, elements, varargs, keywords) =>
+        STupleType(info, elements.takeRight(elements.size-1), varargs, keywords)
+      case _ => NodeFactory.makeVoidType(NodeUtil.getSpan(param))
+    }
+
     def isDeclaredName(f: IdOrOpOrAnonymousName) = f match {
         case SId(_,_,str) => IdentifierUtil.validId(str)
@@ -452 +517 @@
     }
 
-    def isDeclaredFunctional(f: JavaFunctional) = f match {
+    def isDeclaredMethod(f: JavaFunctional) = f match {
+        case DeclaredMethod(_,_) => true
+        case _ => false
+    }
+
+    def isDeclaredFunction(f: JavaFunctional) = f match {
         case DeclaredFunction(_) => true
-        case DeclaredMethod(_,_) => true
+        case _ => false
+    }
+
+    def isFunctionalMethod(f: JavaFunctional) = f match {
+        case FunctionalMethod(_,_) => true
         case _ => false
     }
@@ -483 +557 @@
       }
 
+    /* Returns the type of the given self type and a list of parameters. */
+    private def paramsToType(self: Type, params: JavaList[Param], span: Span): Type = {
+      val span = params.size match {
+        case 0 => NodeUtil.getSpan(self)
+        case _ => NodeUtil.spanAll(params)
+      }
+      val elems = toList(params).map(paramToType)
+      if (elems.forall(_.isDefined))
+        NodeFactory.makeTupleType(span, toJavaList(List(self) ++ elems.map(_.get)))
+      else {
+        error(span,
+              "Type checking couldn't infer the type of " + params)
+        NodeFactory.makeVoidType(span)
+      }
+    }
+
     private def error(loc: Span, msg: String) =
         errors = errors ::: List(TypeError.make(msg, loc))

trunk/ProjectFortress/src/com/sun/fortress/scala_src/useful/STypesUtil.scala

@@ -860 +860 @@
   }
 
-  // Invariant: Parameter types of all the methods should exist.
+  // Invariant: Parameter types of all the methods should exist,
+  //            either given or inferred.
   def inheritedMethods(traits: TraitTable,
                        extendedTraits: List[TraitTypeWhere],
-                       initial: Set[Pair[IdOrOpOrAnonymousName, Functional]],
+                       initial: Set[Pair[IdOrOpOrAnonymousName,
+                                         (Functional, StaticTypeReplacer)]],
                        analyzer: TypeAnalyzer) = {
     // Return all of the methods from super-traits
     def inheritedMethodsHelper(history: HierarchyHistory,
                                extended_traits: List[TraitTypeWhere],
-                               given: Set[Pair[IdOrOpOrAnonymousName, Functional]])
-                              : Set[Pair[IdOrOpOrAnonymousName, Functional]] = {
+                               given: Set[(String, Type)])
+                              : Set[Pair[IdOrOpOrAnonymousName,
+                                         (Functional, StaticTypeReplacer)]] = {
       var allMethods = given
-      var methods = Set[Pair[IdOrOpOrAnonymousName, Functional]]()
+      // a set of inherited methods:
+      // a set of pairs of method names and
+      //                   pairs of Functionals and static parameters substitutions
+      var methods = Set[Pair[IdOrOpOrAnonymousName, (Functional, StaticTypeReplacer)]]()
       var h = history
       for (trait_ <- extended_traits) {
@@ -882 +888 @@
                 case Some(ti) =>
                   if ( ti.isInstanceOf[TraitIndex] ) {
+                    val tindex = ti.asInstanceOf[TraitIndex]
                     // Instantiate methods with static args
                     val paramsToArgs = new StaticTypeReplacer(ti.staticParameters,
                                                               toJavaList(trait_args))
-                    var collected: Collection[Pair[IdOrOpOrAnonymousName, Functional]] =
-                      toSet(ti.asInstanceOf[TraitIndex].dottedMethods)
-                      .asInstanceOf[CSet[Pair[IdOrOpOrAnonymousName, Functional]]]
-                    collected ++=
-                      toSet(ti.asInstanceOf[TraitIndex].functionalMethods)
-                      .asInstanceOf[CSet[Pair[IdOrOpOrAnonymousName, Functional]]]
+                    var collected = toSet(tindex.dottedMethods)
+                      .asInstanceOf[Collection[Pair[IdOrOpOrAnonymousName, Functional]]]
+                    collected ++= toSet(tindex.functionalMethods)
+                      .asInstanceOf[Collection[Pair[IdOrOpOrAnonymousName, Functional]]]
                     for ( pair <- collected ; if pair.first.isInstanceOf[IdOrOp] ) {
-                      val fname = pair.first.asInstanceOf[IdOrOp].getText
-                      val span = NU.getSpan(pair.first)
-                      val paramTy = paramsToType(toList(pair.second.parameters),
-                                                 span) match {
-                        case Some(t) => paramsToArgs.replaceIn(t)
-                        case _ => NF.makeVoidType(span)
-                      }
+                      val (method_name, method_func) = (pair.first, pair.second)
+                      val new_pair = toNameParamTy(method_name, method_func)
+                      val fname = new_pair._1
+                      val paramTy = paramsToArgs.replaceIn(new_pair._2)
                       if (!isOverride(fname, paramTy, allMethods, analyzer)) {
-                        methods += pair
-                        allMethods += pair
+                        methods += new Pair(method_name, (method_func, paramsToArgs))
+                        allMethods += ((fname, paramTy))
                       }
                     }
                     val instantiated_extends_types =
-                      toList(ti.asInstanceOf[TraitIndex].extendsTypes).map( (t:TraitTypeWhere) =>
-                            t.accept(paramsToArgs).asInstanceOf[TraitTypeWhere] )
+                      toList(tindex.extendsTypes).map(_.accept(paramsToArgs).asInstanceOf[TraitTypeWhere])
                     val old_hist = h
                     val inherited = inheritedMethodsHelper(h, instantiated_extends_types,
                                                            allMethods)
                     methods ++= inherited
-                    allMethods ++= inherited
+                    allMethods ++= inherited.map(p => toNameParamTy(p.first, p.second._1))
                     h = old_hist
                   } else return methods
@@ -922 +923 @@
       methods
     }
-    inheritedMethodsHelper(new HierarchyHistory(), extendedTraits, initial)
+    inheritedMethodsHelper(new HierarchyHistory(), extendedTraits,
+                           initial.map(p => toNameParamTy(p.first, p.second._1)))
+  }
+
+  private def toNameParamTy(name: IdOrOpOrAnonymousName, func: Functional) = {
+    val span = NU.getSpan(name)
+    val ty = paramsToType(toList(func.parameters), span) match {
+      case Some(t) => t
+      case _ => NF.makeVoidType(span)
+    }
+   (name.asInstanceOf[IdOrOp].getText, ty)
   }
 
   private def isOverride(fname: String, paramTy: Type,
-                         allMethods: Set[Pair[IdOrOpOrAnonymousName, Functional]],
+                         allMethods: Set[(String, Type)],
                          analyzer: TypeAnalyzer): Boolean = {
-    for (f <- allMethods;
-         if fname.equals(f.first.asInstanceOf[IdOrOp].getText)) {
-      val span = NU.getSpan(f.first)
-      val otherParamTy = paramsToType(toList(f.second.parameters), span) match {
-        case Some(t) => t
-        case _ => NF.makeVoidType(span)
-      }
-      if (analyzer.equivalent(paramTy, otherParamTy).isTrue) return true
+    for (f <- allMethods; if fname.equals(f._1)) {
+      if (analyzer.equivalent(paramTy, f._2).isTrue) return true
     }
     false
@@ -949 +954 @@
         if (elems.forall(_.isDefined))
           Some(NF.makeTupleType(NU.spanAll(toJavaList(params)),
-                                Lists.toJavaList(elems.map(_.get))))
+                                toJavaList(elems.map(_.get))))
         else None
     }