Changeset 3202

Timestamp:

12/12/08 08:05:55 (12 months ago)

Author:

sukyoungryu

Message:

[ast refactoring] Removed optional fields of VarType?, TraitType?, TaggedDimType?, TupleType?, and ArrowType?.

Location:

trunk/ProjectFortress

Files:

• astgen/Fortress.ast (modified) (5 diffs)
• src/com/sun/fortress/compiler/Types.java (modified) (5 diffs)
• src/com/sun/fortress/compiler/desugarer/ObjectExpressionVisitor.java (modified) (1 diff)
• src/com/sun/fortress/compiler/disambiguator/TypeDisambiguator.java (modified) (2 diffs)
• src/com/sun/fortress/compiler/typechecker/FnTypeEnv.java (modified) (1 diff)
• src/com/sun/fortress/compiler/typechecker/ObjectTypeEnv.java (modified) (3 diffs)
• src/com/sun/fortress/compiler/typechecker/TypeAnalyzer.java (modified) (2 diffs)
• src/com/sun/fortress/compiler/typechecker/TypeAnalyzerJUTest.java (modified) (3 diffs)
• src/com/sun/fortress/compiler/typechecker/TypeChecker.java (modified) (1 diff)
• src/com/sun/fortress/compiler/typechecker/TypeCheckerTestCase.java (modified) (1 diff)
• src/com/sun/fortress/compiler/typechecker/TypeEnv.java (modified) (1 diff)
• src/com/sun/fortress/compiler/typechecker/TypesUtil.java (modified) (2 diffs)
• src/com/sun/fortress/interpreter/evaluator/types/FTypeGeneric.java (modified) (2 diffs)
• src/com/sun/fortress/interpreter/rewrite/DesugarerVisitor.java (modified) (1 diff)
• src/com/sun/fortress/interpreter/rewrite/RewriteInPresenceOfTypeInfoVisitor.java (modified) (2 diffs)
• src/com/sun/fortress/nodes_util/ExprFactory.java (modified) (2 diffs)
• src/com/sun/fortress/nodes_util/NodeFactory.java (modified) (16 diffs)
• src/com/sun/fortress/parser/NoNewlineType.rats (modified) (1 diff)
• src/com/sun/fortress/parser/OtherDecl.rats (modified) (1 diff)
• src/com/sun/fortress/parser/Type.rats (modified) (4 diffs)
• src/com/sun/fortress/parser_util/precedence_resolver/TypeResolver.java (modified) (7 diffs)
• src/com/sun/fortress/syntax_abstractions/phases/TemplateVarRewriterJUTest.java (modified) (10 diffs)
• src/com/sun/fortress/syntax_abstractions/util/FortressTypeToJavaTypeJUTest.java (modified) (2 diffs)

trunk/ProjectFortress/astgen/Fortress.ast

@@ -1000 +1000 @@
                          * e.g.) T
                          */
-                        VarType(int lexicalDepth=-2147483648);
+                        VarType(int lexicalDepth);
                         /**
                          * a trait (object, alias, or proper trait) type; traits
@@ -1012 +1012 @@
                          * used during static checking
                          */
-                        TraitType(List<StaticArg> args
-                                      = Collections.<StaticArg>emptyList(),
+                        TraitType(List<StaticArg> args,
                                   List<StaticParam> staticParams);
                     /**
@@ -1037 +1036 @@
                          * e.g.) RR64 Length
                          */
-                        TaggedDimType(DimExpr dimExpr,
-                                      Option<Expr> unitExpr = Option.<Expr>none());
+                        TaggedDimType(DimExpr dimExpr, Option<Expr> unitExpr);
                         /**
                          * type with unit
@@ -1067 +1065 @@
                  * It has a varargs parameter if the varargs field is set.
                  */
-                TupleType(List<Type> elements,
-                          Option<Type> varargs = Option.<Type>none(),
-                          List<KeywordType> keywords = Collections.<KeywordType>emptyList());
+                TupleType(List<Type> elements, Option<Type> varargs,
+                          List<KeywordType> keywords);
                 /**
                  * arrow type
@@ -1079 +1076 @@
                  * type of a generic function, used during static checking
                  */
-                ArrowType(Type domain, Type range,
-                          Effect effect = FortressUtil.emptyEffect(),
-                          List<StaticParam> staticParams
-                              = Collections.<StaticParam>emptyList(),
-                          Option<WhereClause> whereClause
-                              = Option.<WhereClause>none());
+                ArrowType(Type domain, Type range, Effect effect,
+                          List<StaticParam> staticParams,
+                          Option<WhereClause> whereClause);
                 /**
                  * inferred type

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

@@ -211 +211 @@
                 default: {
                     List<Type> l = CollectUtil.makeList(ts);
-                    return new TupleType(NodeFactory.makeSpan("impossible", l), l);
+                    return NodeFactory.makeTupleType(NodeFactory.makeSpan("impossible", l), l);
                 }
             }
@@ -246 +246 @@
             TupleType _d = (TupleType)d;
             if ( NodeUtil.hasVarargs(_d)) {
-                return new TupleType(NodeFactory.makeSpan(_d.getElements(), _d.getVarargs().unwrap()), _d.getElements(), _d.getVarargs());
+                return NodeFactory.makeTupleType(NodeFactory.makeSpan(_d.getElements(), _d.getVarargs().unwrap()),
+                                                 false, _d.getElements(), _d.getVarargs(),
+                                                 Collections.<KeywordType>emptyList());
             }
             else {
@@ -253 +255 @@
                     case 0: return VOID;
                     case 1: return args.get(0);
-                    default: return new TupleType(NodeFactory.makeSpan("impossible", args), args);
+                    default: return NodeFactory.makeTupleType(NodeFactory.makeSpan("impossible", args), args);
                 }
             }
@@ -301 +303 @@
             @Override public Type forTupleType(TupleType t) {
                 if ( ! NodeUtil.hasVarargs(t) )
-                    return new TupleType(NodeFactory.makeSpan(t, keywords), t.getElements(), keywords);
+                    return NodeFactory.makeTupleType(NodeFactory.makeSpan(t, keywords),
+                                                     false, t.getElements(),
+                                                     Option.<Type>none(), keywords);
                 else
-                    return new TupleType(NodeFactory.makeSpan(t, keywords), t.getElements(), t.getVarargs(),
-                                         keywords);
+                    return NodeFactory.makeTupleType(NodeFactory.makeSpan(t, keywords),
+                                                     false, t.getElements(), t.getVarargs(),
+                                                     keywords);
             }
             @Override public Type forType(Type t) {
@@ -310 +315 @@
                     return t;
                 else
-                    return new TupleType(NodeFactory.makeSpan(t, keywords), Collections.singletonList(t), keywords);
+                    return NodeFactory.makeTupleType(NodeFactory.makeSpan(t, keywords), false,
+                                                     Collections.singletonList(t),
+                                                     Option.<Type>none(), keywords);
             }
         });

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

@@ -842 +842 @@
             return new IntArg(span, intRef);
         } else if( NodeUtil.isTypeParam(sParam) ) {
-            VarType varType = new VarType(span, (Id)sParam.getName());
+            VarType varType = NodeFactory.makeVarType(span, (Id)sParam.getName());
             return new TypeArg(span, varType);
         } else {

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

@@ -218 +218 @@
                         return that;
                     }
-                    return new TraitType(that.getSpan(), n,
-                                         Collections.<StaticArg>emptyList(),
-                                         Collections.<StaticParam>emptyList());
+                    return NodeFactory.makeTraitType(that.getSpan(), false, n);
                 }
             }
@@ -260 +258 @@
                     }
                     return changed ?
-                    new TraitType(that.getSpan(), n, newArgs,
-                                  Collections.<StaticParam>emptyList()) : that;
+                    NodeFactory.makeTraitType(that.getSpan(), n, newArgs) : that;
                 }
             }

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

@@ -154 +154 @@
                 // Invariant: _fn.params().isSome()
                 // Otherwise, _fn should not have been in entries.
-                overloadedTypes.add(new ArrowType(loc,
+                overloadedTypes.add(NodeFactory.makeArrowType(loc, false,
                                                   domainFromParams(_fn.parameters()),
                                                   selfType,

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

@@ -35 +35 @@
 import com.sun.fortress.nodes.ArrowType;
 import com.sun.fortress.nodes_util.NodeFactory;
+import com.sun.fortress.parser_util.FortressUtil;
 
 import edu.rice.cs.plt.tuple.Option;
@@ -78 +79 @@
             } else {
                 // No static params, some normal params
-                type = new ArrowType(var.getSpan(),
+                type = NodeFactory.makeArrowType(var.getSpan(),
                                      domainFromParams(decl.getParams().unwrap()),
                                      NodeFactory.makeTraitType(_var));
@@ -89 +90 @@
                 // Some static params, some normal params
                 // TODO: handle type variables bound in where clause
-                type = new ArrowType(decl.getSpan(),
+                type = NodeFactory.makeArrowType(decl.getSpan(), false,
                                      domainFromParams(decl.getParams().unwrap()),
                                      NodeFactory.makeTraitType(_var, TypeEnv.staticParamsToArgs(decl.getStaticParams())),
+                                                 FortressUtil.emptyEffect(),
                                      decl.getStaticParams(),
                                      decl.getWhereClause());

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

@@ -274 +274 @@
                                         List<Type> elts = makeList(skipLast(ts));
                                         Type varargs = last(ts);
-                                        return new TupleType(NodeFactory.makeSpan(elts, varargs),
-                                                             elts, Option.<Type>some(varargs));
+                                        return NodeFactory.makeTupleType(NodeFactory.makeSpan(elts, varargs),
+                                                                         false, elts, Option.<Type>some(varargs),
+                                                                         Collections.<KeywordType>emptyList());
                                     }
                                 }
@@ -340 +341 @@
                 Iterable<Type> overloads = cross(domains, ranges, new Lambda2<Type, Type, Type>() {
                     public Type value(Type d, Type r) {
-                        return new ArrowType(NodeFactory.makeSetSpan(d,r), d, r, normalEffect);
+                        return NodeFactory.makeArrowType(NodeFactory.makeSetSpan(d,r), d, r, normalEffect);
                     }
                 });

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

@@ -521 +521 @@
             Type r = parseType(s.substring(opIndex+2, effectStart));
             Effect e = parseEffect(s.substring(effectStart));
-            return new ArrowType(span, d, r, e);
+            return NodeFactory.makeArrowType(span, d, r, e);
         }
 
@@ -548 +548 @@
             if (varargs) { s = s.substring(0, s.length()-4) + ")"; }
             List<Type> ts = parseTypeList(s, "(", ")");
-            if (varargs) { return new TupleType(span, ts, Option.<Type>some(ts.remove(ts.size()-1))); }
+            if (varargs) { return NodeFactory.makeTupleType(span, false, ts,
+                                                            Option.<Type>some(ts.remove(ts.size()-1)),
+                                                            Collections.<KeywordType>emptyList()); }
             else if (ts.size() == 0) { return VOID; }
             else if (ts.size() == 1) { return ts.get(0); }
-            else { return new TupleType(span, ts); }
+            else { return NodeFactory.makeTupleType(span, ts); }
         }
 
@@ -597 +599 @@
                 }
             }
-            return new TupleType(span, args, varargs, keys);
+            return NodeFactory.makeTupleType(span, false, args, varargs, keys);
         }
         else {

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

@@ -2401 +2401 @@
                 if(varargs){
                         Type var = dlist.remove(dlist.size()-1);
-                        domain = new TupleType(that.getSpan(), dlist, Option.<Type>some(var));
+                        domain = NodeFactory.makeTupleType(that.getSpan(), false, dlist,
+                                                           Option.<Type>some(var),
+                                                           Collections.<KeywordType>emptyList());
                 }
                 else{

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

@@ -65 +65 @@
             Type left = parseType(s.substring(0, arrowIndex));
             Type right = parseType(s.substring(arrowIndex+2));
-            return new ArrowType(span, left, right);
+            return NodeFactory.makeArrowType(span, left, right);
         }
         if (s.startsWith("(")) {

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

@@ -142 +142 @@
 
     protected static ArrowType genericArrowFromDecl(FnDecl decl) {
-        return new ArrowType(decl.getSpan(),
+        return NodeFactory.makeArrowType(decl.getSpan(), false,
                              domainFromParams(decl.getParams()),
                              // all types have been filled in at this point

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

@@ -107 +107 @@
                 case 0: return Types.VOID;
                 case 1: return _args.get(0);
-                default: return new TupleType(NodeFactory.makeSpan("impossible", _args), _args);
+                default: return NodeFactory.makeTupleType(NodeFactory.makeSpan("impossible", _args), _args);
             }
         }
@@ -431 +431 @@
                                 if(constraints.isSome()) {
                                         ArrowType temp = (ArrowType) that.accept(new StaticTypeReplacer(that.getStaticParams(),static_args));
-                                        Type new_type = new ArrowType(temp.getSpan(),temp.isParenthesized(),
+                                        Type new_type = NodeFactory.makeArrowType(temp.getSpan(),temp.isParenthesized(),
                                                                       temp.getDomain(),temp.getRange(), temp.getEffect(),
                                                                       Collections.<StaticParam>emptyList(),

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

@@ -146 +146 @@
         List<StaticArg> statics = paramsToArgs();
         Id in = NodeFactory.makeId(def.getSpan(), name);
-        TraitType inst_type = new TraitType(NodeFactory.makeSpan(in, statics), in, statics,
-                                            Collections.<StaticParam>emptyList());
+        TraitType inst_type = NodeFactory.makeTraitType(NodeFactory.makeSpan(in, statics),
+                                                        false, in, statics,
+                                                        Collections.<StaticParam>emptyList());
         return inst_type;
     }
@@ -164 +165 @@
         private TypeArg idNameToTypeArg(Id idn) {
             return new TypeArg(idn.getSpan(),
-                               new VarType(idn.getSpan(), idn));
+                               NodeFactory.makeVarType(idn.getSpan(), idn));
         }
 

trunk/ProjectFortress/src/com/sun/fortress/interpreter/rewrite/DesugarerVisitor.java

@@ -1119 +1119 @@
                                                                    WellKnownNames.thread));
         List<StaticArg> args = new ArrayList<StaticArg>();
-        args.add(new TypeArg(sp,new VarType(sp,
-                NodeFactory.makeId(sp,WellKnownNames.anyTypeLibrary, WellKnownNames.anyTypeName),
-                Environment.TOP_LEVEL)));
+        args.add(new TypeArg(sp,NodeFactory.makeVarType(sp,
+                                                        NodeFactory.makeId(sp,WellKnownNames.anyTypeLibrary, WellKnownNames.anyTypeName),
+                                                        Environment.TOP_LEVEL)));
 
         _RewriteFnRef fn = new _RewriteFnRef(s.getSpan(), false, Option.<Type>none(),

trunk/ProjectFortress/src/com/sun/fortress/interpreter/rewrite/RewriteInPresenceOfTypeInfoVisitor.java

@@ -32 +32 @@
 import com.sun.fortress.nodes._RewriteFnRef;
 import com.sun.fortress.nodes_util.ExprFactory;
+import com.sun.fortress.nodes_util.NodeFactory;
 import static com.sun.fortress.exceptions.InterpreterBug.bug;
 
@@ -71 +72 @@
     public Node forTraitType(TraitType it) {
         if (it.getArgs().size() == 0) {
-            return (new VarType(it.getSpan(), it.getName())).accept(this);
+            return (NodeFactory.makeVarType(it.getSpan(), it.getName())).accept(this);
         }
         return super.forTraitType(it);

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

@@ -42 +42 @@
     private static FunctionalRef multiJuxt = makeMultiJuxt();
     private static FunctionalRef infixJuxt = makeInfixJuxt();
-    private static int lexicalDepth = -2147483648;
+    public static int lexicalDepth = -2147483648;
 
     public static ArrayElement makeArrayElement(Expr elem) {
@@ -1285 +1285 @@
         return new Do(span, parenthesized, exprType, fronts);
     }
-
-
-
-                                          /*
-    public static TupleExpr makeTupleExpr(Span span,
-                                        boolean parenthesized,
-                                        Option<Type> exprType,
-                                          */
-
-    /***************************************************************************************/
 
     public static FloatLiteralExpr makeFloatLiteralExpr(Span span, String s) {

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

@@ -37 +37 @@
 
 public class NodeFactory {
+    public static int lexicalDepth = -2147483648;
+
     /**
      * For use only when there is no hope of
@@ -506 +508 @@
     }
 
+    public static ArrowType makeArrowType(Span span, Type domain, Type range,
+                                          Effect effect) {
+        return makeArrowType(span, false, domain, range, effect,
+                             Collections.<StaticParam>emptyList(),
+                             Option.<WhereClause>none());
+    }
+
+    public static ArrowType makeArrowType(Span span, Type domain, Type range) {
+        return makeArrowType(span, domain, range,
+                             makeEffect(range.getSpan().getEnd()));
+    }
+
+    public static ArrowType makeArrowType(Span span, boolean parenthesized,
+                                          Type domain, Type range, Effect effect,
+                                          List<StaticParam> sparams,
+                                          Option<WhereClause> where) {
+        return new ArrowType(span, parenthesized, domain, range, effect,
+                             sparams, where);
+    }
+
+    public static TupleType makeTupleType(TupleType t, List<Type> tys) {
+        return makeTupleType(t.getSpan(), tys);
+    }
+
+    public static TupleType makeTupleType(List<Type> elements) {
+        return makeTupleType(new Span(), elements);
+    }
+
+    public static TupleType makeTupleType(Span span, List<Type> elements) {
+        return makeTupleType(span, false, elements, Option.<Type>none(),
+                             Collections.<KeywordType>emptyList());
+    }
+
+    public static TupleType makeTupleType(Span span, boolean parenthesized,
+                                          List<Type> elements,
+                                          Option<Type> varargs,
+                                          List<KeywordType> keywords) {
+        return new TupleType(span, parenthesized, elements, varargs, keywords);
+    }
+
+    public static TaggedDimType makeTaggedDimType(TaggedDimType t, Type s,
+                                                  DimExpr u) {
+        return makeTaggedDimType(t.getSpan(), t.isParenthesized(), s, u,
+                                 t.getUnitExpr());
+    }
+
+    public static TaggedDimType makeTaggedDimType(Span span, boolean parenthesized,
+                                                  Type elem, DimExpr dim,
+                                                  Option<Expr> unit) {
+        return new TaggedDimType(span, parenthesized, elem, dim, unit);
+    }
+
+    public static TraitType makeTraitType(TraitType original) {
+        return makeTraitType(original.getSpan(), original.isParenthesized(),
+                             original.getName(), original.getArgs(),
+                             Collections.<StaticParam>emptyList());
+
+    }
+
+    public static TraitType makeTraitType(TraitType t,
+                                          List<StaticArg> args) {
+        return makeTraitType(t.getSpan(), t.isParenthesized(),
+                             t.getName(), args);
+    }
+
+    public static TraitType makeTraitType(Id name, StaticArg... args) {
+        return makeTraitType(name.getSpan(), false, name, Arrays.asList(args));
+    }
+
+    /** Signature separates the first element in order to guarantee a non-empty arg list. */
+    public static TraitType makeTraitType(String nameFirst, String... nameRest) {
+        // System.err.println("Please don't makeTraitType with a bogus span");
+        return makeTraitType(new Span(), false, makeId(nameFirst, nameRest));
+    }
+
+    public static TraitType makeTraitType(String name,
+                                          List<StaticArg> sargs) {
+        // System.err.println("Please don't makeTraitType with a bogus span");
+        return makeTraitType(new Span(), false, makeId(name), sargs);
+    }
+
+    public static TraitType makeTraitType(Span span, boolean isParenthesized,
+                                          Id name) {
+        return makeTraitType(span, isParenthesized, name,
+                             Collections.<StaticArg>emptyList());
+    }
+
+    public static TraitType makeTraitType(Span span, boolean isParenthesized,
+                                          Id name, StaticArg... args) {
+        return makeTraitType(span, isParenthesized, name, Arrays.asList(args));
+    }
+
+    public static TraitType makeTraitType(Span span, boolean isParenthesized,
+                                          Id name, List<StaticArg> args) {
+        return makeTraitType(span, isParenthesized, name, args,
+                             Collections.<StaticParam>emptyList());
+    }
+
+    public static TraitType makeTraitType(Span span, Id name,
+                                          List<StaticArg> args) {
+        return makeTraitType(span, false, name, args,
+                             Collections.<StaticParam>emptyList());
+    }
+
+    public static TraitType makeTraitType(Id name,
+                                          List<StaticArg> sargs) {
+        return makeTraitType(name.getSpan(), false, name, sargs);
+    }
+
+    public static TraitType makeTraitType(Id name) {
+        return makeTraitType(name.getSpan(), false, name);
+    }
+
+    public static TraitType makeTraitType(Span span, boolean parenthesized,
+                                          Id name, List<StaticArg> sargs,
+                                          List<StaticParam> sparams) {
+        return new TraitType(span, parenthesized, name, sargs, sparams);
+    }
+
+    public static VarType makeVarType(String string) {
+        return makeVarType(new Span(), makeId(string));
+    }
+
+    public static VarType makeVarType(Span span, Id id) {
+        return makeVarType(span, false, id, lexicalDepth);
+    }
+
+    public static VarType makeVarType(Span span, Id id, int depth) {
+        return makeVarType(span, false, id, depth);
+    }
+
+    public static VarType makeVarType(VarType original, int lexicalNestedness) {
+        return makeVarType(original.getSpan(), original.isParenthesized(),
+                           original.getName(), lexicalNestedness);
+    }
+
+    public static VarType makeVarType(Span span, boolean parenthesized,
+                                      Id name, int lexicalDepth) {
+        return new VarType(span, parenthesized, name, lexicalDepth);
+    }
+
     /***************************************************************************/
 
-    /*
-    public static Param makeParam(Span span, Id name, Option<Type> type) {
-        return new Param(span, name, type);
-    }
-
-    public static Param makeParam(Span span, List<Modifier> mods, Id name,
-                                  Type type) {
-        return new Param(span, name, mods, Option.some(type), Option.<Expr>none());
-    }
-
-    public static Param makeParam(Span span, List<Modifier> mods, Id name,
-                                  Option<Type> type) {
-        return new Param(span, name, mods, type, Option.<Expr>none());
-    }
-
-    public static LValue makeLValue(Id name, Type type) {
-        return new LValue(new Span(name.getSpan(), type.getSpan()),
-                          name,
-                          Collections.<Modifier>emptyList(),
-                          Option.some(type),
-                          false);
-    }
-
-    public static LValue makeLValue(Id name, Option<Type> type) {
-        return new LValue(name.getSpan(),
-                          name,
-                          Collections.<Modifier>emptyList(),
-                          type,
-                          false);
-    }
-
-    public static LValue makeLValue(Param param) {
-        return new LValue(param.getSpan(), param.getName(),
-                          param.getMods(), param.getIdType(), false);
-    }
-    */
 
     public static Id makeTemporaryId() {
@@ -600 +707 @@
     }
 
-    public static TraitType makeTraitType(TraitType t,
-                                          List<StaticArg> args) {
-        return new TraitType(t.getSpan(), t.isParenthesized(),
-                             t.getName(), args,
-                             Collections.<StaticParam>emptyList());
-    }
-
     public static TraitTypeWhere makeTraitTypeWhere(BaseType in_type) {
         Span sp = in_type.getSpan();
@@ -630 +730 @@
     }
 
-    public static TupleType makeTupleType(TupleType t, List<Type> tys) {
-        return new TupleType(t.getSpan(), t.isParenthesized(), tys);
-    }
-
-//    public static ArgType makeArgType(ArgType t, List<Type> tys, Type varargs) {
-//    return new ArgType(t.getSpan(), t.isParenthesized(), tys, varargs);
-//    }
-
     public static KeywordType makeKeywordType(KeywordType t, Type s) {
         return new KeywordType(t.getSpan(), t.getName(), s);
-    }
-
-    public static TaggedDimType makeTaggedDimType(TaggedDimType t, Type s,
-                                                  DimExpr u) {
-        return new TaggedDimType(t.getSpan(), t.isParenthesized(), s, u,
-                                 t.getUnitExpr());
     }
 
@@ -686 +772 @@
     }
 
-    public static TraitType makeTraitType(Span span, boolean isParenthesized,
-                                          Id name, List<StaticArg> args) {
-        return new TraitType(span, isParenthesized, name, args,
-                             Collections.<StaticParam>emptyList());
-    }
-
-    public static TraitType makeTraitType(Span span, boolean isParenthesized,
-            Id name, StaticArg... args) {
-        return makeTraitType(span, isParenthesized, name, Arrays.asList(args));
-    }
-
-    public static TraitType makeTraitType(Id name, StaticArg... args) {
-        return makeTraitType(name.getSpan(), false, name, Arrays.asList(args));
-    }
-
-    /** Signature separates the first element in order to guarantee a non-empty arg list. */
-    public static TraitType makeTraitType(String nameFirst, String... nameRest) {
-        // System.err.println("Please don't makeTraitType with a bogus span");
-        return makeTraitType(new Span(), false, makeId(nameFirst, nameRest),
-                Collections.<StaticArg>emptyList());
-    }
-
-    public static TraitType makeTraitType(String name,
-                                          List<StaticArg> sargs) {
-        // System.err.println("Please don't makeTraitType with a bogus span");
-        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,
-                             Collections.<StaticParam>emptyList());
-    }
-
-    public static TraitType makeTraitType(Id name) {
-        return new TraitType(name.getSpan(), name, Collections.<StaticArg>emptyList(),
-                             Collections.<StaticParam>emptyList());
-    }
-
     public static IntersectionType makeIntersectionType(Type t1, Type t2) {
         return new IntersectionType(FortressUtil.spanTwo(t1, t2), Arrays.asList(t1, t2));
@@ -741 +787 @@
         return new UnionType(FortressUtil.spanAll(types),CollectUtil.makeList(types));
     }
-
-//    public static ArrowType makeArrowType(Span span, Type domain,
-//    Type range,
-//    Option<List<BaseType>> throws_) {
-//    Option<List<Type>> throwsAsTypeList =
-//    throws_.isSome() ?
-//    Option.<List<Type>>some(new ArrayList<Type>(throws_.unwrap())) :
-//    Option.<List<Type>>none();
-//    return new ArrowType(span, domain, range, throwsAsTypeList);
-//    }
-
-    public static ArrowType makeArrowType(Span span, Type domain, Type range) {
-        return new ArrowType(span, domain, range, makeEffect(range.getSpan().getEnd()));
-    }
-
-//    public static AbstractArrowType makeGenericArrowType(Span span,
-//    List<StaticParam> staticParams,
-//    Type domain,
-//    Type range,
-//    Option<List<BaseType>> throws_,
-//    WhereClause where) {
-//    if (staticParams.isEmpty() && where.getConstraints().isEmpty() && where.getBindings().isEmpty()) {
-//    return makeArrowType(span, domain, range, throws_);
-//    }
-//    Option<List<Type>> throwsAsTypeList =
-//    throws_.isSome() ?
-//    Option.<List<Type>>some(new ArrayList<Type>(throws_.unwrap())) :
-//    Option.<List<Type>>none();
-//    return new _RewriteGenericArrowType(span, domain, range,
-//    throwsAsTypeList, staticParams, where);
-//    }
-
-//    public static AbstractArrowType makeGenericArrowType(
-//    Span span,
-//    List<StaticParam> staticParams,
-//    Type domain,
-//    Type range) {
-//    if (staticParams.isEmpty()) {
-//    return makeArrowType(span, domain, range, Option.<List<BaseType>>none());
-//    }
-//    return new _RewriteGenericArrowType(span, domain, range,
-//    Option.<List<Type>>none(), staticParams, new WhereClause());
-//    }
 
     public static Type makeDomain(Span span, List<Type> elements,
@@ -795 +798 @@
                 return elements.get(0);
             else
-                return new TupleType(span, elements);
+                return makeTupleType(span, elements);
         } else
-            return new TupleType(span, elements, varargs, keywords);
+            return makeTupleType(span, false, elements, varargs, keywords);
     }
 
@@ -996 +999 @@
     };
 
-    public static VarType makeVarType(String string) {
-        return makeVarType(new Span(), makeId(string));
-    }
-
-    public static VarType makeVarType(Span span, Id id) {
-        return new VarType(span, id);
-    }
-
     public static MatrixType makeMatrixType(Span span, Type element,
                                             ExtentRange dimension) {
@@ -1189 +1184 @@
     }
 
-    public static TupleType makeTupleType(List<Type> elements) {
-        return new TupleType(new Span(), elements);
-    }
-
-    public static TupleType makeTupleType(Span span, List<Type> elements) {
-        return new TupleType(span, elements);
-    }
-
     public static TupleType makeVoidType(Span span) {
-        return new TupleType(span, false, Collections.<Type>emptyList(),
+        return makeTupleType(span, false, Collections.<Type>emptyList(),
                              Option.<Type>none(),
                              Collections.<KeywordType>emptyList());
@@ -1208 +1195 @@
 
     public static TypeArg makeTypeArg(Span span, String string) {
-        return new TypeArg(span, new VarType(span, makeId(span, string)));
+        return new TypeArg(span, makeVarType(span, makeId(span, string)));
     }
 
@@ -1214 +1201 @@
         Span span = new Span();
         return new TypeArg(span,
-                new VarType(span, makeId(span, string)));
+                makeVarType(span, makeId(span, string)));
     }
 
@@ -1364 +1351 @@
         return ty.accept(new NodeAbstractVisitor<Type>() {
             public Type forArrowType(ArrowType t) {
-                return new ArrowType(t.getSpan(), true, t.getDomain(),
-                        t.getRange(), t.getEffect());
+                return makeArrowType(t.getSpan(), true, t.getDomain(),
+                                     t.getRange(), t.getEffect(),
+                                     t.getStaticParams(), t.getWhereClause());
             }
             public Type forArrayType(ArrayType t) {
@@ -1372 +1360 @@
             }
             public Type forVarType(VarType t) {
-                return new VarType(t.getSpan(), true, t.getName());
+                return makeVarType(t.getSpan(), true, t.getName(), t.getLexicalDepth());
             }
             public Type forMatrixType(MatrixType t) {
@@ -1379 +1367 @@
             }
             public Type forTraitType(TraitType t) {
-                return new TraitType(t.getSpan(), true, t.getName(),
+                return makeTraitType(t.getSpan(), true, t.getName(),
                                      t.getArgs(), t.getStaticParams());
             }
             public Type forTupleType(TupleType t) {
-                return new TupleType(t.getSpan(), true, t.getElements(),
+                return makeTupleType(t.getSpan(), true, t.getElements(),
                                      t.getVarargs(), t.getKeywords());
             }
             public Type forTaggedDimType(TaggedDimType t) {
-                return new TaggedDimType(t.getSpan(), true, t.getElemType(),
+                return makeTaggedDimType(t.getSpan(), true, t.getElemType(),
                                          t.getDimExpr(), t.getUnitExpr());
             }
@@ -1434 +1422 @@
     public static NamedType makeNamedType(APIName api, NamedType type) {
         if (type instanceof VarType) {
-            return new VarType(type.getSpan(),
-                    type.isParenthesized(),
-                    makeId(api, type.getName()));
+            return makeVarType(type.getSpan(),
+                               type.isParenthesized(),
+                               makeId(api, type.getName()),
+                               lexicalDepth);
         }
         else { // type instanceof TraitType
             TraitType _type = (TraitType)type;
-            return new TraitType(_type.getSpan(),
+            return makeTraitType(_type.getSpan(),
                                  _type.isParenthesized(),
                                  makeId(api, _type.getName()),
@@ -1449 +1438 @@
 
     public static TraitType makeGenericSingletonType(Id name, List<StaticParam> params) {
-        return new TraitType(name.getSpan(), name, Collections.<StaticArg>emptyList(), params);
-    }
-
-    public static VarType makeVarType(VarType original, int lexicalNestedness) {
-        return new VarType(original.getSpan(), original.isParenthesized(), original.getName(), lexicalNestedness);
-    }
-
-    public static TraitType makeTraitType(TraitType original) {
-        return new TraitType(original.getSpan(), original.isParenthesized(),
-                             original.getName(), original.getArgs(),
-                             Collections.<StaticParam>emptyList());
-
+        return makeTraitType(name.getSpan(), false, name,
+                             Collections.<StaticArg>emptyList(), params);
     }
 

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

@@ -43 +43 @@
            if (ty instanceof TaggedDimType) {
                TaggedDimType _ty = (TaggedDimType)ty;
-               yyValue = new TaggedDimType(_ty.getSpan(), _ty.getElemType(),
-                                           _ty.getDimExpr(), Option.some(a2));
+               yyValue = NodeFactory.makeTaggedDimType(_ty.getSpan(), false, _ty.getElemType(),
+                                                       _ty.getDimExpr(), Option.some(a2));
            } else {
                yyValue = syntaxError(ty.getSpan(),

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

@@ -52 +52 @@
        if ( a1 instanceof Id ) {
            dim = NodeFactory.makeDimDecl(span, (Id)a1, Option.wrap(a2));
-           ty = new VarType(a1.getSpan(), (Id)a1);
+           ty = NodeFactory.makeVarType(a1.getSpan(), (Id)a1);
        } else {
            log(span, a1 + " is not a valid dimension name.");
            Id id = NodeFactory.bogusId(span);
            dim = NodeFactory.makeDimDecl(span, id, Option.wrap(a2));
-           ty = new VarType(a1.getSpan(), id);
+           ty = NodeFactory.makeVarType(a1.getSpan(), id);
        }
        if ( a4 instanceof Id ) {

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

@@ -41 +41 @@
            if (ty instanceof TaggedDimType) {
                TaggedDimType _ty = (TaggedDimType)ty;
-               yyValue = new TaggedDimType(_ty.getSpan(), _ty.getElemType(),
-                                           _ty.getDimExpr(), Option.some(a2));
+               yyValue = NodeFactory.makeTaggedDimType(_ty.getSpan(), false, _ty.getElemType(),
+                                                       _ty.getDimExpr(), Option.some(a2));
            } else {
                yyValue = syntaxError(ty.getSpan(),
@@ -209 +209 @@
    / a1:Id a2:StaticArgs?
      { if (a2 == null)
-            yyValue = new VarType(createSpan(yyStart,yyCount), a1);
-       else yyValue = new TraitType(createSpan(yyStart,yyCount),a1,a2,
-                                    Collections.<StaticParam>emptyList());
+            yyValue = NodeFactory.makeVarType(createSpan(yyStart,yyCount), a1);
+       else yyValue = NodeFactory.makeTraitType(createSpan(yyStart,yyCount),a1,a2);
      };
 
@@ -343 +342 @@
            public Type run(Type base) {
                DimExpr dim = TypeResolver.resolveOpsDim(a1);
-               return new TaggedDimType(createSpan(yyStart,yyCount), (Type)base,
-                                        NodeFactory.makeInParentheses(dim),
-                                        Option.<Expr>none());
+               return NodeFactory.makeTaggedDimType(createSpan(yyStart,yyCount), false,
+                                                    (Type)base, NodeFactory.makeInParentheses(dim),
+                                                    Option.<Expr>none());
            }};
      };
@@ -353 +352 @@
      { yyValue = new Action<Type>() {
            public Type run(Type base) {
-               return new TaggedDimType(createSpan(yyStart,yyCount), (Type)base,
-                                        new DimRef(a1.getSpan(), a1),
-                                        Option.<Expr>none());
+               return NodeFactory.makeTaggedDimType(createSpan(yyStart,yyCount), false,
+                                                    (Type)base, new DimRef(a1.getSpan(), a1),
+                                                    Option.<Expr>none());
            }};
      };

trunk/ProjectFortress/src/com/sun/fortress/parser_util/precedence_resolver/TypeResolver.java

@@ -77 +77 @@
         DimExpr dim = new DimBinaryOp(span, true, dimToDim(expr0.getDimExpr()),
                                       dimToDim(expr2), product(span));
-        return new TaggedDimType(span, true,
-                                 typeToType(expr0.getElemType()), dim,
-                                 expr0.getUnitExpr());
+        return NodeFactory.makeTaggedDimType(span, true,
+                                             typeToType(expr0.getElemType()), dim,
+                                             expr0.getUnitExpr());
     }
 
@@ -87 +87 @@
         DimExpr dim = new DimBinaryOp(span, true, dimToDim(expr0.getDimExpr()),
                                       dimToDim(expr2), quotient(span));
-        return new TaggedDimType(span, true,
-                                 typeToType(expr0.getElemType()), dim,
-                                 expr0.getUnitExpr());
+        return NodeFactory.makeTaggedDimType(span, true,
+                                             typeToType(expr0.getElemType()), dim,
+                                             expr0.getUnitExpr());
     }
 
@@ -99 +99 @@
                 return makeProductDim(span, (TaggedDimType)first, dim);
             } else {
-                return new TaggedDimType(span, true, typeToType(first), dim);
+                return NodeFactory.makeTaggedDimType(span, true, typeToType(first), dim,
+                                                     Option.<Expr>none());
             }
         } catch (TypeConvertFailure x) {
@@ -250 +251 @@
         Type first = frame.getArg();
         if (isTypeOp(op)) {
-            return new ArrowType(spanTwo(first, last), true,
-                                 first,
-                                 typeToType(last), frame.getEffect());
+            return NodeFactory.makeArrowType(spanTwo(first, last), first,
+                                             typeToType(last), frame.getEffect());
         } else { // !(isTypeOp(op))
             try {
@@ -614 +614 @@
             }
             public Type forTaggedDimType(TaggedDimType t) {
-                return new TaggedDimType(t.getSpan(), true,
-                                         typeToType(t.getElemType()),
-                                         makeInParentheses(dimToDim(t.getDimExpr())),
-                                         t.getUnitExpr());
+                return NodeFactory.makeTaggedDimType(t.getSpan(), true,
+                                                     typeToType(t.getElemType()),
+                                                     makeInParentheses(dimToDim(t.getDimExpr())),
+                                                     t.getUnitExpr());
             }
         });
@@ -722 +722 @@
             return dim.accept(new NodeAbstractVisitor<Type>() {
                 public Type forDimRef(DimRef d) {
-                    return new VarType(d.getSpan(),
-                                       d.isParenthesized(),
-                                       d.getName());
+                    return NodeFactory.makeVarType(d.getSpan(),
+                                                   d.isParenthesized(),
+                                                   d.getName(),
+                                                   NodeFactory.lexicalDepth);
                 }
                 public Type forDimBinaryOp(DimBinaryOp d) {
                     try {
-                        return new TaggedDimType(d.getSpan(),
-                                                 d.isParenthesized(),
-                                                 makeInParentheses(dimToType(d.getLeft())),
-                                                 dimToDim(d.getRight()));
+                        return NodeFactory.makeTaggedDimType(d.getSpan(),
+                                                             d.isParenthesized(),
+                                                             makeInParentheses(dimToType(d.getLeft())),
+                                                             dimToDim(d.getRight()),
+                                                             Option.<Expr>none());
                     } catch (TypeConvertFailure e) {
                         return error(e.getMessage());
@@ -754 +756 @@
         if (ty instanceof TaggedDimType) {
             TaggedDimType _ty = (TaggedDimType)ty;
-            return new TaggedDimType(_ty.getSpan(),
-                                     _ty.isParenthesized(),
-                                     canonicalizeType(_ty.getElemType()),
-                                     canonicalizeDim(_ty.getDimExpr()),
-                                     _ty.getUnitExpr());
+            return NodeFactory.makeTaggedDimType(_ty.getSpan(),
+                                                 _ty.isParenthesized(),
+                                                 canonicalizeType(_ty.getElemType()),
+                                                 canonicalizeDim(_ty.getDimExpr()),
+                                                 _ty.getUnitExpr());
         } else return ty;
     }

trunk/ProjectFortress/src/com/sun/fortress/syntax_abstractions/phases/TemplateVarRewriterJUTest.java

@@ -44 +44 @@
         Id expr = NodeFactory.makeId("Expr");
         Map<Id,BaseType> typemap = new HashMap<Id,BaseType>();
-        typemap.put(expr, new VarType(span, expr));
+        typemap.put(expr, NodeFactory.makeVarType(span, expr));
         NTEnv ntEnv = EnvFactory.makeTestingNTEnv(typemap);
         theNTEnv = ntEnv;
@@ -66 +66 @@
     public void testRewriteVars2() {
         Map<Id, BaseType> vars = new HashMap<Id, BaseType>();
-        vars.put(NodeFactory.makeId("foo"), new VarType(span, NodeFactory.makeId(span, "Expr")));
+        vars.put(NodeFactory.makeId("foo"), NodeFactory.makeVarType(span, NodeFactory.makeId(span, "Expr")));
         TemplateVarRewriter tvr = new TemplateVarRewriter(emptyGapEnv, vars);
         String r = tvr.rewriteVars("foo");
-        assertTrue(r.startsWith(TemplateVarRewriter.GAPSYNTAXPREFIX) && 
+        assertTrue(r.startsWith(TemplateVarRewriter.GAPSYNTAXPREFIX) &&
                    r.endsWith(TemplateVarRewriter.GAPSYNTAXSUFFIX));
     }
@@ -75 +75 @@
     public void testRewriteVars3() {
         Map<Id, BaseType> vars = new HashMap<Id, BaseType>();
-        VarType expr = new VarType(span, NodeFactory.makeId(span, "Expr"));
-        vars.put(NodeFactory.makeId("foo"), expr); 
-        vars.put(NodeFactory.makeId("bar"), expr); 
+        VarType expr = NodeFactory.makeVarType(span, NodeFactory.makeId(span, "Expr"));
+        vars.put(NodeFactory.makeId("foo"), expr);
+        vars.put(NodeFactory.makeId("bar"), expr);
         vars.put(NodeFactory.makeId("Baz"), expr);
         FreshName.reset();
@@ -95 +95 @@
     public void testRewriteVars4() {
         Map<Id, BaseType> vars = new HashMap<Id, BaseType>();
-        VarType expr = new VarType(NodeFactory.makeId("Expr"));
-        vars.put(NodeFactory.makeId("foo"), expr); 
-        vars.put(NodeFactory.makeId("bar"), expr); 
+        VarType expr = NodeFactory.makeVarType(NodeFactory.makeId("Expr"));
+        vars.put(NodeFactory.makeId("foo"), expr);
+        vars.put(NodeFactory.makeId("bar"), expr);
         vars.put(NodeFactory.makeId("Baz"), expr);
         FreshName.reset();
@@ -113 +113 @@
         Map<Id, BaseType> vars = new HashMap<Id, BaseType>();
         TemplateVarRewriter tvr = new TemplateVarRewriter(emptyGapEnv, vars);
-        VarType expr = new VarType(NodeFactory.makeId("Expr"));
-        vars.put(NodeFactory.makeId("foo"), expr); 
-        vars.put(NodeFactory.makeId("bar"), expr); 
+        VarType expr = NodeFactory.makeVarType(NodeFactory.makeId("Expr"));
+        vars.put(NodeFactory.makeId("foo"), expr);
+        vars.put(NodeFactory.makeId("bar"), expr);
         vars.put(NodeFactory.makeId("Baz"), expr);
         FreshName.reset();
@@ -130 +130 @@
         Map<Id, BaseType> vars = new HashMap<Id, BaseType>();
         TemplateVarRewriter tvr = new TemplateVarRewriter(emptyGapEnv, vars);
-        VarType expr = new VarType(NodeFactory.makeId("Expr"));
-        vars.put(NodeFactory.makeId("foo"), expr); 
-        vars.put(NodeFactory.makeId("bar"), expr); 
-        vars.put(NodeFactory.makeId("Baz"), expr); 
+        VarType expr = NodeFactory.makeVarType(NodeFactory.makeId("Expr"));
+        vars.put(NodeFactory.makeId("foo"), expr);
+        vars.put(NodeFactory.makeId("bar"), expr);
+        vars.put(NodeFactory.makeId("Baz"), expr);
         vars.put(NodeFactory.makeId("Boz"), expr);
         FreshName.reset();
@@ -150 +150 @@
         Map<Id, BaseType> vars = new HashMap<Id, BaseType>();
         TemplateVarRewriter tvr = new TemplateVarRewriter(emptyGapEnv, vars);
-        VarType expr = new VarType(span, NodeFactory.makeId(span, "Expr"));
+        VarType expr = NodeFactory.makeVarType(span, NodeFactory.makeId(span, "Expr"));
         vars.put(NodeFactory.makeId("foo"), expr);
         String r = tvr.rewriteVars("foo fooo foo");
@@ -164 +164 @@
         Map<Id, BaseType> vars = new HashMap<Id, BaseType>();
         TemplateVarRewriter tvr = new TemplateVarRewriter(emptyGapEnv, vars);
-        VarType expr = new VarType(span, NodeFactory.makeId(span, "Expr"));
+        VarType expr = NodeFactory.makeVarType(span, NodeFactory.makeId(span, "Expr"));
         vars.put(NodeFactory.makeId("foo"), expr);
         vars.put(NodeFactory.makeId("bar"), expr);
@@ -174 +174 @@
         Map<Id, BaseType> vars = new HashMap<Id, BaseType>();
         TemplateVarRewriter tvr = new TemplateVarRewriter(emptyGapEnv, vars);
-        VarType expr = new VarType(span, NodeFactory.makeId(span, "Expr"));
+        VarType expr = NodeFactory.makeVarType(span, NodeFactory.makeId(span, "Expr"));
         vars.put(NodeFactory.makeId("e"), expr);
         String r = tvr.rewriteVars("(e \" world\"");
@@ -186 +186 @@
         Map<Id, BaseType> vars = new HashMap<Id, BaseType>();
         TemplateVarRewriter tvr = new TemplateVarRewriter(emptyGapEnv, vars);
-        VarType expr = new VarType(span, NodeFactory.makeId(span, "Expr"));
+        VarType expr = NodeFactory.makeVarType(span, NodeFactory.makeId(span, "Expr"));
         vars.put(NodeFactory.makeId("e"), expr);
         String r = tvr.rewriteVars("\"e\"");

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

@@ -38 +38 @@
     private Span span = NodeFactory.makeSpan("bogus");
 
-    private VarType stringType = new VarType(span, NodeFactory.makeId("FortressBuiltin", "String"));
+    private VarType stringType = NodeFactory.makeVarType(span, NodeFactory.makeId("FortressBuiltin", "String"));
     private String stringTypeResult = "String";
-    private VarType fortressASTType = new VarType(span, NodeFactory.makeId("FortressAst", "Decl"));
+    private VarType fortressASTType = NodeFactory.makeVarType(span, NodeFactory.makeId("FortressAst", "Decl"));
     private String fortressASTTypeResult = "Decl";
 
@@ -47 +47 @@
         List<StaticArg> args = new LinkedList<StaticArg>();
         args.add(new TypeArg(span, typeArg));
-        return new TraitType(span, name, args, Collections.<StaticParam>emptyList());
+        return NodeFactory.makeTraitType(span, name, args);
     }