Changeset 2740

Timestamp:

08/25/08 07:40:29 (15 months ago)

Author:

angelee

Message:

[desugarer] implemented static type parameters captured by object
expression; added more test cases for mutable variables captured by object
expression.

Location:

trunk/ProjectFortress

Files:

• src/com/sun/fortress/compiler/desugarer/FreeNameCollection.java (modified) (3 diffs)
• src/com/sun/fortress/compiler/desugarer/FreeNameCollector.java (modified) (8 diffs)
• src/com/sun/fortress/compiler/desugarer/ObjectExpressionVisitor.java (modified) (14 diffs)
• src/com/sun/fortress/compiler/desugarer/ObjectExpressionVisitorJUTest.java (modified) (1 diff)
• tests/objectCC_mutable.fss (added)
• tests/objectCC_staticParams.fss (modified) (4 diffs)

trunk/ProjectFortress/src/com/sun/fortress/compiler/desugarer/FreeNameCollection.java

@@ -21 +21 @@
 import java.util.List;
 
+import com.sun.fortress.compiler.typechecker.TypeEnv;
 import com.sun.fortress.exceptions.DesugarerError;
+import com.sun.fortress.nodes.BoolParam;
 import com.sun.fortress.nodes.BoolRef;
 import com.sun.fortress.nodes.DimRef;
 import com.sun.fortress.nodes.FnRef;
+import com.sun.fortress.nodes.IntParam;
 import com.sun.fortress.nodes.IntRef;
+import com.sun.fortress.nodes.NatParam;
 import com.sun.fortress.nodes.OpRef;
+import com.sun.fortress.nodes.StaticParam;
 import com.sun.fortress.nodes.Type;
 import com.sun.fortress.nodes.UnitRef;
@@ -113 +118 @@
      * Hence, remove these redundant references from the freeVarRefs.
      */
-    public void removeStaticRefsFromFreeVarRefs() {
+    public void removeStaticRefsFromFreeVarRefs(TypeEnv typeEnv) {
         // need to use a new list; can't just remove the redundant var from
         // the old list, otherwise we get a ConcurrentModificationException.
@@ -119 +124 @@
 
         for(VarRef var : freeVarRefs) {
-            BoolRef b = new BoolRef( var.getVar() );
-            IntRef i = new IntRef( var.getVar() );
-            if( freeBoolRefs.contains(b) == false && 
-                freeIntRefs.contains(i) == false ) {
+            Option<StaticParam> spOp = typeEnv.staticParam( var.getVar() );
+            if( spOp.isNone() ) { // it's not a static param
                 newFreeVarRefs.add(var);
+            } else if( spOp.unwrap() instanceof BoolParam ) {
+                this.add( new BoolRef(var.getSpan(), var.getVar()) ); 
+            } else if( spOp.unwrap() instanceof IntParam ) {
+                this.add( new IntRef(var.getSpan(), var.getVar()) ); 
+            } else if( spOp.unwrap() instanceof NatParam ) {
+                this.add( new IntRef(var.getSpan(), var.getVar()) ); 
+            } else {
+                throw new DesugarerError( "Unexpected Static Param type " +
+                    "found: " + spOp.unwrap() );
             }
         }

trunk/ProjectFortress/src/com/sun/fortress/compiler/desugarer/FreeNameCollector.java

@@ -82 +82 @@
      *     We need this info so that we don't lose the extends clauses on the 
      *     TypeParam when we make the StaticParam list for the lifted ObjExpr 
+     *
+     * Don't need this now that we are passing all static params
+    private Map<Pair<Id,Id>, TypeParam> staticArgToTypeParam;
      */ 
-    private Map<Pair<Id,Id>, TypeParam> staticArgToTypeParam;
 
         
@@ -104 +106 @@
         this.declSiteToVarRefs = 
             new HashMap<Pair<String,Span>, List<Pair<VarRef,Node>>>();
-        this.staticArgToTypeParam = new HashMap<Pair<Id,Id>, TypeParam>();
+        // this.staticArgToTypeParam = new HashMap<Pair<Id,Id>, TypeParam>();
         
                 this.enclosingTraitDecl = null; 
@@ -119 +121 @@
     }
 
+    /* 
     public Map<Pair<Id,Id>, TypeParam> getStaticArgToTypeParam() {
         return staticArgToTypeParam;
-    }
+    } */
 
         @Override
@@ -228 +231 @@
         scopeStack.pop();
 
+        TypeEnv objExprTypeEnv = typeCheckerOutput.getTypeEnv(that);
+
         if( objExprStack.isEmpty() && 
             (enclosingObjectDecl != null || enclosingTraitDecl != null) ) {
             // use the "self" id to get the right type of the
             // enclosing object / trait decl
-            Option<Type> type = 
-                typeCheckerOutput.getTypeEnv(that).type( new Id("self") );
+            Option<Type> type = objExprTypeEnv.type( new Id("self") );
             freeNames.setEnclosingSelfType(type);
         }
@@ -241 +245 @@
         // captured in two different list and is redundant.  Remove them so
         // we don't get a name collision in the lifted ObjectDecl. 
-        freeNames.removeStaticRefsFromFreeVarRefs();
+        freeNames.removeStaticRefsFromFreeVarRefs(objExprTypeEnv);
 
         List<VarRef> mutableVars = 
@@ -476 +480 @@
                     freeNames.add(that);
 
+            /*
+             * Don't need to do this now that we are passing all static
+             * params
             ObjectExpr innerMostObjExpr = objExprStack.peek();
                 TypeEnv objExprTypeEnv = 
@@ -501 +508 @@
             } else {
                 staticArgToTypeParam.put( key, (TypeParam) spOp.unwrap() );
-            }
+            } */
                 }
 
@@ -616 +623 @@
                     DEBUG_LEVEL, "its span is: ", topLevelNode.getSpan());
                 
-                // FIXME: change if going back to Pair<Node,Span> key
-        // FIXME: change when the type checking ppl are done w/ getTypeEnv
                 TypeEnv topLevelEnv = typeCheckerOutput.getTypeEnv(topLevelNode);
 

trunk/ProjectFortress/src/com/sun/fortress/compiler/desugarer/ObjectExpressionVisitor.java

@@ -100 +100 @@
      *     We need this info so that we don't lose the extends clauses on the 
      *     TypeParam when we make the StaticParam list for the lifted ObjExpr 
+     *
+     * This is no longer needed now that we are passing all static params
+    private Map<Pair<Id,Id>, TypeParam> staticArgToTypeParam;
      */
-    private Map<Pair<Id,Id>, TypeParam> staticArgToTypeParam;
 
 
@@ -147 +149 @@
         objExprToFreeNames = freeNameCollector.getObjExprToFreeNames();
         declSiteToVarRefs  = freeNameCollector.getDeclSiteToVarRefs();
-        staticArgToTypeParam = freeNameCollector.getStaticArgToTypeParam();
+        // staticArgToTypeParam = freeNameCollector.getStaticArgToTypeParam();
 
         // No object expression found in this component. We are done.
@@ -290 +292 @@
         if( rewriteList != null ) {
             String uniqueSuffix = "";
-            if( enclosingObjectDecl != null ) {
-                uniqueSuffix += enclosingObjectDecl.getName().getText();
+            Id enclosingId = getEnclosingTraitObjectName();
+
+            if( enclosingId != null ) {
+                uniqueSuffix += enclosingId.getText();
             }
             uniqueSuffix += nextUniqueId(); 
@@ -394 +398 @@
         VarRef enclosingSelf = null;
 
-        List<StaticArg> staticArgs = makeStaticArgsToLiftedObj(freeNames);
+        List<StaticArg> staticArgs = 
+                makeStaticArgsToLiftedObj(objExpr, freeNames);
 
         /* Now make the call to construct the lifted object */
@@ -404 +409 @@
         if (freeMethodRefs != null && freeMethodRefs.size() != 0) {
             enclosingSelf = ExprFactory.makeVarRef(span, "self");
-        }
+        } 
 
         List<Expr> exprs = makeArgsForCallToLiftedObj(objExpr,
@@ -416 +421 @@
     }
 
-    private List<StaticArg> 
-    makeStaticArgsToLiftedObj(FreeNameCollection freeNames) {
+    /* 
+     * Turns out that we do need pass all the static params from the outer
+     * enclosing Trait/ObjectDecl, but not just the ones being referenced, 
+     * because otherwise some varRef captured by object expression may have 
+     * types that's not recognized at top level.  Argh.  The old code is 
+     * commented out and left at the end of the file.
+     */ 
+    private List<StaticArg> makeStaticArgsToLiftedObj(ObjectExpr target, 
+                                            FreeNameCollection freeNames) {
         List<BoolRef> boolRefs = freeNames.getFreeBoolRefs();
         List<IntRef> intRefs = freeNames.getFreeIntRefs();
         List<VarType> varTypes = freeNames.getFreeVarTypes();
+        List<StaticParam> sParams = null;
         List<StaticArg> args = new LinkedList<StaticArg>();
-
-        for(BoolRef boolRef : boolRefs) {
-            args.add( new BoolArg(boolRef.getSpan(), boolRef) ); 
-        }
-
-        for(IntRef intRef : intRefs) {
-            args.add( new IntArg(intRef.getSpan(), intRef) );
-        }
-
-        for(VarType varType: varTypes) {
-            args.add( new TypeArg(varType.getSpan(), varType) );
+            
+        if( enclosingTraitDecl != null ) {
+            sParams = enclosingTraitDecl.getStaticParams();
+        } else if( enclosingObjectDecl != null ) {
+            sParams = enclosingObjectDecl.getStaticParams();
+        } else {
+            if( boolRefs.isEmpty() == false ||  // sanity check
+                intRefs.isEmpty() == false || varTypes.isEmpty() == false ) {   
+                throw new DesugarerError( target.getSpan(), 
+                        "Found refences to static params outside " + 
+                        "of Trait/ObjectDecl!");
+            }
+        }
+
+        if( sParams != null) {
+            for(StaticParam sp : sParams) {
+                args.add( makeStaticArgFromStaticParam(sp) ); 
+            }
         }
 
@@ -447 +467 @@
         List<Expr> exprs = new LinkedList<Expr>();
 
-        // FIXME: Need to handle mutated vars
         if(freeVarRefs != null) {
             for(VarRef var : freeVarRefs) {
@@ -504 +523 @@
 
         List<StaticParam> staticParams =
-                makeStaticParamsForLiftedObj(freeNames);
+                makeStaticParamsForLiftedObj(target, freeNames);
 
         if( freeMethodRefs.isEmpty() == false ) {
@@ -531 +550 @@
     }
 
-    private List<StaticParam>
-    makeStaticParamsForLiftedObj(FreeNameCollection freeNames) {
+    /* 
+     * Turns out that we do need pass all the static params from the outer
+     * enclosing Trait/ObjectDecl, but not just the ones being referenced, 
+     * because otherwise some varRef captured by object expression may have 
+     * types that's not recognized at top level.  Argh.  The old code is 
+     * commented out and left at the end of the file.
+     */ 
+    private List<StaticParam> makeStaticParamsForLiftedObj(ObjectExpr target, 
+                                                FreeNameCollection freeNames) {
         List<BoolRef> boolRefs = freeNames.getFreeBoolRefs();
         List<IntRef> intRefs = freeNames.getFreeIntRefs();
         List<VarType> varTypes = freeNames.getFreeVarTypes();
-        List<StaticParam> sParams = new LinkedList<StaticParam>();
-
-        for(BoolRef boolRef : boolRefs) {
-            sParams.add( new BoolParam(boolRef.getSpan(), boolRef.getName()) );
-        }
-        for(IntRef intRef : intRefs) {
-            sParams.add( new IntParam(intRef.getSpan(), intRef.getName()) );
-        }
-        for(VarType varType : varTypes) {
-            Id enclosingId = null;
-            if(enclosingTraitDecl != null){
-                enclosingId = enclosingTraitDecl.getName();
-            } else if(enclosingObjectDecl != null) {
-                enclosingId = enclosingObjectDecl.getName();
-            } else {
-                throw new DesugarerError( varType.getSpan(), "VarType " +
-                        varType + " found outside of Trait/ObjectDecl!" );
-            }
-
-            Pair<Id,Id> key = new Pair<Id,Id>( enclosingId, varType.getName() );
-            TypeParam declSite = staticArgToTypeParam.get(key);
-        
-            if(declSite == null) {
-               throw new DesugarerError( varType.getSpan(), "Cannot find the "
-                            + "decl site of VarType " + varType + " in " + 
-                            "staticArgToTypeParam map!");
-            }
-
-            sParams.add( new TypeParam(varType.getSpan(), varType.getName(), 
-                                       declSite.getExtendsClause(), 
-                                       declSite.isAbsorbs()) );
-        }
-        
-        return sParams;
+        List<StaticParam> sParamsCopy = new LinkedList<StaticParam>();
+        List<StaticParam> sParams = null;
+
+        if( enclosingTraitDecl != null ) {
+            sParams = enclosingTraitDecl.getStaticParams();
+        } else if( enclosingObjectDecl != null ) {
+            sParams = enclosingObjectDecl.getStaticParams();
+        } else {
+            if( boolRefs.isEmpty() == false ||  // sanity check
+                intRefs.isEmpty() == false || varTypes.isEmpty() == false ) {   
+                throw new DesugarerError( target.getSpan(), 
+                        "Found refences to static params outside " + 
+                        "of Trait/ObjectDecl!");
+            }
+        }
+
+        if(sParams != null) {
+            sParamsCopy.addAll(sParams);
+        }
+
+        return sParamsCopy;
     }
 
@@ -576 +589 @@
                            FreeNameCollection freeNames,
                            NormalParam enclosingSelfParam) {
-        // TODO: need to figure out shadowed self via FnRef
-        // need to box any var that's mutabl
 
         Option<Type> type = null;
@@ -585 +596 @@
         List<FnRef> freeFnRefs = freeNames.getFreeFnRefs();
 
-        // FIXME: Need to handle mutated vars
         if(freeVarRefs != null) {
             for(VarRef var : freeVarRefs) {
@@ -634 +644 @@
 
         // Just sanity check
-        if(enclosingTraitDecl == null && enclosingObjectDecl == null) {
+        if( getEnclosingTraitObjectName() == null ) {
             throw new DesugarerError("No enclosing trait or object " +
                         "decl found when a dotted method is referenced.");
@@ -668 +678 @@
 
     // small helper methods
+    private StaticArg makeStaticArgFromStaticParam(StaticParam sParam) {
+        Span span = sParam.getSpan();
+
+        if( sParam instanceof BoolParam ) {
+            BoolRef boolRef = new BoolRef(span, ((BoolParam) sParam).getName());
+            return new BoolArg(span, boolRef);
+        } else if( sParam instanceof IntParam ) {
+            IntRef intRef = new IntRef(span, ((IntParam) sParam).getName());
+            return new IntArg(span, intRef);
+        } else if( sParam instanceof NatParam ) {
+            IntRef intRef = new IntRef(span, ((NatParam) sParam).getName());
+            return new IntArg(span, intRef);
+        } else if( sParam instanceof TypeParam ) {
+            VarType varType = new VarType(span, ((TypeParam) sParam).getName());
+            return new TypeArg(span, varType);
+        } else {
+            throw new DesugarerError(
+                "Unexpected type of Static Param found: " + sParam);
+        }
+    }
+ 
+    private Id getEnclosingTraitObjectName() {
+        Id enclosingId = null;
+        if(enclosingTraitDecl != null){
+            enclosingId = enclosingTraitDecl.getName();
+        } else if(enclosingObjectDecl != null) {
+            enclosingId = enclosingObjectDecl.getName();
+        } 
+
+        return enclosingId;
+    }
+
     private VarRef makeVarRefFromNormalParam(NormalParam param) {
         VarRef varRef = ExprFactory.makeVarRef( param.getSpan(),
@@ -685 +727 @@
     }
 
+
+/************
+ * Some code that I like to keep around - may be useful one day.
+ ************/
+
+    /*
+     * The old code that make static args to pass to the lifted object expr
+     * based on what BoolRefs and IntRefs are captured
+     * 
+    private List<StaticArg> 
+    makeStaticArgsToLiftedObj(FreeNameCollection freeNames) {
+        List<BoolRef> boolRefs = freeNames.getFreeBoolRefs();
+        List<IntRef> intRefs = freeNames.getFreeIntRefs();
+        List<VarType> varTypes = freeNames.getFreeVarTypes();
+        List<StaticArg> args = new LinkedList<StaticArg>();
+
+        for(BoolRef boolRef : boolRefs) {
+            args.add( new BoolArg(boolRef.getSpan(), boolRef) ); 
+        }
+
+        for(IntRef intRef : intRefs) {
+            args.add( new IntArg(intRef.getSpan(), intRef) );
+        }
+
+        for(VarType varType: varTypes) {
+            args.add( new TypeArg(varType.getSpan(), varType) );
+        }
+
+        return args;
+    } */
+
+    /*
+     * The old code that make static type params for the lifted object expr
+     * based on what BoolRefs and IntRefs are captured
+     * 
+    private List<StaticParam>
+    makeStaticParamsForLiftedObj(FreeNameCollection freeNames) {
+        List<BoolRef> boolRefs = freeNames.getFreeBoolRefs();
+        List<IntRef> intRefs = freeNames.getFreeIntRefs();
+        List<VarType> varTypes = freeNames.getFreeVarTypes();
+        List<StaticParam> sParams = new LinkedList<StaticParam>();
+
+        for(BoolRef boolRef : boolRefs) {
+            sParams.add( new BoolParam(boolRef.getSpan(), boolRef.getName()) );
+        }
+        for(IntRef intRef : intRefs) {
+            sParams.add( new IntParam(intRef.getSpan(), intRef.getName()) );
+        }
+        for(VarType varType : varTypes) {
+            Id enclosingId = getEnclosingTraitDeclName();
+  
+            if(enclosingId == null) {
+                throw new DesugarerError( varType.getSpan(), "VarType " +
+                        varType + " found outside of Trait/ObjectDecl!" );
+            }
+
+            Pair<Id,Id> key = new Pair<Id,Id>( enclosingId, varType.getName() );
+            TypeParam declSite = staticArgToTypeParam.get(key);
+        
+            if(declSite == null) {
+               throw new DesugarerError( varType.getSpan(), "Cannot find the "
+                            + "decl site of VarType " + varType + " in " + 
+                            "staticArgToTypeParam map!");
+            }
+
+            sParams.add( new TypeParam(varType.getSpan(), varType.getName(), 
+                                       declSite.getExtendsClause(), 
+                                       declSite.isAbsorbs()) );
+        }
+        
+        return sParams;
+    } */
 
 //     private ObjectDecl 

trunk/ProjectFortress/src/com/sun/fortress/compiler/desugarer/ObjectExpressionVisitorJUTest.java

@@ -50 +50 @@
         runFile("objectCC_mutVar1.fss");
         runFile("objectCC_mutVar2.fss");
+        runFile("objectCC_mutable.fss");
     }
 

trunk/ProjectFortress/tests/objectCC_staticParams.fss

@@ -1 @@
-(*******************************************************************************
-    Copyright 2008 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 objectCC_staticParams
 export Executable
@@ -26 +9 @@
 end
 
-object O[\X extends String, bool b, nat n\](v:ZZ32, s:X)
+trait Y 
+end
+
+object YObj extends Y
+end
+
+object O[\X extends String, bool b, nat n\](var v:ZZ32, s:X)
     foo():ZZ32 = 3
     (* After we move checking of method calls to be after
@@ -33 +22 @@
                 x():ZZ32 = foo()
                 y():ZZ32 = quack()
-                z():ZZ32 = do
-                    _ = O[\X, b, n\](v, s)
+                z():ZZ32 = do 
+                    _ = O[\X, b, 3\](v, s)
                     if b then n else (n-1) end
                 end
@@ -43 +32 @@
 end
 
+(* Referring to var with static type param, when the static type is not
+   explitictly referred in object expression body; if the closure conversion
+   works correctly, the unparse output should type check *)
+object O2[\X extends String, Z, ZObj extends Z\](var v:ZZ32, s:X, s2:ZObj)
+    foo():ZZ32 = 3
+    bar():T[\X\] = object extends T[\X\]
+                x():ZZ32 = foo()
+                y():ZZ32 = quack()
+                z() = s2
+                a():X = s
+            end
+    quack():ZZ32 = self.v
+    name():X = s
+end
+
 run(args:String...):() = do
     o:O[\String, true, 7\] = O[\String, true, 7\](4, "Hello");
-    println o.v
-    println o.bar().x()
-    println o.bar().z()
-    println o.bar().a()
+    o.v := o.v + 1
+    t:T[\String\] = o.bar()
+    assert( o.foo(), t.x(), "t.x() failed." )
+    assert( o.quack(), t.y(), "t.y() failed." )
+    assert( 7, t.z(), "t.z() failed." )
+    assert( o.s, t.a(), "t.a() failed." )
 end
 
 end
+