Changeset 4289 for trunk/ProjectFortress

Timestamp:

10/26/09 07:55:47 (4 weeks ago)

Author:

sukyoungryu

Message:

[types util] Fixed the inheritedMethods to handle method overriding.
Moved the paramsToType method to STypesUtil.

Location:

trunk/ProjectFortress/src/com/sun/fortress/scala_src

Files:

• typechecker/AbstractMethodChecker.scala (modified) (2 diffs)
• typechecker/OverloadingChecker.scala (modified) (1 diff)
• useful/STypesUtil.scala (modified) (3 diffs)

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

@@ -25 +25 @@
 import com.sun.fortress.compiler.GlobalEnvironment
 import com.sun.fortress.compiler.index.ComponentIndex
+import com.sun.fortress.compiler.index.{Functional => JavaFunctional}
 import com.sun.fortress.compiler.index.TraitIndex
 import com.sun.fortress.compiler.typechecker.StaticTypeReplacer
@@ -67 +68 @@
         checkObject(span, List(), name, extendsC,
                     walk(decls).asInstanceOf[List[Decl]])
-        val inherited = inheritedMethods(traits, extendsC).map(t => t.first.asInstanceOf[IdOrOp].getText)
+        val inherited = inheritedMethods(traits, extendsC, Set(), typeAnalyzer)
+                        .map(t => t.first.asInstanceOf[IdOrOp].getText)
         for ( d <- decls ; if d.isInstanceOf[FnDecl] ) {
           if ( NU.isFunctionalMethod(NU.getParams(d.asInstanceOf[FnDecl])) &&

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

@@ -474 +474 @@
     /* Returns the type of the given list of parameters. */
     private def paramsToType(params: JavaList[Param], span: Span): Type =
-        params.size match {
-            case 0 => NodeFactory.makeVoidType(span)
-            case 1 => paramToType(params.get(0))
-            case _ =>
-            NodeFactory.makeTupleType(NodeUtil.spanAll(params),
-                                      Lists.toJavaList(Lists.toList(params).map(p => paramToType(p))))
-        }
-
-    /* Returns the type of the given parameter. */
-    private def paramToType(param: Param): Type =
-        toOption(param.getIdType) match {
-            case Some(ty) => ty
-            case _ =>
-                toOption(param.getVarargsType) match {
-                    case Some(ty) => ty
-                    case _ =>
-                        val span = NodeUtil.getSpan(param)
-                        error(span,
-                              "Type checking couldn't infer the type of " + param)
-                        NodeFactory.makeVoidType(span)
-                }
-        }
+      STypesUtil.paramsToType(toList(params), span) match {
+        case Some(ty) => ty
+        case _ =>
+          val span = NodeUtil.spanAll(params)
+          error(span,
+                "Type checking couldn't infer the type of " + params)
+          NodeFactory.makeVoidType(span)
+      }
 
     private def error(loc: Span, msg: String) =

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

@@ -35 +35 @@
 import com.sun.fortress.nodes_util.{NodeFactory => NF}
 import com.sun.fortress.nodes_util.{NodeUtil => NU}
+import com.sun.fortress.nodes_util.Span
 import com.sun.fortress.scala_src.nodes._
 import com.sun.fortress.scala_src.typechecker.ConstraintFormula
@@ -874 +875 @@
   }
 
+  // Invariant: Parameter types of all the methods should exist.
   def inheritedMethods(traits: TraitTable,
-                       extendedTraits: List[TraitTypeWhere]) = {
+                       extendedTraits: List[TraitTypeWhere],
+                       initial: Set[Pair[IdOrOpOrAnonymousName, Functional]],
+                       analyzer: TypeAnalyzer) = {
     // Return all of the methods from super-traits
     def inheritedMethodsHelper(history: HierarchyHistory,
-                               extended_traits: List[TraitTypeWhere])
-                              : Set[Pair[IdOrOpOrAnonymousName, Function]] = {
-      var methods = Set[Pair[IdOrOpOrAnonymousName, Function]]()
-      var done = false
+                               extended_traits: List[TraitTypeWhere],
+                               given: Set[Pair[IdOrOpOrAnonymousName, Functional]])
+                              : Set[Pair[IdOrOpOrAnonymousName, Functional]] = {
+      var allMethods = given
+      var methods = Set[Pair[IdOrOpOrAnonymousName, Functional]]()
       var h = history
-      for ( trait_ <- extended_traits ; if (! done) ) {
+      for (trait_ <- extended_traits) {
         val type_ = trait_.getBaseType
         if ( ! h.hasExplored(type_) ) {
           h.explore(type_)
           type_ match {
-            case ty@STraitType(_, name, _, params) =>
+            case ty@STraitType(_, name, trait_args, params) =>
               toOption(traits.typeCons(name)) match {
                 case Some(ti) =>
                   if ( ti.isInstanceOf[TraitIndex] ) {
-                    val trait_params = ti.staticParameters
-                    val trait_args = ty.getArgs
                     // Instantiate methods with static args
-                    var collected: Collection[Pair[IdOrOpOrAnonymousName, Function]] =
-                      toSet(ti.asInstanceOf[TraitIndex].dottedMethods).asInstanceOf[CSet[Pair[IdOrOpOrAnonymousName, Function]]]
+                    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, Function]]]
+                      toSet(ti.asInstanceOf[TraitIndex].functionalMethods)
+                      .asInstanceOf[CSet[Pair[IdOrOpOrAnonymousName, Functional]]]
                     for ( pair <- collected ; if pair.first.isInstanceOf[IdOrOp] ) {
-                      methods += pair
+                      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)
+                      }
+                      if (!isOverride(fname, paramTy, allMethods, analyzer)) {
+                        methods += pair
+                        allMethods += pair
+                      }
                     }
-                    val paramsToArgs = new StaticTypeReplacer(trait_params, trait_args)
                     val instantiated_extends_types =
                       toList(ti.asInstanceOf[TraitIndex].extendsTypes).map( (t:TraitTypeWhere) =>
                             t.accept(paramsToArgs).asInstanceOf[TraitTypeWhere] )
                     val old_hist = h
-                    methods ++= inheritedMethodsHelper(h, instantiated_extends_types)
+                    val inherited = inheritedMethodsHelper(h, instantiated_extends_types,
+                                                           allMethods)
+                    methods ++= inherited
+                    allMethods ++= inherited
                     h = old_hist
-                  } else done = true
-                case _ => done = true
+                  } else return methods
+                case _ => return methods
               }
-            case _ => done = true
+            case _ => return methods
           }
         }
@@ -918 +937 @@
       methods
     }
-    inheritedMethodsHelper(new HierarchyHistory(), extendedTraits)
-  }
-
+    inheritedMethodsHelper(new HierarchyHistory(), extendedTraits, initial)
+  }
+
+  private def isOverride(fname: String, paramTy: Type,
+                         allMethods: Set[Pair[IdOrOpOrAnonymousName, Functional]],
+                         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
+    }
+    false
+  }
+
+  /* Returns the type of the given list of parameters. */
+  def paramsToType(params: List[Param], span: Span): Option[Type] =
+    params.size match {
+      case 0 => Some(NF.makeVoidType(span))
+      case 1 => paramToType(params.head)
+      case _ =>
+        val elems = params.map(paramToType)
+        if (elems.forall(_.isDefined))
+          Some(NF.makeTupleType(NU.spanAll(toJavaList(params)),
+                                Lists.toJavaList(elems.map(_.get))))
+        else None
+    }
+
+  /* Returns the type of the given parameter. */
+  def paramToType(param: Param): Option[Type] =
+    toOption(param.getIdType) match {
+      case Some(ty) => Some(ty)
+      case _ => toOption(param.getVarargsType) match {
+        case Some(ty) => Some(ty)
+        case _ => None
+      }
+  }
 }