Changeset 4304 for trunk/ProjectFortress

Timestamp:

11/02/09 13:29:21 (3 weeks ago)

Author:

sukyoungryu

Message:

[abstract method checker] Replaced yet another copy of the old, wrong inheritedMethod with STypesUtil.inheritedMethod which is now augmented with the information of declaring traits of the inherited methods.

Location:

trunk/ProjectFortress

Files:

• compiler_tests/AfterTypeChecking.test (modified) (1 diff)
• src/com/sun/fortress/scala_src/typechecker/AbstractMethodChecker.scala (modified) (4 diffs)
• src/com/sun/fortress/scala_src/typechecker/OverloadingChecker.scala (modified) (1 diff)
• src/com/sun/fortress/scala_src/useful/STypesUtil.scala (modified) (2 diffs)

trunk/ProjectFortress/compiler_tests/AfterTypeChecking.test

@@ -25 +25 @@
 Compiled9.g Compiled9.j Compiled9.k Compiled9.l Compiled9.m Compiled9.o Compiled9.p Compiled9.t Compiled9.u Compiled9.y Compiled9.ab Compiled9.ac Compiled9.ah Compiled9.ai Compiled9.aj \
 Compiled10.Comprehensions3 Compiled10.l Compiled10.m Compiled10.r \
-Compiled11 Compiled12
+Compiled11 \
+Compiled12 Compiled12.inherit.fss
 typecheck

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

@@ -26 +26 @@
 import com.sun.fortress.compiler.index.ComponentIndex
 import com.sun.fortress.compiler.index.{Functional => JavaFunctional}
+import com.sun.fortress.compiler.index.HasSelfType
 import com.sun.fortress.compiler.index.TraitIndex
 import com.sun.fortress.compiler.typechecker.StaticTypeReplacer
@@ -105 +106 @@
   }
 
-  private def inheritedAbstractMethods(extended_traits: List[TraitTypeWhere]) =
-    inheritedAbstractMethodsHelper(new HierarchyHistory(), extended_traits)
-
-  private def inheritedAbstractMethodsHelper(hist: HierarchyHistory,
-                                             extended_traits: List[TraitTypeWhere]):
-                                            Map[IdOrOp, (TraitType, Set[FnDecl])] = {
-    var h = hist
-    var map = new HashMap[IdOrOp, (TraitType, Set[FnDecl])]()
-    for ( trait_ <- extended_traits ; if ! h.hasExplored(trait_.getBaseType) ) {
-      trait_.getBaseType match {
-        case ty@STraitType(info, name, args, params) =>
-          h.explore(ty)
-          val tci = typeAnalyzer.traits.typeCons(name)
-          if ( tci.isSome && tci.unwrap.isInstanceOf[TraitIndex] ) {
-            val ti = tci.unwrap.asInstanceOf[TraitIndex]
-            map.put(name, (ty, collectAbstractMethods(name, toList(NU.getDecls(ti.ast)))))
-            val old_hist = h
-            map ++= inheritedAbstractMethodsHelper(h, toList(ti.extendsTypes))
-            h = old_hist
-          } else error(NU.getSpan(trait_),
-                       "Trait types are expected in an extends clause but found "
-                       + ty.toStringVerbose + "\n" + tci.getClass)
-        case SAnyType(_) =>
-        case ty => error(NU.getSpan(trait_),
-                         "Trait types are expected in an extends clause but found "
-                         + ty.toStringVerbose)
+  private def inheritedAbstractMethods(extended_traits: List[TraitTypeWhere]) = {
+    val inherited = inheritedMethods(typeAnalyzer.traits, extended_traits,
+                                     Set(), typeAnalyzer)
+    val map = new HashMap[IdOrOp, (TraitType, Set[FnDecl])]()
+    for (pair <- inherited) {
+      val (_, ftn) = (pair.first, pair.second)
+      val name = ftn._1.asInstanceOf[HasSelfType].declaringTrait
+      val tci = typeAnalyzer.traits.typeCons(name)
+      if ( tci.isSome && tci.unwrap.isInstanceOf[TraitIndex] ) {
+        val ti = tci.unwrap.asInstanceOf[TraitIndex]
+        map.put(name, (ftn._3,
+                       collectAbstractMethods(name, toList(NU.getDecls(ti.ast)))))
       }
     }
@@ -144 +131 @@
                      } else if ( mods.isAbstract ) set += fd
                    case _ => })
-      set
+    set
   }
 
@@ -152 +139 @@
   private def implement(d: FnDecl, decls: List[Decl], ast: TraitType): Boolean =
     decls.exists( (decl: Decl) => decl match {
-                  case fd@SFnDecl(_,_,_,_,_) => implement(d, fd, ast)
+                  case fd:FnDecl => implement(d, fd, ast)
                   case _ => false
                 } )

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

@@ -198 +198 @@
                                           toList(traitOrObject.extendsTypes),
                                           methods, typeAnalyzer)
-              .asInstanceOf[Set[JavaPair[IdOrOpOrAnonymousName, (JavaFunctional, StaticTypeReplacer)]]]
+              .asInstanceOf[Set[JavaPair[IdOrOpOrAnonymousName, (JavaFunctional, StaticTypeReplacer, TraitType)]]]
+              .map(p => { val t = p.second
+                          new JavaPair(p.first, (t._1, t._2)) })
 
             for ( f <- methods.map(x => x.first) ; if isDeclaredName(f) ) {

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

@@ -872 +872 @@
                                given: Set[(String, Type)])
                               : Set[Pair[IdOrOpOrAnonymousName,
-                                         (Functional, StaticTypeReplacer)]] = {
+                                         (Functional, StaticTypeReplacer, TraitType)]] = {
       var allMethods = given
       // 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)]]()
+      //                   triples of Functionals, static parameters substitutions, and declaring trait
+      var methods = Set[Pair[IdOrOpOrAnonymousName, (Functional, StaticTypeReplacer, TraitType)]]()
       var h = history
       for (trait_ <- extended_traits) {
@@ -902 +902 @@
                       val paramTy = paramsToArgs.replaceIn(new_pair._2)
                       if (!isOverride(fname, paramTy, allMethods, analyzer)) {
-                        methods += new Pair(method_name, (method_func, paramsToArgs))
+                        methods += new Pair(method_name, (method_func, paramsToArgs, ty))
                         allMethods += ((fname, paramTy))
                       }