Changeset 4286 for trunk/ProjectFortress/src

Timestamp:

10/24/09 23:14:49 (4 weeks ago)

Author:

sukyoungryu

Message:

[self type idiom] Added more tests.
[type checker] Moved the inheritedMethods method from AbstractMethodChecker? to STypesUtil.

Location:

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

Files:

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

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

@@ -67 +67 @@
         checkObject(span, List(), name, extendsC,
                     walk(decls).asInstanceOf[List[Decl]])
-        val inherited = inheritedMethods(extendsC)
+        val inherited = inheritedMethods(traits, extendsC).map(t => t.first.asInstanceOf[IdOrOp].getText)
         for ( d <- decls ; if d.isInstanceOf[FnDecl] ) {
           if ( NU.isFunctionalMethod(NU.getParams(d.asInstanceOf[FnDecl])) &&
@@ -101 +101 @@
     }
     typeAnalyzer = oldTypeAnalyzer
-  }
-
-  def inheritedMethods(extendedTraits: List[TraitTypeWhere]) = {
-    // Return all of the methods from super-traits
-    def inheritedMethodsHelper(history: HierarchyHistory,
-                               extended_traits: List[TraitTypeWhere])
-                               : Set[String] = {
-      var methods = new HashSet[String]()
-      var done = false
-      var h = history
-      for ( trait_ <- extended_traits ; if (! done) ) {
-        val type_ = trait_.getBaseType
-        if ( ! h.hasExplored(type_) ) {
-          h.explore(type_)
-          type_ match {
-            case ty@STraitType(_, name, _, 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 = toSet(ti.asInstanceOf[TraitIndex].dottedMethods).map(t => t.first)
-                    collected ++= toSet(ti.asInstanceOf[TraitIndex].functionalMethods).map(t => t.first)
-                    for ( pair <- collected ; if pair.isInstanceOf[IdOrOp] ) {
-                      methods += pair.asInstanceOf[IdOrOp].getText
-                    }
-                    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)
-                    h = old_hist
-                  } else done = true
-                case _ => done = true
-              }
-            case _ => done = true
-          }
-        }
-      }
-      methods
-    }
-    inheritedMethodsHelper(new HierarchyHistory(), extendedTraits)
   }
 

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

@@ -19 +19 @@
 
 import _root_.java.util.ArrayList
+import scala.collection.{Set => CSet}
+import edu.rice.cs.plt.tuple.Pair
 import com.sun.fortress.compiler.GlobalEnvironment
 import com.sun.fortress.compiler.Types
@@ -37 +39 @@
 import com.sun.fortress.scala_src.typechecker.CnFalse
 import com.sun.fortress.scala_src.typechecker.CnTrue
+import com.sun.fortress.scala_src.typechecker.TraitTable
 import com.sun.fortress.scala_src.types.TypeAnalyzer
 import com.sun.fortress.scala_src.useful.Lists._
@@ -870 +873 @@
     case _ => addType(fn, arrow)
   }
+
+  def inheritedMethods(traits: TraitTable,
+                       extendedTraits: List[TraitTypeWhere]) = {
+    // 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
+      var h = history
+      for ( trait_ <- extended_traits ; if (! done) ) {
+        val type_ = trait_.getBaseType
+        if ( ! h.hasExplored(type_) ) {
+          h.explore(type_)
+          type_ match {
+            case ty@STraitType(_, name, _, 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]]]
+                    collected ++=
+                      toSet(ti.asInstanceOf[TraitIndex].functionalMethods).asInstanceOf[CSet[Pair[IdOrOpOrAnonymousName, Function]]]
+                    for ( pair <- collected ; if pair.first.isInstanceOf[IdOrOp] ) {
+                      methods += 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)
+                    h = old_hist
+                  } else done = true
+                case _ => done = true
+              }
+            case _ => done = true
+          }
+        }
+      }
+      methods
+    }
+    inheritedMethodsHelper(new HierarchyHistory(), extendedTraits)
+  }
+
 }