Changeset 3921 for trunk/ProjectFortress

Timestamp:

07/06/09 08:26:38 (5 months ago)

Author:

jrhil47

Message:

[type environments] Still rewriting type environments. Fixed the constraint-related bug that David emailed about.

Location:

trunk/ProjectFortress/src/com/sun/fortress

Files:

• compiler/StaticChecker.java (modified) (2 diffs)
• compiler/index/Functional.java (modified) (1 diff)
• compiler/typechecker/constraints/ConstraintUtil.java (modified) (6 diffs)
• scala_src/typechecker/STypeChecker.scala (modified) (1 diff)
• scala_src/typechecker/staticenv/KindEnv.scala (modified) (3 diffs)
• scala_src/typechecker/staticenv/STypeEnv.scala (modified) (4 diffs)
• scala_src/typechecker/staticenv/STypeEnvExtraction.scala (modified) (2 diffs)
• scala_src/typechecker/staticenv/StaticEnv.scala (modified) (6 diffs)

trunk/ProjectFortress/src/com/sun/fortress/compiler/StaticChecker.java

@@ -234 +234 @@
             } else {
                 TypeEnv typeEnv = typeCheckEnv(component, env);
-                ConstraintUtil.useScalaFormulas();
                 STypeChecker typeChecker = STypeCheckerFactory.make(component, traitTable, typeEnv, typeAnalyzer);
                 component_ast = typeChecker.typeCheck(component_ast);
@@ -276 +275 @@
                                                boolean postInference) {
         TypeEnv typeEnv = typeCheckEnv(component, env);
-        ConstraintUtil.useJavaFormulas();
         TypeChecker typeChecker = new TypeChecker(traitTable, typeEnv,
                                                   component, postInference);

trunk/ProjectFortress/src/com/sun/fortress/compiler/index/Functional.java

@@ -73 +73 @@
     /**
      * Evaluate the thunk to get a return type. Then replace the thunk with one
-     * that simply gets back the previously evaluated return type.
+     * that simply gets back the previously evaluated return type. After type
+     * checking, the result of this method will always be Some(type).
      */
     public Option<Type> getReturnType() {

trunk/ProjectFortress/src/com/sun/fortress/compiler/typechecker/constraints/ConstraintUtil.java

@@ -18 +18 @@
 package com.sun.fortress.compiler.typechecker.constraints;
 
+import com.sun.fortress.Shell;
 import com.sun.fortress.compiler.typechecker.constraints.JavaConstraintUtil;
 import com.sun.fortress.scala_src.typechecker.ScalaConstraintUtil;
@@ -29 +30 @@
 public class ConstraintUtil {
 
-        private static boolean java = true;
-
-        public static void useJavaFormulas(){
-                java = true;
-        }
-
-        public static void useScalaFormulas(){
-                java = false;
-        }
-
-        public static void setJava(Boolean _java){
-                java = _java;
-        }
-
         public static ConstraintFormula trueFormula() {
-                if(java)
+                if(!Shell.getScala())
                         return JavaConstraintUtil.trueFormula();
                 else
@@ -50 +37 @@
         }
         public static ConstraintFormula falseFormula() {
-                if(java)
+                if(!Shell.getScala())
                         return JavaConstraintUtil.falseFormula();
                 else
@@ -57 +44 @@
 
         public static ConstraintFormula upperBound(_InferenceVarType ivar, Type type, SubtypeHistory h) {
-                if(java)
+                if(!Shell.getScala())
                         return JavaConstraintUtil.upperBound(ivar,type,h);
                 else
@@ -64 +51 @@
 
         public static ConstraintFormula lowerBound(_InferenceVarType ivar, Type type, SubtypeHistory h) {
-                if(java)
+                if(!Shell.getScala())
                         return JavaConstraintUtil.lowerBound(ivar,type,h);
                 else
@@ -80 +67 @@
 
         public static ConstraintFormula fromBoolean(Boolean bool){
-                if(java)
+                if(!Shell.getScala())
                         return JavaConstraintUtil.fromBoolean(bool);
                 else

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

@@ -226 +226 @@
    * Return the conditions for subtype <: supertype to hold.
    */
-  protected def checkSubtype(subtype: Type, supertype: Type): ScalaConstraint =
-    analyzer.subtype(subtype, supertype).asInstanceOf[ScalaConstraint]
+  protected def checkSubtype(subtype: Type, supertype: Type): ScalaConstraint = {
+    val constraint = analyzer.subtype(subtype, supertype) 
+    if (!constraint.isInstanceOf[ScalaConstraint]) {
+      bug("Not a ScalaConstraint.")
+    }
+    constraint.asInstanceOf[ScalaConstraint]
+  }
 
   protected def equivalentTypes(t1: Type, t2: Type): Boolean =

trunk/ProjectFortress/src/com/sun/fortress/scala_src/typechecker/staticenv/KindEnv.scala

@@ -35 +35 @@
   type EnvBinding = KindBinding
 
-  /** Extend me with the immediate bindings of the given node. */
-  def extendWith(node: Any): KindEnv =
-    new NestedKindEnv(this, KindEnv.extractEnvBindings(node))
-
   /**
    * Get the type of the given variable name, if it is bound. The resulting
@@ -63 +59 @@
  */
 class NestedKindEnv protected (protected val parent: KindEnv,
-                               _bindings: Collection[KindBinding])
+                               _bindings: Iterable[KindBinding])
     extends KindEnv with NestedStaticEnv[StaticParam] {
     
@@ -80 +76 @@
   type EnvBinding = KindBinding
   
-  /** New kind environment with empty parent and the node's bindings. */
-  def make(node: Any): KindEnv =
-    new NestedKindEnv(EmptyKindEnv, extractEnvBindings(node))
+  def empty():KindEnv = EmptyKindEnv
   
   /** Extract out the bindings in node. */
-  protected def extractEnvBindings(node: Any) : Collection[KindBinding] = null
+  protected def extractEnvBindings(node: Node) : Iterable[KindBinding] = Nil
+  protected def extractEnvBindings(node: Any) : Iterable[KindBinding] = Nil
 }
 

trunk/ProjectFortress/src/com/sun/fortress/scala_src/typechecker/staticenv/STypeEnv.scala

@@ -36 +36 @@
   
   /** Extend me with the immediate bindings of the given node. */
-  def extendWith(node: Any): STypeEnv =
-    new NestedSTypeEnv(this, STypeEnv.extractEnvBindings(node))
   
   /** Same as `lookup`. */
@@ -53 +51 @@
  */
 class NestedSTypeEnv protected (protected val parent: STypeEnv,
-                                _bindings: Collection[TypeBinding])
+                                _bindings: Iterable[TypeBinding])
     extends STypeEnv with NestedStaticEnv[Type] {
     
@@ -62 +60 @@
 
 /** Companion module for STypeEnv. */
-object STypeEnv extends StaticEnvCompanion[Type] with STypeEnvExtraction {
+object STypeEnv extends StaticEnvCompanion[Type]
+    with STypeEnvExtraction {
   
   /** My type. */
@@ -70 +69 @@
   type EnvBinding = TypeBinding
   
-  /** New type environment with empty parent and the node's bindings. */
-  def make(node: Any): STypeEnv =
-    new NestedSTypeEnv(EmptySTypeEnv, extractEnvBindings(node))
+  def empty(): STypeEnv = EmptySTypeEnv 
+  
 }
 

trunk/ProjectFortress/src/com/sun/fortress/scala_src/typechecker/staticenv/STypeEnvExtraction.scala

@@ -33 +33 @@
 import edu.rice.cs.plt.collect.Relation
 
-trait STypeEnvExtraction { self: STypeEnv.type =>
+
+/**
+ * Provides the functionality for extracting type bindings from nodes and
+ * indices to create type environments.
+ */
+trait STypeEnvExtraction  { self: STypeEnv.type =>
   
   /** Extract out the bindings in node. */
-  def extractEnvBindings(node: Any): Collection[TypeBinding] = {
-    def recur(node: Any) = extractEnvBindings(node)
-    (node match {
-      
+  def extractEnvBindings(node: Node): Iterable[TypeBinding] = {
+    def recur(node: Node) = extractEnvBindings(node)
+    (node match{
       case SBinding(_, name, mods, Some(typ)) =>
         TypeBinding(name, typ, mods, false)
@@ -50 +54 @@
       case SLValue(_, name, mods, Some(typ), mutable) =>
         TypeBinding(name, typ, mods, mutable)
-      
+        
       case SLocalVarDecl(_, _, lValues, _) => lValues.map(recur)
-      
-      case v:DeclaredVariable => recur(v.ast)
-      
-      // Type erasure makes us put all JMap cases in one.
-      case m:JMap[_, _] => toMap(m).flatMap(xv =>
-        xv match {
-          
-          // Match Map[Id, Variable]
-          case (x:Id, v:DeclaredVariable) => recur(v)
-          case (x:Id, v:SingletonVariable) =>
-            recur(NF.makeLValue(x, v.declaringTrait))
-          case (x:Id, v:ParamVariable) => recur(v.ast)
-          
-          // Bind object names to their types.
-          case (x:Id, v:ObjectTraitIndex) =>
-            val decl = v.ast
-            val params = toOption(NU.getParams(decl))
-            val sparams = NU.getStaticParams(decl)
-            val objType = params match {
-              case None if sparams.isEmpty =>
-                // Just a single trait type.
-                NF.makeTraitType(x)
-              case None =>
-                // A generic trait type.
-                NF.makeGenericSingletonType(x, sparams)
-              case Some(params) if sparams.isEmpty =>
-                // Arrow type for basic constructor.
-                NF.makeArrowType(NU.getSpan(x),
-                                 STypesUtil.makeDomainType(toList(params)),
-                                 NF.makeTraitType(x))
-              case Some(params) =>
-                // Generic arrow type for constructor.
-                val sargs = toList(sparams).map(STypesUtil.staticParamToArg)
-                NF.makeArrowType(NU.getSpan(decl),
-                                 false,
-                                 STypesUtil.makeDomainType(toList(params)),
-                                 NF.makeTraitType(x, toJavaList(sargs)),
-                                 NF.emptyEffect, // TODO: Change this?
-                                 sparams,
-                                 NU.getWhereClause(decl))
-            }
-            List(TypeBinding(x, objType, Modifiers.None, false))
-        })
-      
-      // Matches all, but must be [IdOrOpOrAnonymousName, ? <: Functional]
-      case r:Relation[IdOrOpOrAnonymousName, Functional] =>
-        val fnNames = toSet(r.firstSet)
-        
-        // For each name, intersect together all of its overloading types.
-        fnNames.flatMap(x => x match {
-          
-          // Make sure this is actually a name.
-          case x: IdOrOpOrAnonymousName => 
-            val fns: Set[Functional] = toSet(r.matchFirst(x).asInstanceOf[JSet[Functional]])
-            val oTypes =
-              fns.map(STypesUtil.makeArrowFromFunctional(_).asInstanceOf[Type])
-            val fnType = NF.makeIntersectionType(oTypes)
-            Some(TypeBinding(x, fnType, Modifiers.None, false))
-            
-//          case _ => None
-        })
-      
-      case xs:Iterable[_] => xs.flatMap(recur)
-      
+
       case _ => Nil
-      
-    }) match { // Guarantee that a Collection is returned.
-      case bs:Collection[TypeBinding] => bs
+    }) match{
+      case bs:Iterable[TypeBinding] => bs
       case b:TypeBinding => List(b)
     }
   }
+  
+//  def extractEnvBindings(m: JMap[Id, Variable]): Iterable[TypeBinding] = toMap(m).flatMap(xv =>{ 
+//    xv match{
+//      case (x:Id, v:DeclaredVariable) => extractEnvBindings(v.ast)
+//      case (x:Id, v:SingletonVariable) =>
+//        extractEnvBindings(NF.makeLValue(x, v.declaringTrait))
+//      case (x:Id, v:ParamVariable) =>  extractEnvBindings(v.ast)
+//    }
+//  })
+  
+//  def extractEnvBindings(m: JMap[Id, TypeConsIndex]): Iterable[TypeBinding] = toMap(m).flatMap(xv => {
+//    xv match {
+//      // Bind object names to their types.
+//      case (x:Id, v:ObjectTraitIndex) =>
+//        val decl = v.ast
+//        val params = toOption(NU.getParams(decl))
+//        val sparams = NU.getStaticParams(decl)
+//        val objType = params match {
+//          case None if sparams.isEmpty =>
+//            // Just a single trait type.
+//            NF.makeTraitType(x)
+//          case None =>
+//            // A generic trait type.
+//            NF.makeGenericSingletonType(x, sparams)
+//          case Some(params) if sparams.isEmpty =>
+//            // Arrow type for basic constructor.
+//            NF.makeArrowType(NU.getSpan(x),
+//                             STypesUtil.makeDomainType(toList(params)),
+//                             NF.makeTraitType(x))
+//          case Some(params) =>
+//            // Generic arrow type for constructor.
+//            val sargs = toList(sparams).map(STypesUtil.staticParamToArg)
+//            NF.makeArrowType(NU.getSpan(decl),
+//                             false,
+//                             STypesUtil.makeDomainType(toList(params)),
+//                             NF.makeTraitType(x, toJavaList(sargs)),
+//                             NF.emptyEffect, // TODO: Change this?
+//                             sparams,
+//                             NU.getWhereClause(decl))
+//        }
+//        List(TypeBinding(x, objType, Modifiers.None, false))
+//    }
+//  })
+  
+  def extractEnvBindings(r: Relation[IdOrOpOrAnonymousName, Functional]): Iterable[TypeBinding] = {
+    val fnNames = toSet(r.firstSet)     
+    // For each name, intersect together all of its overloading types.
+    fnNames.flatMap(x => {
+        val fns: Set[Functional] = toSet(r.matchFirst(x).asInstanceOf[JSet[Functional]])
+        val oTypes =
+          fns.map(STypesUtil.makeArrowFromFunctional(_).asInstanceOf[Type])
+        val fnType = NF.makeIntersectionType(oTypes)
+        Some(TypeBinding(x, fnType, Modifiers.None, false))
+    })
+  }
+  
+  def make(comp: CompilationUnitIndex): STypeEnv = {
+    EmptySTypeEnv//.extendWith(comp.functions)
+     // .extendWith(comp.variables)
+      //.extendWith(comp.typeConses)
+  }
 }

trunk/ProjectFortress/src/com/sun/fortress/scala_src/typechecker/staticenv/StaticEnv.scala

@@ -18 +18 @@
 package com.sun.fortress.scala_src.typechecker.staticenv
 
+import _root_.java.util.{Map => JMap}
 import com.sun.fortress.nodes.Name
+import com.sun.fortress.nodes.Node
 import com.sun.fortress.nodes.Type
+import edu.rice.cs.plt.collect.Relation
 
 /**
@@ -25 +28 @@
  * variable names to some value. Each static environment contains 
  */
-trait StaticEnv[T] extends Collection[StaticBinding[T]] {
+trait StaticEnv[T] extends Iterable[StaticBinding[T]] {
   
   /** Define Env as the type of the implementing class. */
@@ -41 +44 @@
    *         `node` combined.
    */
-  def extendWith(node: Any): Env
+
   
   /**
@@ -61 +64 @@
    */
   def getType(x: Name): Option[Type]
+  
+  /** Not in Iterable, but specify size. */
+  def size: Int
   
   /** Make the type on `Collection.elements` more specific. */
@@ -123 +129 @@
   /**
    * Extracts all the _immediate_ bindings for this kind of environment from the
-   * given node. If `node` is a collection of nodes, then this method returns
-   * the concatenation of all bindings found therein. Any bindings located
-   * further inside the node will not be extracted.
+   * given node. Any bindings located further inside the node will not be
+   * extracted.
    * 
-   * @param node A node or collection of nodes in which to extract bindings.
+   * @param node A node in which to extract bindings.
    * @return A collection of all the bindings extracted in the given node.
    */
-  protected def extractEnvBindings(node: Any): Collection[EnvBinding]
+  protected def extractEnvBindings(node: Node): Iterable[EnvBinding]
+  
+  /**
+   * Extracts all the _immediate_ bindings for this kind of environment from the
+   * given nodes. Any bindings located further inside the nodes will not be
+   * extracted. This overloading simply flatMaps the other overloading for
+   * convenience.
+   * 
+   * @param nodes A collection of nodes in which to extract bindings.
+   * @return A collection of all the bindings extracted in the given node.
+   */
+  protected def extractEnvBindings(nodes: Iterable[Node])
+                                   : Iterable[EnvBinding] =
+    nodes.flatMap(extractEnvBindings)
   
   /**
@@ -139 +157 @@
    * @return A new instance of Env containing these bindings.
    */
-  def make(node: Any): Env
+  def empty(): Env
+  
 }