Changeset 3186

Timestamp:

12/10/08 06:38:03 (12 months ago)

Author:

sukyoungryu

Message:

[ast refactoring] Removed optional fields of FnDecl?, DimDecl?, UnitDecl?, PropertyDecl?, TypeAlias?, Binding, LValue, and Param.

Location:

trunk/ProjectFortress

Files:

• astgen/Fortress.ast (modified) (8 diffs)
• src/com/sun/fortress/compiler/desugarer/DesugaringVisitor.java (modified) (1 diff)
• src/com/sun/fortress/compiler/desugarer/ObjectExpressionVisitor.java (modified) (5 diffs)
• src/com/sun/fortress/compiler/desugarer/VarRefContainer.java (modified) (4 diffs)
• src/com/sun/fortress/compiler/disambiguator/SelfParamDisambiguator.java (modified) (1 diff)
• src/com/sun/fortress/compiler/index/FieldSetterMethod.java (modified) (2 diffs)
• src/com/sun/fortress/compiler/typechecker/InferenceVarInserter.java (modified) (1 diff)
• src/com/sun/fortress/compiler/typechecker/VarTypeEnv.java (modified) (5 diffs)
• src/com/sun/fortress/nodes_util/ExprFactory.java (modified) (2 diffs)
• src/com/sun/fortress/nodes_util/NodeFactory.java (modified) (5 diffs)
• src/com/sun/fortress/parser/Function.rats (modified) (1 diff)
• src/com/sun/fortress/parser/LocalDecl.rats (modified) (2 diffs)
• src/com/sun/fortress/parser/NoNewlineExpr.rats (modified) (1 diff)
• src/com/sun/fortress/parser/OtherDecl.rats (modified) (4 diffs)
• src/com/sun/fortress/parser/Variable.rats (modified) (1 diff)
• src/com/sun/fortress/parser_util/FortressUtil.java (modified) (3 diffs)
• src/com/sun/fortress/syntax_abstractions/phases/Transform.java (modified) (3 diffs)

trunk/ProjectFortress/astgen/Fortress.ast

@@ -320 +320 @@
                        Option<WhereClause> whereClause,
                        Option<Contract> contract,
-                       Id unambiguousName = new Id(in_span, "FN$"+in_span.toString()),
+                       Id unambiguousName,
                        Option<Expr> body,
-                       Option<Id> implementsUnambiguousName = Option.<Id>none())
+                       Option<Id> implementsUnambiguousName)
                       implements Applicable, Generic;
                 /**
@@ -352 +352 @@
                      * e.g.) dim Length SI_unit meter meters m
                      */
-                    DimDecl(Id dimId, Option<Type> derived = Option.<Type>none(),
-                            Option<Id> defaultId = Option.<Id>none());
+                    DimDecl(Id dimId, Option<Type> derived, Option<Id> defaultId);
                     /**
                      * unit declaration
@@ -359 +358 @@
                      * e.g.) unit inch inches: Length
                      */
-                    UnitDecl(boolean si_unit = false,
-                             List<Id> units = Collections.<Id>emptyList(),
-                             Option<Type> dimType = Option.<Type>none(),
-                             Option<Expr> defExpr);
+                    UnitDecl(boolean si_unit, List<Id> units,
+                             Option<Type> dimType, Option<Expr> defExpr);
                 /**
                  * test declaration
@@ -376 +373 @@
                  * e.g.) property fIsMonotonic = FORALL (x:ZZ, y:ZZ) (x < y) -> (f(x) < f(y))
                  */
-                PropertyDecl(Option<Id> name = Option.<Id>none(), List<Param> params,
-                             Expr expr);
+                PropertyDecl(Option<Id> name, List<Param> params, Expr expr);
                 /**
                  * type alias declaration
@@ -384 +380 @@
                  */
                 TypeAlias(Id name,
-                          List<StaticParam> staticParams
-                              = Collections.<StaticParam>emptyList(),
+                          List<StaticParam> staticParams,
                           Type typeDef);
                 /**
@@ -417 +412 @@
              * left-hand side of variable declaration or value parameter
              */
-            abstract Binding(Id name,
-                             List<Modifier> mods = Collections.<Modifier>emptyList(),
-                             Option<Type> idType = Option.<Type>none()) implements Lhs;
+            abstract Binding(Id name, List<Modifier> mods,
+                             Option<Type> idType) implements Lhs;
                 /**
                  * left-hand side of variable declaration
@@ -425 +419 @@
                  * Name must be unqualified.
                  */
-                LValue(boolean mutable = false);
+                LValue(boolean mutable);
                 /**
                  * value parameter of functional declarations and object declarations
@@ -445 +439 @@
                  * It is a varargs parameter if the varargsType field is set.
                  */
-                Param(Option<Expr> defaultExpr = Option.<Expr>none(),
-                      Option<Type> varargsType = Option.<Type>none());
+                Param(Option<Expr> defaultExpr, Option<Type> varargsType);
             /**
              * expression

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

@@ -280 +280 @@
         List<Param> params = new ArrayList<Param>();
         Id param = NodeFactory.makeId(span, "param_"+name);
-        params.add((Param)NodeFactory.makeParam(span, new LinkedList<Modifier>(),
-                                                param, ty));
+        params.add((Param)NodeFactory.makeParam(param, ty));
         Expr rhs = ExprFactory.makeVarRef(span, param, ty);
         Expr assign;

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

@@ -576 +576 @@
                             exit.getExprType(), exit.getTarget(), var);
                         exitFnExprParams.add(
-                            NodeFactory.makeParam(exitSpan,
-                                exitWithId, exitWithTypeOp) );
+                            NodeFactory.makeParam(exitWithId, exitWithTypeOp) );
                     } else {
                         throw new DesugarerError( exitSpan,
@@ -726 +725 @@
                     // FIXME: what span should I use?
                     type = var.getExprType();
-                    param = NodeFactory.makeParam(var.getSpan(),
-                                                        var.getVarId(), type);
+                    param = NodeFactory.makeParam(var.getVarId(), type);
                     params.add(param);
                 }
@@ -742 +740 @@
                 if ( ! (name instanceof Id) )
                     bug(name, "The name field of FnRef should be Id.");
-                param = NodeFactory.makeParam(fn.getSpan(),
-                                              (Id)name, type);
+                param = NodeFactory.makeParam((Id)name, type);
                 params.add(param);
             }
@@ -771 +768 @@
                 Id exitFnId = NodeFactory.makeId(exitSpan,
                         MANGLE_CHAR + EXIT_FUNC_PREFIX + "_" + exitIndex);
-                param = NodeFactory.makeParam(exitSpan, exitFnId, type);
+                param = NodeFactory.makeParam(exitFnId, type);
                 params.add(param);
                 Pair<Span, Id> exitKey = new Pair<Span,Id>(exitSpan, label);
@@ -801 +798 @@
         Id enclosingParamId = NodeFactory.makeId(paramSpan,
                 MANGLE_CHAR + ENCLOSING_PREFIX + "_" + objExprNestingLevel);
-        param = NodeFactory.makeParam(paramSpan,
-                                        enclosingParamId, enclosingSelfType);
+        param = NodeFactory.makeParam(enclosingParamId, enclosingSelfType);
 
         return param;

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

@@ -103 +103 @@
 
     public Param containerTypeParam() {
-        return new Param( origDeclNode.getSpan(),
-                          containerVarId(), containerType() );
+        return NodeFactory.makeParam( origDeclNode.getSpan(),
+                                      containerVarId(), containerType() );
     }
 
@@ -110 +110 @@
         List<LValue> lhs = new LinkedList<LValue>();
         // set the field to be immutable
-        lhs.add( new LValue(origDeclNode.getSpan(), containerVarId(),
-                            containerType(), false) );
+        lhs.add( NodeFactory.makeLValue(origDeclNode.getSpan(), containerVarId(),
+                                        containerType()) );
         VarDecl field = new VarDecl( origDeclNode.getSpan(),
                                      lhs, Option.<Expr>some(makeCallToContainerObj()) );
@@ -133 +133 @@
         List<LValue> lhs = new LinkedList<LValue>();
         // set the field to be immutable
-        lhs.add( new LValue(origDeclNode.getSpan(), containerVarId(),
-                            containerType(), false) );
+        lhs.add( NodeFactory.makeLValue(origDeclNode.getSpan(), containerVarId(),
+                                        containerType()) );
         LocalVarDecl ret = ExprFactory.makeLocalVarDecl( origDeclNode.getSpan(),
                             lhs, makeCallToContainerObj(), bodyExprs );
@@ -142 +142 @@
 
     private Param makeVarParamFromVarRef(VarRef var,
-                                               Span paramSpan,
+                                         Span paramSpan,
                                                Option<Type> typeOp) {
         List<Modifier> mods = new LinkedList<Modifier>();
         mods.add( new ModifierSettable() );
-        Param param = new Param(paramSpan, var.getVarId(), mods, typeOp);
+        Param param = NodeFactory.makeParam(paramSpan, mods, var.getVarId(), typeOp);
         return param;
     }

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

@@ -107 +107 @@
                                 new_type = type_result;
 
-                        return new Param(that.getSpan(),
-                                         that.getName(),
-                                         that.getMods(),
-                                         new_type,
-                                         that.getDefaultExpr(),
-                                         that.getVarargsType());
+                        return NodeFactory.makeParam(that.getSpan(),
+                                                     that.getMods(),
+                                                     that.getName(),
+                                                     new_type,
+                                                     that.getDefaultExpr(),
+                                                     that.getVarargsType());
                     } else
                         return that;

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

@@ -34 +34 @@
 import com.sun.fortress.nodes.Type;
 import com.sun.fortress.nodes_util.Span;
+import com.sun.fortress.nodes_util.NodeFactory;
 import com.sun.fortress.useful.NI;
 
@@ -58 +59 @@
         public List<Param> parameters() {
             // return the implicit parameter
-            Param p = new Param(_ast.getSpan(),
-                                new Id(_ast.getSpan(), "fakeParamForImplicitSetter"),
-                                Collections.<Modifier>emptyList(),
-                                _ast.getIdType(),
-                                Option.<Expr>none());
+            Param p = NodeFactory.makeParam(_ast.getSpan(),
+                                            Collections.<Modifier>emptyList(),
+                                            new Id(_ast.getSpan(), "fakeParamForImplicitSetter"),
+                                            _ast.getIdType());
                 return Collections.singletonList(p);
         }

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

@@ -50 +50 @@
                 if( type_result.isNone() ) {
                         Option<Type> new_type = Option.<Type>some(NodeFactory.make_InferenceVarType(that.getName().getSpan()));
-                        return new LValue(that.getSpan(),name_result,mods_result,new_type,that.isMutable());
+                        return NodeFactory.makeLValue(that.getSpan(), name_result,
+                                                      mods_result, new_type,
+                                                      that.isMutable());
                 }
                 else {

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

@@ -49 +49 @@
     private Map<Id, Variable> entries;
     private TypeEnv parent;
-    
+
     VarTypeEnv(Map<Id, Variable> _entries, TypeEnv _parent) {
         entries = _entries;
@@ -62 +62 @@
      if (!(var instanceof Id)) { return parent.binding(var); }
      Id _var = (Id)var;
-     
+
      Id no_api_var = removeApi(_var);
-     
+
         if (entries.containsKey(no_api_var)) {
             Variable result = entries.get(no_api_var);
@@ -79 +79 @@
                 Option<Type> type = typeFromParam(param);
 
-                return some(new BindingLookup(makeLValue(
-                  makeLValue(param.getName(), type), param.getMods())));
+                return some(new BindingLookup(makeLValue(param.getSpan(), param.getName(),
+                                                         param.getMods(), type, false)));
             }
         } else {
@@ -104 +104 @@
              if (!(id instanceof Id)) { return parent.declarationSite(id); }
              Id _var = (Id)id;
-             
+
              Id no_api_var = removeApi(_var);
-             
+
              if (entries.containsKey(no_api_var)) {
                  Variable var = entries.get(no_api_var);
@@ -128 +128 @@
         public TypeEnv replaceAllIVars(Map<_InferenceVarType, Type> ivars) {
                 Map<Id, Variable> new_entries = new HashMap<Id,Variable>();
-                
+
                 InferenceVarReplacer rep = new InferenceVarReplacer(ivars);
-                
+
                 for( Map.Entry<Id, Variable> entry : this.entries.entrySet() ) {
                         Variable v = entry.getValue();
-                
+
                         Variable new_v = v.acceptNodeUpdateVisitor(rep);
                         new_entries.put(entry.getKey(), new_v);
                 }
-                
+
                 return new VarTypeEnv(new_entries, parent.replaceAllIVars(ivars));
         }

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

@@ -665 +665 @@
         Option<Expr> _rhs = Option.some(_r);
         _body.add(_body_expr);
-        _lhs.add(new LValue(p.getSpan(), p,false));
+        _lhs.add(NodeFactory.makeLValue(p.getSpan(), p));
         return new LocalVarDecl(FortressUtil.spanTwo(p, _r), _body, _lhs, _rhs);
     }
@@ -674 +674 @@
         Option<Expr> _rhs = Option.some(_r);
         _body.add(_body_expr);
-        _lhs.add(new LValue(sp, p,false));
+        _lhs.add(NodeFactory.makeLValue(sp, p));
         return new LocalVarDecl(sp, _body, _lhs, _rhs);
     }

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

@@ -317 +317 @@
     }
 
+    public static DimDecl makeDimDecl(Span span, Id dim, Option<Type> derived) {
+        return makeDimDecl(span, dim, derived, Option.<Id>none());
+    }
+
+    public static DimDecl makeDimDecl(Span span, Id dim, Option<Type> derived,
+                                      Option<Id> defaultId) {
+        return new DimDecl(span, dim, derived, defaultId);
+    }
+
+    public static UnitDecl makeUnitDecl(Span span, boolean si_unit, List<Id> units,
+                                        Option<Type> dim, Option<Expr> def) {
+        return new UnitDecl(span, si_unit, units, dim, def);
+    }
+
+    public static LValue makeLValue(Span span, Id name, Option<Type> type) {
+        return makeLValue(span, name,
+                          Collections.<Modifier>emptyList(),
+                          type, false);
+    }
+
+    public static LValue makeLValue(Span span, Id id, Type ty) {
+        return makeLValue(span, id, Option.<Type>some(ty));
+    }
+
+    public static LValue makeLValue(Span span, Id id) {
+        return makeLValue(span, id, Option.<Type>none());
+    }
+
+    public static LValue makeLValue(Id id) {
+        return makeLValue(id.getSpan(), id);
+    }
+
+    public static LValue makeLValue(Id name, Id type) {
+        return makeLValue(FortressUtil.spanTwo(name, type),
+                          name,
+                          Collections.<Modifier>emptyList(),
+                          Option.some((Type)makeVarType(type.getSpan(),type)),
+                          false);
+    }
+
+    public static LValue makeLValue(Id id, Type ty) {
+        return makeLValue(id, ty, Collections.<Modifier>emptyList());
+    }
+
+    public static LValue makeLValue(Id id, Type ty,
+                                    List<Modifier> mods) {
+        return makeLValue(id.getSpan(), id, mods, Option.<Type>some(ty),
+                          FortressUtil.getMutable(mods));
+    }
+
+    public static LValue makeLValue(String name, Type type) {
+        return makeLValue(type.getSpan(), makeId(name),
+                          Collections.<Modifier>emptyList(), Option.some(type), false);
+    }
+
+    public static LValue makeLValue(String name, Type type, List<Modifier> mods) {
+        return makeLValue(type.getSpan(), makeId(name), mods, Option.some(type), false);
+    }
+
+    public static LValue makeLValue(String name, String type) {
+        return makeLValue(name, makeVarType(type));
+    }
+
+    public static LValue makeLValue(LValue lvb, List<Modifier> mods,
+                                    boolean mutable) {
+        return makeLValue(lvb.getSpan(), lvb.getName(), mods, lvb.getIdType(), mutable);
+    }
+
+    public static LValue makeLValue(LValue lvb, Id name) {
+        return makeLValue(lvb.getSpan(), name, lvb.getMods(), lvb.getIdType(),
+                          lvb.isMutable());
+    }
+
+    public static LValue makeLValue(LValue lvb, boolean mutable) {
+        return makeLValue(lvb.getSpan(), lvb.getName(), lvb.getMods(), lvb.getIdType(),
+                          mutable);
+    }
+
+    public static LValue makeLValue(LValue lvb, List<Modifier> mods) {
+        boolean mutable = lvb.isMutable();
+        for (Modifier m : mods) {
+            if (m instanceof ModifierVar || m instanceof ModifierSettable)
+                mutable = true;
+        }
+        return makeLValue(lvb.getSpan(), lvb.getName(), mods, lvb.getIdType(), mutable);
+    }
+
+    public static LValue makeLValue(LValue lvb, Type ty) {
+        return makeLValue(lvb.getSpan(), lvb.getName(), lvb.getMods(),
+                          Option.<Type>some(ty), lvb.isMutable());
+    }
+
+    public static LValue makeLValue(LValue lvb, Type ty,
+                                    boolean mutable) {
+        return makeLValue(lvb.getSpan(), lvb.getName(), lvb.getMods(),
+                          Option.<Type>some(ty), mutable);
+    }
+
+    public static LValue makeLValue(LValue lvb, Type ty,
+                                    List<Modifier> mods) {
+        boolean mutable = lvb.isMutable();
+        for (Modifier m : mods) {
+            if (m instanceof ModifierVar || m instanceof ModifierSettable)
+                mutable = true;
+        }
+        return makeLValue(lvb.getSpan(), lvb.getName(), mods,
+                          Option.<Type>some(ty), mutable);
+    }
+
+    public static LValue makeLValue(Span span, Id name, List<Modifier> mods,
+                                    Option<Type> type, boolean mutable) {
+        return new LValue(span, name, mods, type, mutable);
+    }
+
+    public static Param makeParam(Span span, List<Modifier> mods, Id name,
+                                  Type type) {
+        return makeParam(span, mods, name, Option.<Type>some(type));
+    }
+
+    public static Param makeParam(Span span, List<Modifier> mods, Id name,
+                                  Option<Type> type) {
+        return makeParam(span, mods, name, type,
+                         Option.<Expr>none(), Option.<Type>none());
+    }
+
+    public static Param makeParam(Id name) {
+        return makeParam(name, Option.<Type>none());
+    }
+
+    public static Param makeParam(Id id, Type type) {
+        return makeParam(id.getSpan(), Collections.<Modifier>emptyList(), id,
+                         Option.<Type>some(type));
+    }
+
+    public static Param makeParam(Id id, Option<Type> type) {
+        return makeParam(id.getSpan(), Collections.<Modifier>emptyList(), id, type);
+    }
+
+    public static Param makeParam(Span span, Id id, Option<Type> type) {
+        return makeParam(span, Collections.<Modifier>emptyList(), id, type);
+    }
+
+    public static Param makeParam(Param param, Expr expr) {
+        return makeParam(param.getSpan(), param.getMods(), param.getName(),
+                         param.getIdType(), Option.<Expr>some(expr),
+                         param.getVarargsType());
+    }
+
+    public static Param makeParam(Param param, List<Modifier> mods) {
+        return makeParam(param.getSpan(), mods, param.getName(),
+                         param.getIdType(), param.getDefaultExpr(),
+                         param.getVarargsType());
+    }
+
+    public static Param makeParam(Param param, Id newId) {
+        return makeParam(param.getSpan(), param.getMods(), newId,
+                         param.getIdType(), param.getDefaultExpr(),
+                         param.getVarargsType());
+    }
+
+    public static Param makeVarargsParam(Id name, Type type) {
+        return makeParam(name.getSpan(), Collections.<Modifier>emptyList(), name,
+                         Option.<Type>none(), Option.<Expr>none(), Option.<Type>some(type));
+    }
+
+    public static Param makeVarargsParam(Param param, List<Modifier> mods) {
+        return makeParam(param.getSpan(), mods, param.getName(),
+                         Option.<Type>none(), Option.<Expr>none(),
+                         param.getVarargsType());
+    }
+
+    public static Param makeVarargsParam(Span span, List<Modifier> mods,
+                                         Id name, Type type) {
+        return makeParam(span, mods, name,
+                         Option.<Type>none(), Option.<Expr>none(),
+                         Option.<Type>some(type));
+    }
+
+    public static Param makeAbsParam(Type type) {
+        return makeParam(type.getSpan(), Collections.<Modifier>emptyList(),
+                         new Id(type.getSpan(), "_"), type);
+    }
+
+    public static Param makeParam(Span span, List<Modifier> mods, Id name,
+                                  Option<Type> type, Option<Expr> expr,
+                                  Option<Type> varargsType) {
+        return new Param(span, name, mods, type, expr, varargsType);
+    }
+
+    /***************************************************************************/
+
     /*
-    public static FnDecl makeFnDecl(Span span, List<Modifier> mods,
-                                    Id name, Option<Type> type) {
-        return makeFnDecl(span, mods, name, Collections.<Param>emptyList(), type);
-    }
-
-    public static FnDecl makeFnDecl(Span span, List<Modifier> mods,
-                                    Id name, List<Param> params,
-                                    Option<Type> type) {
-        return new FnDecl(span, mods, name, Collections.<StaticParam>emptyList(),
-                          params, type, Option.<Expr>none());
-    }
-
-    public static FnDecl makeFnDecl(Span s, List<Modifier> mods,
-                                    IdOrOpOrAnonymousName name,
-                                    List<StaticParam> staticParams,
-                                    List<Param> params,
-                                    Option<Type> returnType,
-                                    Option<List<BaseType>> throwss,
-                                    Option<WhereClause> where,
-                                    Option<Contract> contract) {
-        return new FnDecl(s, mods, name, staticParams, params, returnType,
-                          throwss, where, contract, Option.<Expr>none(), Option.<Id>none());
-    }
-
-    public static FnDecl makeFnDecl(Span span, List<Modifier> mods,
-                                  Id name, Option<Type> type, Expr body) {
-        return makeFnDecl(span, mods, name, Collections.<Param>emptyList(), type,
-                          Option.<Expr>some(body));
-    }
-
-    public static FnDecl makeFnDecl(Span span, List<Modifier> mods,
-                                  Id name, Option<Type> type, Option<Expr> body) {
-        return makeFnDecl(span, mods, name, Collections.<Param>emptyList(), type,
-                          body);
-    }
-
-    public static FnDecl makeFnDecl(Span span, List<Modifier> mods,
-                                  Id name, List<Param> params,
-                                  Option<Type> type, Expr body) {
-        return new FnDecl(span, mods, name, Collections.<StaticParam>emptyList(),
-                          params, type, Option.<List<BaseType>>none(),
-                          Option.<WhereClause>none(), Option.<Contract>none(),
-                          Option.<Expr>some(body));
-    }
-
-    public static FnDecl makeFnDecl(Span span, List<Modifier> mods,
-                                  Id name, List<Param> params,
-                                  Option<Type> type, Option<Expr> body) {
-        return new FnDecl(span, mods, name, Collections.<StaticParam>emptyList(),
-                         params, type, Option.<List<BaseType>>none(),
-                         Option.<WhereClause>none(), Option.<Contract>none(),
-                         body);
+    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);
     }
     */
@@ -413 +585 @@
         Indices indices = ind.unwrap(new Indices(span, Collections.<ExtentRange>emptyList()));
         return new ArrayType(span, element, indices);
-    }
-
-    public static DimDecl makeDimDecl(Span span, Id dim) {
-        return new DimDecl(span, dim);
     }
 
@@ -836 +1004 @@
     }
 
-    public static LValue makeLValue(Id id) {
-        return new LValue(id.getSpan(), id);
-    }
-
-    public static LValue makeLValue(String name, String type) {
-        return makeLValue(name, makeVarType(type));
-    }
-
-    public static LValue makeLValue(Id name, Id type) {
-        return new LValue(new Span(name.getSpan(), type.getSpan()),
-                          name,
-                          Collections.<Modifier>emptyList(),
-                          Option.some((Type)makeVarType(type.getSpan(),type)),
-                          false);
-    }
-
-    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(String name, Type type) {
-        return new LValue(type.getSpan(), makeId(name),
-                          Collections.<Modifier>emptyList(), Option.some(type), false);
-    }
-
-    public static LValue makeLValue(String name, Type type, List<Modifier> mods) {
-        LValue result = makeLValue(name, type);
-        return makeLValue(result, mods);
-    }
-
-    public static LValue makeLValue(LValue lvb, Id name) {
-        return new LValue(lvb.getSpan(), name, lvb.getMods(), lvb.getIdType(),
-                          lvb.isMutable());
-    }
-
-    public static LValue makeLValue(LValue lvb, boolean mutable) {
-        return new LValue(lvb.getSpan(), lvb.getName(), lvb.getMods(), lvb.getIdType(),
-                          mutable);
-    }
-
-    public static LValue makeLValue(LValue lvb, List<Modifier> mods) {
-        boolean mutable = lvb.isMutable();
-        for (Modifier m : mods) {
-            if (m instanceof ModifierVar || m instanceof ModifierSettable)
-                mutable = true;
-        }
-        return new LValue(lvb.getSpan(), lvb.getName(), mods, lvb.getIdType(), mutable);
-    }
-
-    public static LValue makeLValue(LValue lvb, List<Modifier> mods,
-            boolean mutable) {
-        return new LValue(lvb.getSpan(), lvb.getName(), mods, lvb.getIdType(), mutable);
-    }
-
-    public static LValue makeLValue(LValue lvb, Type ty) {
-        return new LValue(lvb.getSpan(), lvb.getName(), lvb.getMods(),
-                          Option.some(ty), lvb.isMutable());
-    }
-
-    public static LValue makeLValue(LValue lvb, Type ty,
-            boolean mutable) {
-        return new LValue(lvb.getSpan(), lvb.getName(), lvb.getMods(),
-                          Option.some(ty), mutable);
-    }
-
-    public static LValue makeLValue(LValue lvb, Type ty,
-            List<Modifier> mods) {
-        boolean mutable = lvb.isMutable();
-        for (Modifier m : mods) {
-            if (m instanceof ModifierVar || m instanceof ModifierSettable)
-                mutable = true;
-        }
-        return new LValue(lvb.getSpan(), lvb.getName(), mods,
-                          Option.some(ty), mutable);
-    }
-
-    public static LValue makeLValue(Param param) {
-        return new LValue(param.getSpan(), param.getName(),
-                          param.getMods(), param.getIdType(), false);
-    }
-
     public static MatrixType makeMatrixType(Span span, Type element,
                                             ExtentRange dimension) {
@@ -1050 +1125 @@
     }
 
-    public static Param makeVarargsParam(Id name, Type type) {
-        return new Param(name.getSpan(), name, Collections.<Modifier>emptyList(),
-                         Option.<Type>none(), Option.<Expr>none(), Option.<Type>some(type));
-    }
-
-    public static Param makeVarargsParam(Param param, List<Modifier> mods) {
-        return new Param(param.getSpan(), param.getName(), mods,
-                         Option.<Type>none(), Option.<Expr>none(),
-                         param.getVarargsType());
-    }
-
-    public static Param makeVarargsParam(Span span, List<Modifier> mods,
-                                         Id name, Type type) {
-        return new Param(span, name, mods,
-                         Option.<Type>none(), Option.<Expr>none(),
-                         Option.<Type>some(type));
-    }
-
-    public static Param makeAbsParam(Type type) {
-        Id id = new Id(type.getSpan(), "_");
-        return new Param(type.getSpan(), id, Collections.<Modifier>emptyList(),
-                         Option.some(type), Option.<Expr>none());
-    }
-
-    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 Param makeParam(Id id, Type type) {
-        return new Param(id.getSpan(), id, Collections.<Modifier>emptyList(),
-                         Option.some(type), Option.<Expr>none());
-    }
-
-    public static Param makeParam(Id name) {
-        return new Param(name.getSpan(), name, Collections.<Modifier>emptyList(),
-                         Option.<Type>none(), Option.<Expr>none());
-    }
-
-    public static Param makeParam(Param param, Expr expr) {
-        return new Param(param.getSpan(), param.getName(), param.getMods(),
-                         param.getIdType(), Option.some(expr));
-    }
-
-    public static Param makeParam(Param param, List<Modifier> mods) {
-        return new Param(param.getSpan(), param.getName(), mods,
-                         param.getIdType(), param.getDefaultExpr());
-    }
-
-    public static Param makeParam(Param param, Id newId) {
-        return new Param(param.getSpan(), newId, param.getMods(),
-                         param.getIdType(), param.getDefaultExpr());
-    }
-
     public static StaticParam makeTypeParam(String name) {
         Span s = new Span();
@@ -1171 +1187 @@
                                Option.<Type>none(), false,
                                new KindNat());
-    }
-
-    public static Param makeParam(Span span, Id name, Option<Type> type) {
-        return new Param(span, name, type);
     }
 

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

@@ -81 +81 @@
        We could do this, if we had a suitable value for bottomExpr:
        for (KeywordType k : d.getKeywords()) {
-           params.add(new Param(k.getSpan(), mods, k.getName(), k.getType(), bottomExpr));
+           params.add(NodeFactory.makeParam(k.getSpan(), mods,
+                                            k.getName(), k.getType(), bottomExpr,
+                                            Option.<Type>none()));
        }
        */

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

@@ -176 +176 @@
 LValue VarMayType := a1:BindId a2:(s void:colon s NoNewlineType)?
      { if (a2 == null)
-           yyValue = FortressUtil.mkLValue(createSpan(yyStart,yyCount),a1);
+           yyValue = NodeFactory.makeLValue(createSpan(yyStart,yyCount),a1);
        else
-           yyValue = FortressUtil.mkLValue(createSpan(yyStart,yyCount),a1,a2);
+           yyValue = NodeFactory.makeLValue(createSpan(yyStart,yyCount),a1,a2);
      };
 
@@ -193 +193 @@
 LValue VarWoType =
      a1:BindId
-     { yyValue = FortressUtil.mkLValue(createSpan(yyStart,yyCount), a1); }
+     { yyValue = NodeFactory.makeLValue(createSpan(yyStart,yyCount), a1); }
    / Unpasting
      { Span span = createSpan(yyStart,yyCount);
-       yyValue = FortressUtil.mkLValue(span, new Id(span, "_"));
+       yyValue = NodeFactory.makeLValue(span, new Id(span, "_"));
      };
 

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

@@ -205 +205 @@
 /* NoNewlineVarWType ::= BindId s NoNewlineIsType */
 LValue NoNewlineVarWType = a1:BindId s a2:NoNewlineIsType
-     { yyValue = FortressUtil.mkLValue(createSpan(yyStart,yyCount),a1,a2); };
+     { yyValue = NodeFactory.makeLValue(createSpan(yyStart,yyCount),a1,a2); };
 
 /* NoNewlineIsType ::= : w NoNewlineType */

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

@@ -51 +51 @@
        for (Id a5Elt : a5s.list()) { ids.add(a5Elt); }
        if ( a1 instanceof Id ) {
-           dim = new DimDecl(span, (Id)a1, Option.wrap(a2));
+           dim = NodeFactory.makeDimDecl(span, (Id)a1, Option.wrap(a2));
            ty = new VarType(a1.getSpan(), (Id)a1);
        } else {
            log(span, a1 + " is not a valid dimension name.");
            Id id = NodeFactory.bogusId(span);
-           dim = new DimDecl(span, id, Option.wrap(a2));
+           dim = NodeFactory.makeDimDecl(span, id, Option.wrap(a2));
            ty = new VarType(a1.getSpan(), id);
        }
@@ -65 +65 @@
            ids.add(NodeFactory.bogusId(span));
        }
-       UnitDecl unit = new UnitDecl(span, si_unit, ids, Option.some(ty),
-                                    Option.wrap(a6));
+       UnitDecl unit = NodeFactory.makeUnitDecl(span, si_unit, ids, Option.some(ty),
+                                                Option.wrap(a6));
        yyValue = FortressUtil.mkList(dim, unit);
      }
@@ -86 +86 @@
            unitId = NodeFactory.bogusId(span);
        }
-       dim = new DimDecl(span, dimId, Option.wrap(a2), Option.wrap(unitId));
+       dim = NodeFactory.makeDimDecl(span, dimId, Option.wrap(a2), Option.wrap(unitId));
        yyValue = FortressUtil.mkList((DimUnitDecl)dim);
      }
@@ -103 +103 @@
        }
        for (Id a3Elt : a3s.list()) { ids.add(a3Elt); }
-       UnitDecl unit = new UnitDecl(span, si_unit,
-                                    ids, Option.wrap(a4), Option.wrap(a5));
+       UnitDecl unit = NodeFactory.makeUnitDecl(span, si_unit, ids,
+                                                Option.wrap(a4), Option.wrap(a5));
        yyValue = FortressUtil.mkList((DimUnitDecl)unit);
      };

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

@@ -142 +142 @@
 LValue VarMayType = a1:BindId a2:(w IsType)
      { if (a2 == null)
-           yyValue = FortressUtil.mkLValue(createSpan(yyStart,yyCount),a1);
+           yyValue = NodeFactory.makeLValue(createSpan(yyStart,yyCount),a1);
        else
-           yyValue = FortressUtil.mkLValue(createSpan(yyStart,yyCount),a1,a2);
+           yyValue = NodeFactory.makeLValue(createSpan(yyStart,yyCount),a1,a2);
      };
 

trunk/ProjectFortress/src/com/sun/fortress/parser_util/FortressUtil.java

@@ -490 +490 @@
         List<LValue> lvs = new ArrayList<LValue>();
         for (Id id : ids) {
-            lvs.add(new LValue(id.getSpan(), id, mods, ty, mutable));
+            lvs.add(NodeFactory.makeLValue(id.getSpan(), id, mods, ty, mutable));
         }
         return lvs;
@@ -518 +518 @@
         int ind = 0;
         for (Id id : ids) {
-            lvs.add(new LValue(id.getSpan(), id, mods, Option.<Type>some(tys.get(ind)),
-                               mutable));
+            lvs.add(NodeFactory.makeLValue(id.getSpan(), id, mods,
+                                           Option.<Type>some(tys.get(ind)),
+                                           mutable));
             ind += 1;
         }
@@ -599 +600 @@
         return new LocalVarDecl(span, false, emptyExprs(), lvs,
                                 Option.<Expr>none());
-    }
-
-    public static LValue mkLValue(Span span, Id id, Type ty) {
-        return new LValue(span, id, emptyModifiers(), Option.<Type>some(ty), false);
-    }
-    public static LValue mkLValue(Span span, Id id) {
-        return new LValue(span, id, emptyModifiers(), Option.<Type>none(), false);
-    }
-    public static LValue mkLValue(Id id, Type ty,
-                                  List<Modifier> mods) {
-        return new LValue(id.getSpan(), id, mods, Option.<Type>some(ty), getMutable(mods));
-    }
-    public static LValue mkLValue(Id id, Type ty) {
-        return mkLValue(id, ty, emptyModifiers());
     }
 

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

@@ -319 +319 @@
                           extendSyntaxEnvironment(old, generatedId);
                         */
-                        return new Param(that.getSpan(), generatedId, mods_result, type_result, defaultExpr_result);
+                        return NodeFactory.makeParam(that.getSpan(), mods_result,
+                                                     generatedId, type_result,
+                                                     defaultExpr_result,
+                                                     Option.<Type>none());
                     } else {
                         Debug.debug( Debug.Type.SYNTAX, 2, "Varargs param id hash code " + name_result.generateHashCode() );
@@ -326 +329 @@
                         Debug.debug( Debug.Type.SYNTAX, 2, "Generate new binding for " + old + " = " + generatedId );
                         extendSyntaxEnvironment(old, generatedId);
-                        return new Param(that.getSpan(), generatedId, mods_result, Option.<Type>none(), Option.<Expr>none(),
-                                         varargsType_result);
+                        return NodeFactory.makeParam(that.getSpan(), mods_result,
+                                                     generatedId, Option.<Type>none(), Option.<Expr>none(),
+                                                     varargsType_result);
                     }
                 }
@@ -399 +403 @@
                             Debug.debug( Debug.Type.SYNTAX, 2, "Generate new binding for " + old + " = " + generatedId );
                             extendSyntaxEnvironment(old, generatedId);
-                            return new LValue(that.getSpan(), generatedId, mods_result, type_result);
+                            return NodeFactory.makeLValue(that.getSpan(), generatedId, mods_result,
+                                                          type_result, that.isMutable());
                         }
                     });