Changeset 3783

Timestamp:

05/31/09 04:41:05 (6 months ago)

Author:

sukyoungryu

Message:

[static checker] Implemented static overloading checking of dotted method declarations with simple generics. Moved exclusion checking in Java code to the Scala checker. Eliminated calls of InterpreterBug?.bug in the static checker in Scala. Added a test.

Location:

trunk/ProjectFortress

Files:

• compiler_tests/Compiled6.i.fss (added)
• compiler_tests/XXX6i.test (added)
• src/com/sun/fortress/compiler/StaticChecker.java (modified) (1 diff)
• src/com/sun/fortress/compiler/typechecker/InferenceVarInserter.java (modified) (1 diff)
• src/com/sun/fortress/compiler/typechecker/TypeAnalyzer.java (modified) (2 diffs)
• src/com/sun/fortress/scala_src/typechecker/CoercionOracle.scala (modified) (1 diff)
• src/com/sun/fortress/scala_src/typechecker/ExclusionOracle.scala (modified) (4 diffs)
• src/com/sun/fortress/scala_src/typechecker/ExportChecker.scala (modified) (2 diffs)
• src/com/sun/fortress/scala_src/typechecker/OverloadingChecker.scala (modified) (12 diffs)
• src/com/sun/fortress/scala_src/typechecker/STypeChecker.scala (modified) (4 diffs)
• test (modified) (2 diffs)
• tests/Reversals.fss (modified) (1 diff)

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

@@ -220 +220 @@
 
                 if (Shell.testCoercion()) { new CoercionTest(typeChecker).run(); }
-                    
+
                 component_ast = typeChecker.check(component_ast);
                 result = new TypeCheckerResult(component_ast,

trunk/ProjectFortress/src/com/sun/fortress/compiler/typechecker/InferenceVarInserter.java

@@ -1 +1 @@
 /*******************************************************************************
-    Copyright 2008 Sun Microsystems, Inc.,
+    Copyright 2009 Sun Microsystems, Inc.,
     4150 Network Circle, Santa Clara, California 95054, U.S.A.
     All rights reserved.

trunk/ProjectFortress/src/com/sun/fortress/compiler/typechecker/TypeAnalyzer.java

@@ -141 +141 @@
     public TraitTable traitTable() { return _table; }
 
+    public TypeEnv typeEnv() { return _typeEnv; }
+
     private TypeAnalyzer(TraitTable table, TypeEnv typeEnv,
             SubtypeCache parentCache) {
@@ -218 +220 @@
         public Type value(Type t) { return normalize(t); }
     };
-
-    /* Checks whether two given types are exclusive. */
-    /* Invariant: two types are not equal. */
-    public boolean exclusion(Type s, Type t) {
-        return exc(normalize(s), normalize(t));
-    }
-
-    /* The following TypeConsIndex's are not checked:
-     *     TypeAliasIndex
-     *     Dimension
-     *     Unit
-     * TupleType's with varargs parameters or keyword parameters are not supprted.
-     */
-    private boolean exc(Type s, Type t) {
-        if ( s instanceof TraitType && t instanceof TraitType ) {
-            TraitType ss = (TraitType)s;
-            TraitType tt = (TraitType)t;
-            Option<TypeConsIndex> firstInd  = _table.typeCons(ss.getName());
-            Option<TypeConsIndex> secondInd = _table.typeCons(tt.getName());
-            if ( firstInd.isNone() )
-                throw new IllegalArgumentException("Unrecognized name: " +
-                                                   ss.getName());
-            else if ( secondInd.isNone() )
-                throw new IllegalArgumentException("Unrecognized name: " +
-                                                   tt.getName());
-            TypeConsIndex first  = firstInd.unwrap();
-            TypeConsIndex second = secondInd.unwrap();
-            if ( first instanceof TraitIndex && second instanceof TraitIndex ) {
-                if ( ! (subtype(ss, tt).isTrue() || subtype(tt, ss).isTrue() ) &&
-                     ( isClosedType(first) || isClosedType(second) ) )
-                    return true;
-                else if ( first  instanceof ProperTraitIndex &&
-                          second instanceof ProperTraitIndex )
-                    return exc(ss, tt, (ProperTraitIndex)second) ||
-                           exc(tt, ss, (ProperTraitIndex)first);
-                else return false;
-            } else return false;
-        } else if ( s instanceof VarType && t instanceof VarType ) {
-            Option<StaticParam> sParam = _typeEnv.staticParam(((VarType)s).getName());
-            Option<StaticParam> tParam = _typeEnv.staticParam(((VarType)t).getName());
-            if ( sParam.isNone() )
-                bug("We are being asked about some type that is not in scope: " +
-                    s + " @ " + NodeUtil.getSpan(s));
-            if ( tParam.isNone() )
-                bug("We are being asked about some type that is not in scope: " +
-                    t + " @ " + NodeUtil.getSpan(t));
-            StaticParam that = sParam.unwrap();
-            if ( NodeUtil.isTypeParam( that ) ) {
-                for ( BaseType ty : that.getExtendsClause() ) {
-                    if ( exclusion(ty, t) ) return true;
-                }
-            }
-            that = tParam.unwrap();
-            if ( NodeUtil.isTypeParam( that ) ) {
-                for ( BaseType ty : that.getExtendsClause() ) {
-                    if ( exclusion(s, ty) ) return true;
-                }
-            }
-            return false;
-        } else if ( s instanceof VarType ) {
-            Option<StaticParam> param = _typeEnv.staticParam(((VarType)s).getName());
-            if ( param.isNone() )
-                bug("We are being asked about some type that is not in scope: " +
-                    s + " @ " + NodeUtil.getSpan(s));
-            StaticParam that = param.unwrap();
-            if ( NodeUtil.isTypeParam( that ) ) {
-                for ( BaseType ty : that.getExtendsClause() ) {
-                    if ( exclusion(ty, t) ) return true;
-                }
-            }
-            return false;
-        } else if ( t instanceof VarType ) {
-            Option<StaticParam> param = _typeEnv.staticParam(((VarType)t).getName());
-            if ( param.isNone() )
-                bug("We are being asked about some type that is not in scope: " +
-                    t + " @ " + NodeUtil.getSpan(t));
-            StaticParam that = param.unwrap();
-            if ( NodeUtil.isTypeParam( that ) ) {
-                for ( BaseType ty : that.getExtendsClause() ) {
-                    if ( exclusion(s, ty) ) return true;
-                }
-            }
-            return false;
-        } else if ( s instanceof TupleType && t instanceof TupleType ) {
-            TupleType ss = (TupleType)s;
-            TupleType tt = (TupleType)t;
-            return ( ss.getVarargs().isNone() && tt.getVarargs().isNone() &&
-                     ss.getKeywords().isEmpty() && tt.getKeywords().isEmpty() &&
-                     ss.getElements().size() == tt.getElements().size() &&
-                     existExc(ss.getElements(), tt.getElements()) );
-        } else return false;
-    }
-
-    /* A type is a closed type if and only if
-     * it is an object trait type or
-     * it is a trait type with a comprises clause containing only closed types.
-     */
-    private boolean isClosedType(TypeConsIndex s) {
-        if ( s instanceof ObjectTraitIndex ) return true;
-        else if ( s instanceof ProperTraitIndex ) {
-            Set<TraitType> comprises = ((ProperTraitIndex)s).comprisesTypes();
-            if ( comprises.isEmpty() ) return false;
-            for ( TraitType t : comprises ) {
-                Option<TypeConsIndex> index  = _table.typeCons(t.getName());
-                if ( index.isNone() )
-                    throw new IllegalArgumentException("Unrecognized name: " +
-                                                       t.getName());
-                if ( ! isClosedType(index.unwrap()) ) return false;
-            }
-            return true;
-        } else return false;
-    }
-
-    /* Invariant: two lists of types are the same length. */
-    private boolean existExc(List<Type> ss, List<Type> tt) {
-        int i = 0;
-        for ( Type s : ss ) {
-            if ( exclusion(s, tt.get(i++)) ) return true;
-        }
-        return false;
-    }
-
-    /* Exists "tau" in "[X |-> ty...]S" such that "s" is a subtype of "tau"
-     * where "t" is "T[\ty...\]" and "trait T[\X...\] ... excludes S ... end"
-     */
-    private boolean exc(TraitType s, TraitType t, ProperTraitIndex tIndex) {
-        // staticParams: X...
-        List<StaticParam> staticParams = tIndex.staticParameters();
-        // staticArgs  : ty...
-        List<StaticArg>   staticArgs   = t.getArgs();
-        if ( staticParams.size() != staticArgs.size() )
-            bug("The numbers of static parameters and static arguments do not match: " + t);
-        // subst       : [X |-> ty ...]
-        final Map<IdOrOp,Type> subst = new HashMap<IdOrOp,Type>();
-        int i = 0;
-        for ( StaticParam sp : staticParams ) {
-            StaticArg arg = staticArgs.get(i++);
-            if ( arg instanceof TypeArg )
-                subst.put(sp.getName(), ((TypeArg)arg).getTypeArg());
-        }
-        // excludes    : S
-        Set<TraitType> excludes = tIndex.excludesTypes();
-        // [X |-> ty ...]S
-        for ( TraitType tau : excludes ) {
-            excludes.remove(tau);
-            excludes.add((TraitType)tau.accept(new NodeUpdateVisitor() {
-                        @Override
-                        public Node forVarTypeOnly(VarType that, TypeInfo info, Id name) {
-                            if ( subst.containsKey(name) ) {
-                                return subst.get(name);
-                            } else return bug("Type variable " + that + " is unbound.");
-                        }
-                }));
-        }
-        // Exists "tau" in "[X |-> ty ...]S" such that "s" is a subtype of "tau"
-        for ( TraitType tau : excludes ) {
-            if ( subtype(s, tau).isTrue() ) return true;
-        }
-        return false;
-    }
 
     /**

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

@@ -36 +36 @@
 class CoercionOracleFactory(traits: TraitTable, analyzer: TypeAnalyzer, errors: ErrorLog) {
   val coercionTable = makeCoercionTable()
-  val exclusionOracle = new ExclusionOracle(analyzer)
+  val exclusionOracle = new ExclusionOracle(analyzer, errors)
 
   private def makeCoercionTable() = {

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

@@ -19 +19 @@
 
 import _root_.java.util.ArrayList
+import _root_.java.util.{HashMap => JavaHashMap}
 import _root_.java.util.{List => JavaList}
 import _root_.java.util.{Set => JavaSet}
@@ -25 +26 @@
 import com.sun.fortress.compiler.GlobalEnvironment
 import com.sun.fortress.compiler.index.ComponentIndex
+import com.sun.fortress.compiler.index.ObjectTraitIndex
+import com.sun.fortress.compiler.index.ProperTraitIndex
+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.InterpreterBug
 import com.sun.fortress.exceptions.StaticError
 import com.sun.fortress.exceptions.TypeError
@@ -37 +40 @@
 import com.sun.fortress.repository.FortressRepository
 import com.sun.fortress.scala_src.useful._
+import com.sun.fortress.scala_src.useful.ErrorLog
 import com.sun.fortress.scala_src.useful.Lists._
 import com.sun.fortress.scala_src.useful.Options._
@@ -42 +46 @@
 import com.sun.fortress.scala_src.nodes._
 
-class ExclusionOracle(typeAnalyzer: TypeAnalyzer) {
-    /* Checks the overloading rule: exclusion
-     * Invariant: firstParam is not equal to secondParam
-     * The following types are not yet supported:
-     *     Types tagged with dimensions or units
-     *     Effects on arrow types
-     *     Keyword parameters and varargs parameters
-     *     Intersection types
-     *     Union types
-     *     Fixed-point types
-     */
-    def excludes(first: Type, second: Type): Boolean =
-        (first, second) match {
-            case (SBottomType(_), _) => true
-            case (_, SBottomType(_)) => true
-            case (SAnyType(_), _) => false
-            case (_, SAnyType(_)) => false
-            case (SVarType(_,_,_), _) =>
-                typeAnalyzer.exclusion(first, second)
-            case (_, SVarType(_,_,_)) =>
-                typeAnalyzer.exclusion(first, second)
-            case (SArrowType(_,_,_,_), SArrowType(_,_,_,_)) => false
-            case (SArrowType(_,_,_,_), _) => true
-            case (_, SArrowType(_,_,_,_)) => true
-            case (f@STupleType(_,_,_,_), s@STupleType(_,_,_,_)) =>
-                NodeUtil.differentArity(f, s) || typeAnalyzer.exclusion(f, s)
-            case (STupleType(_,_,_,_) ,_) => true
-            case (_, STupleType(_,_,_,_)) => true
-            case _ => typeAnalyzer.exclusion(first, second)
-    }
-
+/*
+ * ToDo: Unlike subtyping checking, all the other checking such as
+ * exclusion checking and meet and join operations are not cached.
+ * We'll cache the results of those questions later.
+ */
+class ExclusionOracle(typeAnalyzer: TypeAnalyzer, errors: ErrorLog) {
+  /* Checks the overloading rule: exclusion
+   * Invariant: firstParam is not equal to secondParam
+   * The following types are not yet supported:
+   *     Types tagged with dimensions or units
+   *     Effects on arrow types
+   *     Keyword parameters and varargs parameters
+   *     Intersection types
+   *     Union types
+   *     Fixed-point types
+   * The following TypeConsIndex's are not checked:
+   *     TypeAliasIndex
+   *     Dimension
+   *     Unit
+   * TupleType's with varargs parameters or keyword parameters are not supprted.
+   */
+  def excludes(first: Type, second: Type): Boolean =
+    ( typeAnalyzer.normalize(first), typeAnalyzer.normalize(second) ) match {
+      case (SBottomType(_), _) => true
+      case (_, SBottomType(_)) => true
+      case (SAnyType(_), _) => false
+      case (_, SAnyType(_)) => false
+      case (f@SVarType(_,_,_), s@SVarType(_,_,_)) =>
+        ( toOption(typeAnalyzer.typeEnv.staticParam(f.getName)),
+          toOption(typeAnalyzer.typeEnv.staticParam(s.getName)) ) match {
+          case (Some(fp), Some(sp)) =>
+            var result = false
+            if ( NodeUtil.isTypeParam( fp ) ) {
+              for ( ty <- toList(fp.getExtendsClause) ; if ! result ) {
+                if ( excludes(ty, s) ) result = true
+              }
+            }
+            if ( NodeUtil.isTypeParam( sp ) ) {
+              for ( ty <- toList(sp.getExtendsClause) ; if ! result ) {
+                if ( excludes(ty, f) ) result = true
+              }
+            }
+            result
+          case (None, Some(_)) =>
+            errors.signal("We are being asked about some type that is not in scope:\n    " +
+                          f, NodeUtil.getSpan(f))
+            false
+          case (_, None) =>
+            errors.signal("We are being asked about some type that is not in scope:\n    " +
+                          s, NodeUtil.getSpan(s))
+            false
+          case _ =>
+            errors.signal("We are being asked about some type that is not in scope:\n    " +
+                          f, NodeUtil.getSpan(f))
+            errors.signal("We are being asked about some type that is not in scope:\n    " +
+                          s, NodeUtil.getSpan(s))
+            false
+        }
+      case (f@SVarType(_,_,_), _) =>
+        toOption(typeAnalyzer.typeEnv.staticParam(f.getName)) match {
+          case Some(fp) =>
+            var result = false
+            if ( NodeUtil.isTypeParam( fp ) ) {
+              for ( ty <- toList(fp.getExtendsClause) ; if ! result ) {
+                if ( excludes(ty, second) ) result = true
+              }
+            }
+            result
+          case _ =>
+            errors.signal("We are being asked about some type that is not in scope:\n    " +
+                          f, NodeUtil.getSpan(f))
+            false
+        }
+      case (_, s@SVarType(_,_,_)) =>
+        toOption(typeAnalyzer.typeEnv.staticParam(s.getName)) match {
+          case Some(sp) =>
+            var result = false
+            if ( NodeUtil.isTypeParam( sp ) ) {
+              for ( ty <- toList(sp.getExtendsClause) ; if ! result ) {
+                if ( excludes(ty, first) ) result = true
+              }
+            }
+            result
+          case _ =>
+            errors.signal("We are being asked about some type that is not in scope:\n    " +
+                          s, NodeUtil.getSpan(s))
+            false
+        }
+      case (SArrowType(_,_,_,_), SArrowType(_,_,_,_)) => false
+      case (SArrowType(_,_,_,_), _) => true
+      case (_, SArrowType(_,_,_,_)) => true
+      case (f@STupleType(_,_,_,_), s@STupleType(_,_,_,_)) =>
+        NodeUtil.differentArity(f, s) || {
+          f.getVarargs.isNone && s.getVarargs.isNone &&
+          f.getKeywords.isEmpty && s.getKeywords.isEmpty &&
+          f.getElements.size == s.getElements.size &&
+          toList(f.getElements).zip(toList(s.getElements)).exists((e:(Type,Type)) =>
+                                                                  excludes(e._1,e._2))
+        }
+      case (STupleType(_,_,_,_) ,_) => true
+      case (_, STupleType(_,_,_,_)) => true
+      case (f@STraitType(_,_,_,_), s@STraitType(_,_,_,_)) =>
+        ( toOption(typeAnalyzer.traitTable.typeCons(f.getName)),
+          toOption(typeAnalyzer.traitTable.typeCons(s.getName)) ) match {
+          case (Some(fi), Some(si)) =>
+            ( NodeUtil.isTraitOrObject(fi), NodeUtil.isTraitOrObject(si) ) match {
+              case (true, true) =>
+                if ( ! (typeAnalyzer.subtype(f, s).isTrue ||
+                        typeAnalyzer.subtype(s, f).isTrue ) &&
+                     ( isClosedType(fi) || isClosedType(si) ) )
+                  return true
+                else if ( fi.isInstanceOf[ProperTraitIndex] &&
+                          si.isInstanceOf[ProperTraitIndex] )
+                  excludes(f, s, si.asInstanceOf[ProperTraitIndex]) ||
+                  excludes(s, f, fi.asInstanceOf[ProperTraitIndex])
+                else false
+              case _ => false
+            }
+          case (None, Some(_)) =>
+            errors.signal("Unrecognized name: " + f.getName, NodeUtil.getSpan(f))
+            false
+          case (_, None) =>
+            errors.signal("Unrecognized name: " + s.getName, NodeUtil.getSpan(s))
+            false
+          case _ =>
+            errors.signal("Unrecognized name: " + f.getName, NodeUtil.getSpan(f))
+            errors.signal("Unrecognized name: " + s.getName, NodeUtil.getSpan(s))
+            false
+        }
+      case _ => false
+    }
+
+  /* Exists "tau" in "[X |-> ty...]S" such that "s" is a subtype of "tau"
+   * where "t" is "T[\ty...\]" and "trait T[\X...\] ... excludes S ... end"
+   */
+  private def excludes(s: TraitType, t: TraitType, tIndex: ProperTraitIndex) = {
+    // staticParams: X...
+    val staticParams = toList(tIndex.staticParameters)
+    // staticArgs  : ty...
+    val staticArgs   = toList(t.getArgs)
+    if ( staticParams.size != staticArgs.size )
+      errors.signal("The numbers of static parameters and static arguments do not match: " + t,
+                    NodeUtil.getSpan(t))
+    // subst       : [X |-> ty ...]
+    val subst = new JavaHashMap[IdOrOp,Type]()
+    staticParams.zip(staticArgs).foreach( (pair:(StaticParam,StaticArg)) =>
+                                          if ( pair._2.isInstanceOf[TypeArg] )
+                                            subst.put(pair._1.getName,
+                                                      pair._2.asInstanceOf[TypeArg].getTypeArg) )
+    // excludes    : S
+    var excludes: Set[TraitType] = toSet(tIndex.excludesTypes)
+    // [X |-> ty ...]S
+    def saSubst(sa: StaticArg): StaticArg = sa match {
+      case STypeArg(i,t) => STypeArg(i, tySubst(t) )
+      case _ => sa
+    }
+    def spSubst(sp: StaticParam): StaticParam = sp match {
+      case SStaticParam(i,n,e,d,a,k) =>
+        SStaticParam(i, n, e.map(tySubst).asInstanceOf[List[BaseType]], d, a, k)
+    }
+    def tySubst(tau: Type): Type = tau match {
+      case SVarType(_,name,_) =>
+        if ( subst.containsKey(name) ) subst.get(name)
+        else {
+          errors.signal("Type variable " + tau + " is unbound.", NodeUtil.getSpan(tau))
+          tau
+        }
+      case STraitType(i,n,a,p) => STraitType(i, n, a.map(saSubst), p.map(spSubst))
+      case STupleType(i,e,v,k) => STupleType(i, e.map(tySubst), v, k)
+      case SArrowType(i,d,r,e) => SArrowType(i, tySubst(d), tySubst(r), e)
+      case _ => tau
+    }
+    excludes = excludes.map( tySubst ).asInstanceOf[Set[TraitType]]
+    var result = false
+    // Exists "tau" in "[X |-> ty ...]S" such that "s" is a subtype of "tau"
+    for ( tau <- excludes ; if ! result ) {
+        if ( typeAnalyzer.subtype(s, tau).isTrue ) result = true
+    }
+    result
+  }
+
+  /* A type is a closed type if and only if
+   * it is an object trait type or
+   * it is a trait type with a comprises clause containing only closed types.
+   */
+  private def isClosedType(s: TypeConsIndex): Boolean =
+    if ( s.isInstanceOf[ObjectTraitIndex] ) true
+    else if ( s.isInstanceOf[ProperTraitIndex] ) {
+      val comprises = toSet(s.asInstanceOf[ProperTraitIndex].comprisesTypes)
+      if ( comprises.isEmpty ) false
+      else {
+        var result = true
+        for ( t <- comprises ; if result ) {
+          toOption(typeAnalyzer.traitTable.typeCons(t.getName)) match {
+            case None =>
+              errors.signal("Unrecognized name: " + t.getName, NodeUtil.getSpan(t))
+            case Some(ind) =>
+              if ( ! isClosedType(ind) ) result = false
+          }
+        }
+        result
+      }
+    } else false
 }

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

@@ -31 +31 @@
 import com.sun.fortress.compiler.index.{Constructor => JavaConstructor}
 import com.sun.fortress.compiler.index.{DeclaredFunction => JavaDeclaredFunction}
+import com.sun.fortress.compiler.index.{DeclaredMethod => JavaDeclaredMethod}
+import com.sun.fortress.compiler.index.{FieldGetterMethod => JavaFieldGetterMethod}
+import com.sun.fortress.compiler.index.{FieldSetterMethod => JavaFieldSetterMethod}
 import com.sun.fortress.compiler.index.{DeclaredVariable => JavaDeclaredVariable}
 import com.sun.fortress.compiler.index.{Dimension => JavaDimension}
@@ -713 +716 @@
 object FunctionalMethod {
     def unapply(function:JavaFunctionalMethod) =
-        Some(function.ast, function.declaringTrait)
+        Some((function.ast, function.declaringTrait))
     def apply(fndecl:FnDecl, id:Id) =
         new JavaFunctionalMethod(fndecl, id)
 }
+
+object DeclaredMethod {
+    def unapply(method:JavaDeclaredMethod) =
+        Some((method.ast, method.getDeclaringTrait))
+    def apply(fndecl:FnDecl, id:Id) =
+        new JavaDeclaredMethod(fndecl, id)
+}
+
+object FieldGetterMethod {
+    def unapply(method:JavaFieldGetterMethod) =
+        Some((method.ast, method.getDeclaringTrait))
+    def apply(binding:Binding, id:Id) =
+        new JavaFieldGetterMethod(binding, id)
+}
+
+object FieldSetterMethod {
+    def unapply(method:JavaFieldSetterMethod) =
+        Some((method.ast, method.getDeclaringTrait))
+    def apply(binding:Binding, id:Id) =
+        new JavaFieldSetterMethod(binding, id)
+}

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

@@ -27 +27 @@
 import com.sun.fortress.compiler.index.TraitIndex
 import com.sun.fortress.compiler.index.{Function => JavaFunction}
+import com.sun.fortress.compiler.index.{Functional => JavaFunctional}
+import com.sun.fortress.compiler.index.{Method => JavaMethod}
 import com.sun.fortress.compiler.typechecker.TypeAnalyzer
 import com.sun.fortress.exceptions.InterpreterBug
@@ -60 +62 @@
                          repository: FortressRepository) {
 
-    val typeAnalyzer = TypeAnalyzer.make(new TraitTable(compilation_unit, globalEnv))
-    val exclusionOracle = new ExclusionOracle(typeAnalyzer)
+    var typeAnalyzer = TypeAnalyzer.make(new TraitTable(compilation_unit, globalEnv))
     var errors = List[StaticError]()
 
@@ -70 +71 @@
         val fnsInComp = compilation_unit.functions
         for ( f <- toSet(fnsInComp.firstSet) ; if isDeclaredName(f) ) {
-            checkOverloading(f, fnsInComp.matchFirst(f))
+            checkOverloading(f, toSet(fnsInComp.matchFirst(f)).asInstanceOf[Set[JavaFunctional]])
         }
         val typesInComp = compilation_unit.typeConses
@@ -94 +95 @@
                 }
             }
-            /*
-            val methods = typesInComp.get(t).asInstanceOf[TraitIndex].dottedMethods
+            val methods = traitOrObject.dottedMethods
+            val staticParameters = new ArrayList[StaticParam]()
+            // Add static parameters of the enclosing trait or object
+            staticParameters.addAll( traitOrObject.staticParameters )
+            // Extend the type analyzer with the collected static parameters
+            val oldTypeAnalyzer = typeAnalyzer
             for ( f <- toSet(methods.firstSet) ; if isDeclaredName(f) ) {
-                checkOverloading(f, methods.matchFirst(f).asInstanceOf[JavaSet[JavaFunctional]])
-            }
-            */
+                typeAnalyzer = typeAnalyzer.extend(staticParameters, none[WhereClause])
+                checkOverloading(f, toSet(methods.matchFirst(f)).asInstanceOf[Set[JavaFunctional]])
+            }
+            typeAnalyzer = oldTypeAnalyzer
         }
         toJavaList(errors)
@@ -106 +112 @@
     /* Checks the validity of the overloaded function declarations. */
     private def checkOverloading(name: IdOrOpOrAnonymousName,
-                                 set: JavaSet[JavaFunction]) = {
-        var signatures = List[((Type,Type),Span)]()
-        for ( f <- toSet(set) ; if isDeclaredFunction(f) ) {
+                                 set: Set[JavaFunctional]) = {
+        var signatures = List[((JavaList[StaticParam],Type,Type),Span)]()
+        for ( f <- set ; if isDeclaredFunctional(f) ) {
             val result = f.getReturnType
             val param = paramsToType(f.parameters, f.getSpan)
-            signatures.find(p => p._1 == (param,result)) match {
+            val sparams = f.staticParameters
+            signatures.find(p => p._1 == (sparams,param,result)) match {
                 case Some((_,span)) =>
                     error(mergeSpan(span, f.getSpan),
@@ -118 +125 @@
                           param + " -> " + result)
                 case _ =>
-                    signatures = ((param, result), f.getSpan) :: signatures
+                    signatures = ((sparams, param, result), f.getSpan) :: signatures
             }
         }
@@ -140 +147 @@
 
     /* Checks the overloading rules: subtype / exclusion / meet */
-    private def validOverloading(first: ((Type,Type),Span),
-                                 second: ((Type,Type),Span),
-                                 set: List[((Type,Type),Span)]) =
+    private def validOverloading(first: ((JavaList[StaticParam],Type,Type),Span),
+                                 second: ((JavaList[StaticParam],Type,Type),Span),
+                                 set: List[((JavaList[StaticParam],Type,Type),Span)]) =
         subtype(first, second) || subtype(second, first) ||
         exclusion(first, second) || meet(first, second, set)
 
     /* Checks the overloading rule: subtype */
-    private def subtype(newTypeAnalyzer: TypeAnalyzer, f: JavaFunction,
-                        g: JavaFunction): Boolean =
-        subtype(newTypeAnalyzer, paramsToType(g.parameters, g.getSpan),
+    private def subtype(f: JavaFunction, g: JavaFunction): Boolean =
+        subtype(paramsToType(g.parameters, g.getSpan),
                 paramsToType(f.parameters, f.getSpan)) &&
-        subtype(newTypeAnalyzer, f.getReturnType, g.getReturnType)
-
-    private def subtype(newTypeAnalyzer: TypeAnalyzer, sub_type: Type,
-                        super_type: Type): Boolean =
-        newTypeAnalyzer.subtype(sub_type, super_type).isTrue
+        subtype(f.getReturnType, g.getReturnType)
 
     private def subtype(sub_type: Type, super_type: Type): Boolean =
-        subtype(typeAnalyzer, sub_type, super_type)
-
-    private def subtype(sub_type: ((Type,Type),Span),
-                        super_type: ((Type,Type),Span)): Boolean =
-        subtype(super_type._1._1, sub_type._1._1) &&
-        subtype(sub_type._1._2, super_type._1._2)
+        typeAnalyzer.subtype(sub_type, super_type).isTrue
+
+    private def subtype(sub_type: ((JavaList[StaticParam],Type,Type),Span),
+                        super_type: ((JavaList[StaticParam],Type,Type),Span)): Boolean = {
+        val oldTypeAnalyzer = typeAnalyzer
+        // Add static parameters of the method
+        val staticParameters = new ArrayList[StaticParam]()
+        staticParameters.addAll(sub_type._1._1)
+        staticParameters.addAll(super_type._1._1)
+        typeAnalyzer = typeAnalyzer.extend(staticParameters, none[WhereClause])
+        val result = subtype(super_type._1._2, sub_type._1._2) &&
+                     subtype(sub_type._1._3, super_type._1._3)
+        typeAnalyzer = oldTypeAnalyzer
+        result
+    }
 
     /* Checks the overloading rule: exclusion
@@ -175 +186 @@
      *     Fixed-point types
      */
-    private def exclusion(first: ((Type,Type),Span),
-                          second: ((Type,Type),Span)): Boolean =
-        exclusionOracle.excludes(first._1._1, second._1._1)
+    private def exclusion(first: ((JavaList[StaticParam],Type,Type),Span),
+                          second: ((JavaList[StaticParam],Type,Type),Span)): Boolean = {
+        val oldTypeAnalyzer = typeAnalyzer
+        // Add static parameters of the method
+        val staticParameters = new ArrayList[StaticParam]()
+        staticParameters.addAll(first._1._1)
+        staticParameters.addAll(second._1._1)
+        typeAnalyzer = typeAnalyzer.extend(staticParameters, none[WhereClause])
+        val result = new ExclusionOracle(typeAnalyzer,
+                                         new ErrorLog()).excludes(first._1._2,
+                                                                  second._1._2)
+        typeAnalyzer = oldTypeAnalyzer
+        result
+    }
 
     /* Checks the overloading rule: meet */
     /* Not yet fully implemented... */
-    private def meet(first: ((Type,Type),Span), second: ((Type,Type),Span),
-                     set: List[((Type,Type),Span)]) = {
+    private def meet(first: ((JavaList[StaticParam],Type,Type),Span),
+                     second: ((JavaList[StaticParam],Type,Type),Span),
+                     set: List[((JavaList[StaticParam],Type,Type),Span)]) = {
+        val oldTypeAnalyzer = typeAnalyzer
+        // Add static parameters of the method
+        val staticParameters = new ArrayList[StaticParam]()
+        staticParameters.addAll(first._1._1)
+        staticParameters.addAll(second._1._1)
+        typeAnalyzer = typeAnalyzer.extend(staticParameters, none[WhereClause])
         var result = false
-        val meet = (reduce(typeAnalyzer.meet(first._1._1, second._1._1)),
-                    reduce(typeAnalyzer.meet(first._1._2, second._1._2)))
+        val meet = (reduce(typeAnalyzer.meet(first._1._2, second._1._2)),
+                    reduce(typeAnalyzer.meet(first._1._3, second._1._3)))
         for ( f <- set ; if ! result )
-            if ( subtype(f._1._1, meet._1) &&
-                 subtype(meet._1, f._1._1) &&
-                 subtype(meet._2, f._1._2) &&
-                 subtype(f._1._2, meet._2))
+            if ( subtype(f._1._2, meet._1) &&
+                 subtype(meet._1, f._1._2) &&
+                 subtype(meet._2, f._1._3) &&
+                 subtype(f._1._3, meet._2))
                 result = true
+        typeAnalyzer = oldTypeAnalyzer
         result
     }
@@ -260 +290 @@
         for ( s <- toList(g.staticParameters) ) staticParameters.add(s)
         // Extend the type analyzer with the collected static parameters
-        val newTypeAnalyzer = typeAnalyzer.extend(staticParameters,
-                                                  none[WhereClause])
+        val oldTypeAnalyzer = typeAnalyzer
         // 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
-        subtype(newTypeAnalyzer, f, g)
+        typeAnalyzer = typeAnalyzer.extend(staticParameters, none[WhereClause])
+        val result = subtype(f, g)
+        typeAnalyzer = oldTypeAnalyzer
+        result
     }
 
@@ -273 +305 @@
     }
 
-    def isDeclaredFunction(f: JavaFunction) = f match {
+    def isDeclaredFunctional(f: JavaFunctional) = f match {
         case DeclaredFunction(fd) => true
+        case DeclaredMethod(_,_) => true
         case _ => false
     }
 
-    private def mergeSpan(sub_type: ((Type,Type),Span),
-                          super_type: ((Type,Type),Span)): String =
+    private def mergeSpan(sub_type: ((JavaList[StaticParam],Type,Type),Span),
+                          super_type: ((JavaList[StaticParam],Type,Type),Span)): String =
         mergeSpan(sub_type._2, super_type._2)
 
@@ -288 +321 @@
             second.toString + ":\n" + first.toString
 
-    private def toString(ty: ((Type,Type), Span)): String =
-        ty._1._1 + " -> " + ty._1._2 + " @ " + ty._2
+    private def toString(ty: ((JavaList[StaticParam],Type,Type), Span)): String =
+        ty._1._2 + " -> " + ty._1._3 + " @ " + ty._2
 
     /* Returns the type of the given list of parameters. */
@@ -305 +338 @@
         toOption(param.getIdType) match {
             case Some(ty) => ty
-            case _ => InterpreterBug.bug(param,
-                                         "Type checking couldn't infer the type of " + param)
+            case _ =>
+                toOption(param.getVarargsType) match {
+                    case Some(ty) => ty
+                    case _ =>
+                        val span = NodeUtil.getSpan(param)
+                        error(span.toString,
+                              "Type checking couldn't infer the type of " + param)
+                        NodeFactory.makeVoidType(span)
+                }
         }
 

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

@@ -54 +54 @@
 import com.sun.fortress.scala_src.useful.Lists._
 import com.sun.fortress.scala_src.useful.Options._
-import com.sun.fortress.exceptions.InterpreterBug.bug
 import com.sun.fortress.useful.HasAt
 
@@ -830 +829 @@
             if ( isArrows(first) ) {
               val (arrows,temp) = (first::rest).span(isArrows)
-              val (nonArrows,remainingChunks) = temp.span((e:Expr) => ! isArrows(e)) 
+              val (nonArrows,remainingChunks) = temp.span((e:Expr) => ! isArrows(e))
               chunker(remainingChunks, (arrows,nonArrows)::results)
             } else {
@@ -849 +848 @@
         def associateArrows(fs: List[Expr], oe: Option[Expr]) = oe match {
           case None => fs match {
-            case Nil => bug(expr, "Empty chunk")
+            case Nil =>
+              errors.signal("Empty chunk", expr)
+              expr
             case _ =>
               fs.take(fs.size-1).foldRight(fs.last){ (f: Expr, e: Expr) =>
@@ -887 +888 @@
           // If not, left associate as InfixJuxts
           associatedChunks match {
-            case Nil => bug(expr, "Empty juxt")
+            case Nil =>
+              errors.signal("Empty juxt", expr)
+              expr
             case head::tail =>
               checkExpr(tail.foldLeft(head){ (e1: Expr, e2: Expr) =>

trunk/ProjectFortress/test

@@ -2 +2 @@
 
 ################################################################################
-#    Copyright 2008 Sun Microsystems, Inc.,
+#    Copyright 2009 Sun Microsystems, Inc.,
 #    4150 Network Circle, Santa Clara, California 95054, U.S.A.
 #    All rights reserved.
@@ -21 +21 @@
 SCALAVER=2.7.4
 
-if (uname | egrep -q CYGWIN) ; then 
+if (uname | egrep -q CYGWIN) ; then
   CP="build;$TP/junit/junit.jar;$TP/unsigned/unsigned.jar;$TP/asm/asm-all-3.1.jar;$TP/xtc/xtc.jar;$TP/jsr166y/jsr166y.jar;$TP/plt/plt.jar;$TP/astgen/astgen.jar;$TP/scala/scala-library-$SCALAVER.jar"
 else

trunk/ProjectFortress/tests/Reversals.fss

@@ +1 @@
+(*******************************************************************************
+    Copyright 2009 Sun Microsystems, Inc.,
+    4150 Network Circle, Santa Clara, California 95054, U.S.A.
+    All rights reserved.
+
+    U.S. Government Rights - Commercial software.
+    Government users are subject to the Sun Microsystems, Inc. standard
+    license agreement and applicable provisions of the FAR and its supplements.
+
+    Use is subject to license terms.
+
+    This distribution may include materials developed by third parties.
+
+    Sun, Sun Microsystems, the Sun logo and Java are trademarks or registered
+    trademarks of Sun Microsystems, Inc. in the U.S. and other countries.
+ ******************************************************************************)
+
 component Reversals
 import List.{...}
 export Executable
-
-
 
 run() = do