Changeset 3144

Timestamp:

12/03/08 20:05:46 (12 months ago)

Author:

sukyoungryu

Message:

[ast refactoring] Eliminated _RewriteGenericSingletonType.

Location:

trunk/ProjectFortress

Files:

• astgen/Fortress.ast (modified) (1 diff)
• src/com/sun/fortress/compiler/disambiguator/TypeDisambiguator.java (modified) (2 diffs)
• src/com/sun/fortress/compiler/typechecker/StaticTypeReplacer.java (modified) (1 diff)
• src/com/sun/fortress/compiler/typechecker/TypeAnalyzer.java (modified) (2 diffs)
• src/com/sun/fortress/compiler/typechecker/TypeChecker.java (modified) (3 diffs)
• src/com/sun/fortress/interpreter/evaluator/types/FTypeGeneric.java (modified) (2 diffs)
• src/com/sun/fortress/nodes_util/NodeFactory.java (modified) (6 diffs)
• src/com/sun/fortress/nodes_util/NodeUtil.java (modified) (1 diff)
• src/com/sun/fortress/parser/Type.rats (modified) (1 diff)
• src/com/sun/fortress/syntax_abstractions/util/BaseTypeCollector.java (modified) (1 diff)
• src/com/sun/fortress/syntax_abstractions/util/FortressTypeToJavaTypeJUTest.java (modified) (4 diffs)
• src/com/sun/fortress/tools/FortressAstToConcrete.java (modified) (2 diffs)

trunk/ProjectFortress/astgen/Fortress.ast

@@ -1281 +1281 @@
                          * TraitType ::= QualifiedName [\StaticArgList\]
                          * e.g.) List[\ZZ32\]
+                         *
+                         * <staticParams>
+                         * If the staticParams field is set,
+                         * it is the type of a generic singleton
+                         * used during static checking
                          */
                         TraitType(List<StaticArg> args
-                                   = Collections.<StaticArg>emptyList());
-                        /**
-                         * type of a generic singleton, used during static checking
-                         */
-                        _RewriteGenericSingletonType(List<StaticParam> staticParams);
+                                      = Collections.<StaticArg>emptyList(),
+                                  List<StaticParam> staticParams);
                     /**
                      * abbreviated type

trunk/ProjectFortress/src/com/sun/fortress/compiler/disambiguator/TypeDisambiguator.java

@@ -216 +216 @@
                     }
                     return new TraitType(that.getSpan(), n,
-                                                Collections.<StaticArg>emptyList());
+                                         Collections.<StaticArg>emptyList(),
+                                         Collections.<StaticParam>emptyList());
                 }
             }
@@ -256 +257 @@
                     }
                     return changed ?
-                        new TraitType(that.getSpan(), n, newArgs) : that;
+                    new TraitType(that.getSpan(), n, newArgs,
+                                  Collections.<StaticParam>emptyList()) : that;
                 }
             }

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

@@ -55 +55 @@
 import com.sun.fortress.nodes.Type;
 import com.sun.fortress.nodes.VarRef;
-import com.sun.fortress.nodes._RewriteGenericSingletonType;
 import com.sun.fortress.nodes_util.NodeFactory;
 import com.sun.fortress.useful.NI;

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

@@ -226 +226 @@
         Type result = (Type) t.accept(new NodeUpdateVisitor() {
 
-            @Override public BaseType forTraitTypeOnly(TraitType t, Id name, List<StaticArg> normalArgs) {
+                @Override public BaseType forTraitTypeOnly(TraitType t, Id name, List<StaticArg> normalArgs,
+                                                           List<StaticParam> normalParams) {
                 Option<TypeConsIndex> ind = _table.typeCons(name);
              if(ind.isNone()){
@@ -243 +244 @@
                 }
                 else if (index instanceof TraitIndex) {
-                    return (BaseType) super.forTraitTypeOnly(t, name, normalArgs);
+                    return (BaseType) super.forTraitTypeOnly(t, name, normalArgs, normalParams);
                 }
                 else if (index == null) {

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

@@ -948 +948 @@
         @Override
         public TypeCheckerResult for_RewriteObjectRefOnly(_RewriteObjectRef that, Option<TypeCheckerResult> exprType_result,
-                        TypeCheckerResult obj_result,
-                        List<TypeCheckerResult> staticArgs_result) {
-                Type t;
-                ConstraintFormula accumulated_constraints = ConstraintFormula.TRUE;
-                if( obj_result.type().isNone() ) {
-                        return TypeCheckerResult.compose(that, subtypeChecker, obj_result,
-                                        TypeCheckerResult.compose(that, subtypeChecker, staticArgs_result));
-                }
-                else if( (obj_result.type().unwrap() instanceof TraitType) ) {
-                        t=obj_result.type().unwrap();
-                }
-                else if( (obj_result.type().unwrap() instanceof _RewriteGenericSingletonType) ) {
-                        // instantiate with static parameters
-                        _RewriteGenericSingletonType uninstantiated_t = (_RewriteGenericSingletonType)obj_result.type().unwrap();
-                        Option<ConstraintFormula> constraint = StaticTypeReplacer.argsMatchParams(that.getStaticArgs(), uninstantiated_t.getStaticParams(), this.subtypeChecker);
-                        if(constraint.isSome()) {
-                                // make a trait type that is GenericType instantiated
-                                t = NodeFactory.makeTraitType(uninstantiated_t.getSpan(),
-                                                uninstantiated_t.isParenthesized(), uninstantiated_t.getName(), that.getStaticArgs());
-                                accumulated_constraints = constraint.unwrap();
-                        }
-                        else {
-                                // error
-                                String err = "Generic object, " + uninstantiated_t + " instantiated with invalid arguments, " + that.getStaticArgs();
-                                TypeCheckerResult e_result = new TypeCheckerResult(that, TypeError.make(err, that));
-                                return TypeCheckerResult.compose(that, subtypeChecker, obj_result, e_result,
-                                                TypeCheckerResult.compose(that, subtypeChecker, staticArgs_result));
-                        }
-                }
-                else {
-                        return bug("Unexpected type for ObjectRef.");
-                }
-
-                Node new_node = new _RewriteObjectRef(that.getSpan(), that.isParenthesized(), Option.<Type>some(t), (Id) obj_result.ast(), (List<StaticArg>) TypeCheckerResult.astFromResults(staticArgs_result));
-                return TypeCheckerResult.compose(new_node, t, subtypeChecker, obj_result,
-                                TypeCheckerResult.compose(that, subtypeChecker, staticArgs_result),
-                                new TypeCheckerResult(new_node,accumulated_constraints));
+                                                          TypeCheckerResult obj_result,
+                                                          List<TypeCheckerResult> staticArgs_result) {
+            Type t;
+            ConstraintFormula accumulated_constraints = ConstraintFormula.TRUE;
+            if( obj_result.type().isNone() ) {
+                return TypeCheckerResult.compose(that, subtypeChecker, obj_result,
+                                                 TypeCheckerResult.compose(that, subtypeChecker, staticArgs_result));
+            }
+            else if( (obj_result.type().unwrap() instanceof TraitType) ) {
+                t=obj_result.type().unwrap();
+                TraitType _t = (TraitType)t;
+
+                if ( NodeUtil.isGenericSingletonType(_t) ) {
+                    // instantiate with static parameters
+                    Option<ConstraintFormula> constraint = StaticTypeReplacer.argsMatchParams(that.getStaticArgs(),
+                                                                                              _t.getStaticParams(),
+                                                                                              this.subtypeChecker);
+                    if(constraint.isSome()) {
+                        // make a trait type that is GenericType instantiated
+                        t = NodeFactory.makeTraitType(_t.getSpan(),
+                                                      _t.isParenthesized(),
+                                                      _t.getName(),
+                                                      that.getStaticArgs());
+                        accumulated_constraints = constraint.unwrap();
+                    }
+                    else {
+                        // error
+                        String err = "Generic object, " + _t + " instantiated with invalid arguments, " + that.getStaticArgs();
+                        TypeCheckerResult e_result = new TypeCheckerResult(that, TypeError.make(err, that));
+                        return TypeCheckerResult.compose(that, subtypeChecker, obj_result, e_result,
+                                                         TypeCheckerResult.compose(that, subtypeChecker, staticArgs_result));
+                    }
+                }
+            }
+            else {
+                return bug("Unexpected type for ObjectRef.");
+            }
+
+            Node new_node = new _RewriteObjectRef(that.getSpan(), that.isParenthesized(),
+                                                  Option.<Type>some(t),
+                                                  (Id) obj_result.ast(),
+                                                  (List<StaticArg>) TypeCheckerResult.astFromResults(staticArgs_result));
+            return TypeCheckerResult.compose(new_node, t, subtypeChecker, obj_result,
+                                             TypeCheckerResult.compose(that, subtypeChecker, staticArgs_result),
+                                             new TypeCheckerResult(new_node,accumulated_constraints));
         }
 
@@ -2968 +2976 @@
         @Override
         public TypeCheckerResult forLooseJuxtOnly(LooseJuxt that, Option<TypeCheckerResult> exprType_result,
-                        TypeCheckerResult multiJuxt_result,
-                        TypeCheckerResult infixJuxt_result,
-                        List<TypeCheckerResult> exprs_result) {
-                // The implementation of this method is very similar to tight juxt except
-                // the ordering of association is different.
-                // Notice also that tightJuxt has to be recursive, but loose juxt is not, due to specification.
-
-                // Did any subexpressions fail to typecheck?
-                for( TypeCheckerResult r : exprs_result ) {
-                        if( r.type().isNone())
-                                return TypeCheckerResult.compose(that, subtypeChecker, exprs_result);
-                }
-
-                if( that.getExprs().size() != exprs_result.size() ) {
-                        bug("Number of types don't match number of sub-expressions");
-                }
-                // Specification describes chunks, which are elements group together. Chunking process goes first.
-                List<Pair<TypeCheckerResult,Expr>> checked_chunks = new LinkedList<Pair<TypeCheckerResult,Expr>>();
-                {
-                        List<Pair<TypeCheckerResult,Expr>> cur_chunk = new LinkedList<Pair<TypeCheckerResult,Expr>>();
-                        Iterator<Expr> expr_iter = that.getExprs().iterator();
-                        boolean seen_non_fn = false;
-                        // First the loose juxtaposition is broken into nonempty chunks; wherever there is a non-function element followed
-                        // by a function element, the latter begins a new chunk. Thus a chunk consists of some number (possibly zero) of
-                        // functions followed by some number (possibly zero) of non-functions.
-                        for( TypeCheckerResult r : exprs_result ) {
-                                boolean is_arrow = TypesUtil.isArrows(r.type().unwrap());
-                                if( is_arrow && seen_non_fn ) {
-                                        // finished last chunk
-                                        Pair<TypeCheckerResult,Expr> checked_chunk = this.checkChunk(cur_chunk, that.getInfixJuxt());
-                                        checked_chunks.add(checked_chunk);
-                                        cur_chunk.clear();
-                                        seen_non_fn = false;
-                                }
-                                if( is_arrow ){
-                                        cur_chunk.add(Pair.make(r, expr_iter.next()));
-                                }
-                                else {
-                                        seen_non_fn = true;
-                                        cur_chunk.add(Pair.make(r, expr_iter.next()));
-                                }
-                        }
-                        // Last chunk needs to be checked, if there is one
-                        if( !cur_chunk.isEmpty() ) {
-                                checked_chunks.add(checkChunk(cur_chunk, that.getInfixJuxt()));
-                        }
-                }
-                // After chunking
-                List<Expr> new_juxt_exprs = CollectUtil.makeList(IterUtil.pairSeconds(checked_chunks));
-                List<TypeCheckerResult> new_juxt_results = CollectUtil.makeList(IterUtil.pairFirsts(checked_chunks));
-
-                if( checked_chunks.size() == 1 ) {
-                        Expr expr = IterUtil.first(new_juxt_exprs);
-                        TypeCheckerResult expr_result = expr.accept(this); // Is it bad to re-typecheck all args?
-                        return TypeCheckerResult.compose(expr_result.ast(), expr_result.type(), subtypeChecker, expr_result,
-                                        TypeCheckerResult.compose(expr_result.ast(), subtypeChecker, new_juxt_results));
-                }
-                // (1) If any element that remains has type String, then it is a static error if any two adjacent elements are not of type String.
-                // TODO: Separate pass?
-                // (2) Treat the sequence that remains as a multifix application of the juxtaposition operator. The rules for multifix operators then apply:
-                OpExpr multi_op_expr = new OpExpr(that.getSpan(), that.getMultiJuxt(), new_juxt_exprs);
-                TypeCheckerResult multi_op_result = multi_op_expr.accept(this);
-                if( multi_op_result.type().isSome() ) {
-                        return TypeCheckerResult.compose(multi_op_result.ast(), multi_op_result.type(), subtypeChecker,
-                                        TypeCheckerResult.compose(multi_op_result.ast(), subtypeChecker, new_juxt_results));
-                }
-                // if an applicable method cannot be found for the entire expression, then it is left-associated.
-                Iterator<Expr> expr_iter = new_juxt_exprs.iterator();
-                Expr expr_1 = expr_iter.next(); // the fact that >= two items are here is guaranteed from above.
-                Expr expr_2 = expr_iter.next();
-                OpExpr cur_op_expr = new OpExpr(new Span(expr_1.getSpan(),expr_2.getSpan()), that.getInfixJuxt(), Useful.list(expr_1,expr_2));
-                while( expr_iter.hasNext() ) {
-                        Expr next_expr = expr_iter.next();
-                        cur_op_expr = new OpExpr(new Span(cur_op_expr.getSpan(),next_expr.getSpan()), that.getInfixJuxt(), Useful.list(cur_op_expr, next_expr));
-                }
-                // typecheck this result instead
-                TypeCheckerResult op_expr_result = cur_op_expr.accept(this); // Is it bad to re-typecheck all args?
-                return TypeCheckerResult.compose(op_expr_result.ast(), op_expr_result.type(), subtypeChecker, op_expr_result,
-                                TypeCheckerResult.compose(op_expr_result.ast(), subtypeChecker, new_juxt_results));
+                                                  TypeCheckerResult multiJuxt_result,
+                                                  TypeCheckerResult infixJuxt_result,
+                                                  List<TypeCheckerResult> exprs_result) {
+            // The implementation of this method is very similar to tight juxt except
+            // the ordering of association is different.
+            // Notice also that tightJuxt has to be recursive, but loose juxt is not, due to specification.
+
+            // Did any subexpressions fail to typecheck?
+            for( TypeCheckerResult r : exprs_result ) {
+                if( r.type().isNone())
+                    return TypeCheckerResult.compose(that, subtypeChecker, exprs_result);
+            }
+
+            if( that.getExprs().size() != exprs_result.size() ) {
+                bug("Number of types don't match number of sub-expressions");
+            }
+            // Specification describes chunks, which are elements group together. Chunking process goes first.
+            List<Pair<TypeCheckerResult,Expr>> checked_chunks = new LinkedList<Pair<TypeCheckerResult,Expr>>();
+            {
+                List<Pair<TypeCheckerResult,Expr>> cur_chunk = new LinkedList<Pair<TypeCheckerResult,Expr>>();
+                Iterator<Expr> expr_iter = that.getExprs().iterator();
+                boolean seen_non_fn = false;
+                // First the loose juxtaposition is broken into nonempty chunks; wherever there is a non-function element followed
+                // by a function element, the latter begins a new chunk. Thus a chunk consists of some number (possibly zero) of
+                // functions followed by some number (possibly zero) of non-functions.
+                for( TypeCheckerResult r : exprs_result ) {
+                    boolean is_arrow = TypesUtil.isArrows(r.type().unwrap());
+                    if( is_arrow && seen_non_fn ) {
+                        // finished last chunk
+                        Pair<TypeCheckerResult,Expr> checked_chunk = this.checkChunk(cur_chunk, that.getInfixJuxt());
+                        checked_chunks.add(checked_chunk);
+                        cur_chunk.clear();
+                        seen_non_fn = false;
+                    }
+                    if( is_arrow ){
+                        cur_chunk.add(Pair.make(r, expr_iter.next()));
+                    }
+                    else {
+                        seen_non_fn = true;
+                        cur_chunk.add(Pair.make(r, expr_iter.next()));
+                    }
+                }
+                // Last chunk needs to be checked, if there is one
+                if( !cur_chunk.isEmpty() ) {
+                    checked_chunks.add(checkChunk(cur_chunk, that.getInfixJuxt()));
+                }
+            }
+            // After chunking
+            List<Expr> new_juxt_exprs = CollectUtil.makeList(IterUtil.pairSeconds(checked_chunks));
+            List<TypeCheckerResult> new_juxt_results = CollectUtil.makeList(IterUtil.pairFirsts(checked_chunks));
+
+            if( checked_chunks.size() == 1 ) {
+                Expr expr = IterUtil.first(new_juxt_exprs);
+                TypeCheckerResult expr_result = expr.accept(this); // Is it bad to re-typecheck all args?
+                return TypeCheckerResult.compose(expr_result.ast(), expr_result.type(), subtypeChecker, expr_result,
+                                                 TypeCheckerResult.compose(expr_result.ast(), subtypeChecker, new_juxt_results));
+            }
+            // (1) If any element that remains has type String, then it is a static error if any two adjacent elements are not of type String.
+            // TODO: Separate pass?
+            // (2) Treat the sequence that remains as a multifix application of the juxtaposition operator. The rules for multifix operators then apply:
+            OpExpr multi_op_expr = new OpExpr(that.getSpan(), that.getMultiJuxt(), new_juxt_exprs);
+            TypeCheckerResult multi_op_result = multi_op_expr.accept(this);
+            if( multi_op_result.type().isSome() ) {
+                return TypeCheckerResult.compose(multi_op_result.ast(), multi_op_result.type(), subtypeChecker,
+                                                 TypeCheckerResult.compose(multi_op_result.ast(), subtypeChecker, new_juxt_results));
+            }
+            // if an applicable method cannot be found for the entire expression, then it is left-associated.
+            Iterator<Expr> expr_iter = new_juxt_exprs.iterator();
+            Expr expr_1 = expr_iter.next(); // the fact that >= two items are here is guaranteed from above.
+            Expr expr_2 = expr_iter.next();
+            OpExpr cur_op_expr = new OpExpr(new Span(expr_1.getSpan(),expr_2.getSpan()), that.getInfixJuxt(), Useful.list(expr_1,expr_2));
+            while( expr_iter.hasNext() ) {
+                Expr next_expr = expr_iter.next();
+                cur_op_expr = new OpExpr(new Span(cur_op_expr.getSpan(),next_expr.getSpan()), that.getInfixJuxt(), Useful.list(cur_op_expr, next_expr));
+            }
+            // typecheck this result instead
+            TypeCheckerResult op_expr_result = cur_op_expr.accept(this); // Is it bad to re-typecheck all args?
+            return TypeCheckerResult.compose(op_expr_result.ast(), op_expr_result.type(), subtypeChecker, op_expr_result,
+                                             TypeCheckerResult.compose(op_expr_result.ast(), subtypeChecker, new_juxt_results));
         }
 
@@ -3858 +3866 @@
         @Override
         public TypeCheckerResult forTightJuxt(TightJuxt that) {
-                // Just create a MathPrimary
-                Expr front = IterUtil.first(that.getExprs());
-
-                // If this juxt is actually a fn app, then rewrite to a fn app.
-                if (that.isFnApp()) {
-                        // Make sure it is just two exprs.
-                        if (that.getExprs().size() != 2) {
-                                bug(String.format("TightJuxt denoted as function application but has %d (!= 2) exprs.", that.getExprs().size()));
-                        }
-                        Expr arg = that.getExprs().get(1);
-                        _RewriteFnApp fnApp = new _RewriteFnApp(new Span(front.getSpan(), arg.getSpan()),
-                                        front, arg);
-
-                        // Simulate a TypeCheckerResult for the front, giving it a fresh arrow type.
-                        Type freshArrow = NodeFactory.makeArrowType(new Span(),
-                                        NodeFactory.make_InferenceVarType(that.getSpan()),
-                                        NodeFactory.make_InferenceVarType(that.getSpan()));
-                        TypeCheckerResult front_result = new TypeCheckerResult(front, freshArrow);
-
-                        // Type check the other nodes and recur on the fn app.
-                        Option<TypeCheckerResult> exprType_result = this.recurOnOptionOfType(that.getExprType());
-                        TypeCheckerResult arg_result = arg.accept(this);
-                        TypeCheckerResult fnApp_result = this.for_RewriteFnAppOnly(fnApp,
-                                        exprType_result,
-                                        front_result,
-                                        arg_result);
-                        return TypeCheckerResult.compose(that,
-                                        fnApp_result.type(),
-                                        subtypeChecker,
-                                        fnApp_result);
-                }
-
-                Iterable<Expr> rest = IterUtil.skipFirst(that.getExprs());
-                List<MathItem> items = CollectUtil.makeList(IterUtil.map(rest, new Lambda<Expr,MathItem>(){
+            // Just create a MathPrimary
+            Expr front = IterUtil.first(that.getExprs());
+
+            // If this juxt is actually a fn app, then rewrite to a fn app.
+            if (that.isFnApp()) {
+                // Make sure it is just two exprs.
+                if (that.getExprs().size() != 2) {
+                    bug(String.format("TightJuxt denoted as function application but has %d (!= 2) exprs.", that.getExprs().size()));
+                }
+                Expr arg = that.getExprs().get(1);
+                _RewriteFnApp fnApp = new _RewriteFnApp(new Span(front.getSpan(), arg.getSpan()),
+                                                        front, arg);
+
+                // Simulate a TypeCheckerResult for the front, giving it a fresh arrow type.
+                Type freshArrow = NodeFactory.makeArrowType(new Span(),
+                                                            NodeFactory.make_InferenceVarType(that.getSpan()),
+                                                            NodeFactory.make_InferenceVarType(that.getSpan()));
+                TypeCheckerResult front_result = new TypeCheckerResult(front, freshArrow);
+
+                // Type check the other nodes and recur on the fn app.
+                Option<TypeCheckerResult> exprType_result = this.recurOnOptionOfType(that.getExprType());
+                TypeCheckerResult arg_result = arg.accept(this);
+                TypeCheckerResult fnApp_result = this.for_RewriteFnAppOnly(fnApp,
+                                                                           exprType_result,
+                                                                           front_result,
+                                                                           arg_result);
+                return TypeCheckerResult.compose(that,
+                                                 fnApp_result.type(),
+                                                 subtypeChecker,
+                                                 fnApp_result);
+            }
+
+            Iterable<Expr> rest = IterUtil.skipFirst(that.getExprs());
+            List<MathItem> items = CollectUtil.makeList(IterUtil.map(rest, new Lambda<Expr,MathItem>(){
                         public MathItem value(Expr arg0) {
-                                if( arg0.isParenthesized() || arg0 instanceof TupleExpr || arg0 instanceof VoidLiteralExpr)
-                                        return new ParenthesisDelimitedMI(arg0.getSpan(),arg0);
-                                else
-                                        return new NonParenthesisDelimitedMI(arg0.getSpan(),arg0);
+                            if( arg0.isParenthesized() || arg0 instanceof TupleExpr || arg0 instanceof VoidLiteralExpr)
+                                return new ParenthesisDelimitedMI(arg0.getSpan(),arg0);
+                            else
+                                return new NonParenthesisDelimitedMI(arg0.getSpan(),arg0);
                         }}));
-                MathPrimary new_primary = new MathPrimary(that.getSpan(),that.isParenthesized(),that.getMultiJuxt(),that.getInfixJuxt(),front,items);
+            MathPrimary new_primary = new MathPrimary(that.getSpan(),
+                                                      that.isParenthesized(),
+                                                      that.getMultiJuxt(),
+                                                      that.getInfixJuxt(),
+                                                      front,items);
                 return new_primary.accept(this);
         }

trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/types/FTypeGeneric.java

@@ -25 +25 @@
 import java.util.HashMap;
 import java.util.List;
+import java.util.Collections;
 import java.util.Map;
 
@@ -151 +152 @@
         List<StaticArg> statics = paramsToArgs();
         Id in = NodeFactory.makeId(def.getSpan(), name);
-        TraitType inst_type = new TraitType(NodeFactory.makeSpan(in, statics), in, statics);
+        TraitType inst_type = new TraitType(NodeFactory.makeSpan(in, statics), in, statics,
+                                            Collections.<StaticParam>emptyList());
         return inst_type;
     }

trunk/ProjectFortress/src/com/sun/fortress/nodes_util/NodeFactory.java

@@ -285 +285 @@
 
     public static TraitType makeTraitType(TraitType t,
-            List<StaticArg> args) {
+                                          List<StaticArg> args) {
         return new TraitType(t.getSpan(), t.isParenthesized(),
-                t.getName(), args);
+                             t.getName(), args,
+                             Collections.<StaticParam>emptyList());
     }
 
@@ -370 +371 @@
 
     public static TraitType makeTraitType(Span span, boolean isParenthesized,
-            Id name, List<StaticArg> args) {
-        return new TraitType(span, isParenthesized, name, args);
+                                          Id name, List<StaticArg> args) {
+        return new TraitType(span, isParenthesized, name, args,
+                             Collections.<StaticParam>emptyList());
     }
 
@@ -391 +393 @@
 
     public static TraitType makeTraitType(String name,
-            List<StaticArg> sargs) {
+                                          List<StaticArg> sargs) {
         // System.err.println("Please don't makeTraitType with a bogus span");
-        return new TraitType(new Span(),makeId(name),sargs);
+        return new TraitType(new Span(),makeId(name),sargs,
+                             Collections.<StaticParam>emptyList());
     }
 
     public static TraitType makeTraitType(Id name,
-            List<StaticArg> sargs) {
-        return new TraitType(name.getSpan(), name, sargs);
+                                          List<StaticArg> sargs) {
+        return new TraitType(name.getSpan(), name, sargs,
+                             Collections.<StaticParam>emptyList());
     }
 
     public static TraitType makeTraitType(Id name) {
-        return new TraitType(name.getSpan(), name, Collections.<StaticArg>emptyList());
+        return new TraitType(name.getSpan(), name, Collections.<StaticArg>emptyList(),
+                             Collections.<StaticParam>emptyList());
     }
 
@@ -1263 +1268 @@
             public Type forTraitType(TraitType t) {
                 return new TraitType(t.getSpan(), true, t.getName(),
-                        t.getArgs());
+                                     t.getArgs(), t.getStaticParams());
             }
             public Type forTupleType(TupleType t) {
@@ -1330 +1335 @@
                     makeId(api, type.getName()));
         }
-        else if( type instanceof _RewriteGenericSingletonType ) {
-            _RewriteGenericSingletonType rgs_type = (_RewriteGenericSingletonType)type;
-            return new _RewriteGenericSingletonType(rgs_type.getSpan(),
-                    rgs_type.isParenthesized(),
-                    makeId(api,rgs_type.getName()),
-                    rgs_type.getStaticParams());
-        }
         else { // type instanceof TraitType
             TraitType _type = (TraitType)type;
             return new TraitType(_type.getSpan(),
-                    _type.isParenthesized(),
-                    makeId(api, _type.getName()),
-                    _type.getArgs());
+                                 _type.isParenthesized(),
+                                 makeId(api, _type.getName()),
+                                 _type.getArgs(),
+                                 _type.getStaticParams());
         }
     }
 
-    public static _RewriteGenericSingletonType makeGenericSingletonType(Id name, List<StaticParam> params) {
-        return new _RewriteGenericSingletonType(name.getSpan(), name, params);
+    public static TraitType makeGenericSingletonType(Id name, List<StaticParam> params) {
+        return new TraitType(name.getSpan(), name, Collections.<StaticArg>emptyList(), params);
     }
 
@@ -1361 +1360 @@
 
     public static TraitType makeTraitType(TraitType original) {
-        return new TraitType(original.getSpan(), original.isParenthesized(), original.getName(), original.getArgs());
+        return new TraitType(original.getSpan(), original.isParenthesized(),
+                             original.getName(), original.getArgs(),
+                             Collections.<StaticParam>emptyList());
 
     }

trunk/ProjectFortress/src/com/sun/fortress/nodes_util/NodeUtil.java

@@ -166 +166 @@
         else if (def instanceof FnExpr) { return Option.some(((FnExpr)def).getBody()); }
         else { return Option.none(); }
+    }
+
+    public static boolean isGenericSingletonType(TraitType t) {
+        return (! t.getStaticParams().isEmpty());
     }
 

trunk/ProjectFortress/src/com/sun/fortress/parser/Type.rats

@@ -210 +210 @@
      { if (a2 == null)
             yyValue = new VarType(createSpan(yyStart,yyCount), a1);
-       else yyValue = new TraitType(createSpan(yyStart,yyCount),a1,a2);
+       else yyValue = new TraitType(createSpan(yyStart,yyCount),a1,a2,
+                                    Collections.<StaticParam>emptyList());
      };
 

trunk/ProjectFortress/src/com/sun/fortress/syntax_abstractions/util/BaseTypeCollector.java

@@ -37 +37 @@
     @Override
     public String forTraitTypeOnly(TraitType that, String name_result,
-            List<String> args_result) {
+                                   List<String> args_result,
+                                   List<String> params_result) {
         if (args_result.size() == 0)
             return that.getName().getText();
         if (args_result.size() != 1)
-            return super.forTraitTypeOnly(that, name_result, args_result);       
+            return super.forTraitTypeOnly(that, name_result, args_result, params_result);
         return args_result.get(0);
     }

trunk/ProjectFortress/src/com/sun/fortress/syntax_abstractions/util/FortressTypeToJavaTypeJUTest.java

@@ -20 +20 @@
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Collections;
 
 import com.sun.fortress.nodes.Id;
@@ -25 +26 @@
 import com.sun.fortress.nodes.TraitType;
 import com.sun.fortress.nodes.StaticArg;
+import com.sun.fortress.nodes.StaticParam;
 import com.sun.fortress.nodes.BaseType;
 import com.sun.fortress.nodes.TypeArg;
@@ -35 +37 @@
 
     private Span span = NodeFactory.makeSpan("bogus");
-    
+
     private VarType stringType = new VarType(span, NodeFactory.makeId("FortressBuiltin", "String"));
     private String stringTypeResult = "String";
@@ -45 +47 @@
         List<StaticArg> args = new LinkedList<StaticArg>();
         args.add(new TypeArg(span, typeArg));
-        return new TraitType(span, name, args);
+        return new TraitType(span, name, args, Collections.<StaticParam>emptyList());
     }
 

trunk/ProjectFortress/src/com/sun/fortress/tools/FortressAstToConcrete.java

@@ -2085 +2085 @@
     @Override public String forTraitTypeOnly(TraitType that,
                                              String name_result,
-                                             List<String> args_result) {
+                                             List<String> args_result,
+                                             List<String> params_result) {
         StringBuilder s = new StringBuilder();
 
@@ -2092 +2093 @@
 
         return s.toString();
-    }
-
-    @Override public String for_RewriteGenericSingletonTypeOnly(_RewriteGenericSingletonType that,
-                                                                String name_result,
-                                                                List<String> staticParams_result) {
-        StringBuilder s = new StringBuilder();
-
-        s.append( name_result );
-        inOxfordBrackets(s, staticParams_result );
-
-        return handleParen( s.toString(),
-                            that.isParenthesized() );
     }