Changeset 3210

Timestamp:

12/12/08 16:56:30 (12 months ago)

Author:

sukyoungryu

Message:

[ast refactoring] Removed optional fields of the rest of the nodes.

Location:

trunk/ProjectFortress

Files:

• astgen/Fortress.ast (modified) (13 diffs)
• build.xml (modified) (1 diff)
• src/com/sun/fortress/compiler/IndexBuilder.java (modified) (1 diff)
• src/com/sun/fortress/compiler/desugarer/FreeNameCollection.java (modified) (2 diffs)
• src/com/sun/fortress/compiler/desugarer/FreeNameCollector.java (modified) (2 diffs)
• src/com/sun/fortress/compiler/desugarer/ObjectExpressionVisitor.java (modified) (1 diff)
• src/com/sun/fortress/compiler/desugarer/PreDisambiguationDesugaringVisitor.java (modified) (1 diff)
• src/com/sun/fortress/compiler/disambiguator/ExprDisambiguator.java (modified) (1 diff)
• src/com/sun/fortress/compiler/disambiguator/TopLevelEnv.java (modified) (4 diffs)
• src/com/sun/fortress/compiler/disambiguator/TypeDisambiguator.java (modified) (6 diffs)
• src/com/sun/fortress/compiler/index/FieldSetterMethod.java (modified) (1 diff)
• src/com/sun/fortress/compiler/typechecker/FnDeclTypeEnv.java (modified) (2 diffs)
• src/com/sun/fortress/compiler/typechecker/SubtypeCheckerJUTest.java (modified) (1 diff)
• src/com/sun/fortress/compiler/typechecker/TraitTable.java (modified) (1 diff)
• src/com/sun/fortress/compiler/typechecker/TypeAnalyzer.java (modified) (1 diff)
• src/com/sun/fortress/compiler/typechecker/TypeAnalyzerJUTest.java (modified) (2 diffs)
• src/com/sun/fortress/compiler/typechecker/TypeCheckerTestCase.java (modified) (1 diff)
• src/com/sun/fortress/compiler/typechecker/TypeEnv.java (modified) (8 diffs)
• src/com/sun/fortress/interpreter/glue/NativeApp.java (modified) (1 diff)
• src/com/sun/fortress/interpreter/rewrite/DesugarerVisitor.java (modified) (3 diffs)
• src/com/sun/fortress/nodes_util/ExprFactory.java (modified) (1 diff)
• src/com/sun/fortress/nodes_util/NodeFactory.java (modified) (29 diffs)
• src/com/sun/fortress/nodes_util/NodeUtil.java (modified) (1 diff)
• src/com/sun/fortress/nodes_util/OprUtil.java (modified) (3 diffs)
• src/com/sun/fortress/parser/Function.rats (modified) (2 diffs)
• src/com/sun/fortress/parser/Identifier.rats (modified) (5 diffs)
• src/com/sun/fortress/parser/LocalDecl.rats (modified) (2 diffs)
• src/com/sun/fortress/parser/MayNewlineHeader.rats (modified) (21 diffs)
• src/com/sun/fortress/parser/Method.rats (modified) (2 diffs)
• src/com/sun/fortress/parser/MethodParam.rats (modified) (1 diff)
• src/com/sun/fortress/parser/NoNewlineHeader.rats (modified) (1 diff)
• src/com/sun/fortress/parser/Syntax.rats (modified) (1 diff)
• src/com/sun/fortress/parser_util/FortressUtil.java (modified) (1 diff)
• src/com/sun/fortress/syntax_abstractions/phases/EscapeRewriter.java (modified) (1 diff)
• src/com/sun/fortress/tests/unit_tests/ConstructorsJUTest.java (modified) (2 diffs)

trunk/ProjectFortress/astgen/Fortress.ast

@@ -415 +415 @@
                              Option<Type> idType) implements Lhs;
                 /**
-                 * left-hand side of variable declaration
+                 * left-hand side of top-level variable declaration,
+                 * local variable declaration, or field declaration
                  * e.g.) var x: ZZ32
                  * Name must be unqualified.
@@ -1153 +1154 @@
              * e.g.) throws FailCalled
              */
-            Effect(Option<List<BaseType>> throwsClause = Option.<List<BaseType>>none(),
-                   boolean ioEffect = false);
+            Effect(Option<List<BaseType>> throwsClause, boolean ioEffect);
             /**
              * static argument
@@ -1198 +1198 @@
              * static expression
              */
-            abstract StaticExpr(ignoreForEquals boolean parenthesized = false);
+            abstract StaticExpr(ignoreForEquals boolean parenthesized);
                 /**
                  * integer expression
@@ -1216 +1216 @@
                      * e.g.) m
                      */
-                    IntRef(Id name, int lexicalDepth=-2147483648);
+                    IntRef(Id name, int lexicalDepth);
                     /**
                      * integer expression with an operator
@@ -1255 +1255 @@
                      * e.g.) ninf
                      */
-                    BoolRef(Id name, int lexicalDepth=-2147483648);
+                    BoolRef(Id name, int lexicalDepth);
                     /**
                      * boolean constraint
@@ -1306 +1306 @@
              * e.g.) where { ninf AND NOT nan }
              */
-            WhereClause(List<WhereBinding> bindings
-                            = Collections.<WhereBinding>emptyList(),
-                        List<WhereConstraint> constraints
-                            = Collections.<WhereConstraint>emptyList());
+            WhereClause(List<WhereBinding> bindings,
+                        List<WhereConstraint> constraints);
             /**
              * hidden type variable binding declared in where clauses
@@ -1424 +1422 @@
              * e.g.) requires { n GE 0 } ensures { outcome GE 0 }
              */
-            Contract(Option<List<Expr>> requiresClause = Option.<List<Expr>>none(),
-                     Option<List<EnsuresClause>> ensuresClause =
-                         Option.<List<EnsuresClause>>none(),
-                     Option<List<Expr>> invariantsClause = Option.<List<Expr>>none());
+            Contract(Option<List<Expr>> requiresClause,
+                     Option<List<EnsuresClause>> ensuresClause,
+                     Option<List<Expr>> invariantsClause);
             /**
              * ensures clause used in contracts
@@ -1433 +1430 @@
              * e.g.) sorted(outcome) provided sorted(input)
              */
-            EnsuresClause(Expr post, Option<Expr> pre = Option.<Expr>none());
+            EnsuresClause(Expr post, Option<Expr> pre);
             /**
              * static parameter
@@ -1468 +1465 @@
                  *
                  */
-                APIName(List<Id> ids,
-                        ignoreForEquals String text = com.sun.fortress.useful.Useful.<Id>dottedList(in_ids).intern());
+                APIName(List<Id> ids, ignoreForEquals String text);
                 /**
                  * non-API name
@@ -1476 +1472 @@
                  *              | opr EncloserPair
                  */
-                abstract IdOrOpOrAnonymousName(Option<APIName> apiName
-                                                   = Option.<APIName>none());
+                abstract IdOrOpOrAnonymousName(Option<APIName> apiName);
                     /**
                      * identifier or operator name
@@ -1542 +1537 @@
              * because different ops can be chosen for different clauses.
              */
-            CaseClause(Expr matchClause, Block body,
-                       Option<FunctionalRef> op = Option.<FunctionalRef>none());
+            CaseClause(Expr matchClause, Block body, Option<FunctionalRef> op);
             /**
              * catch clause used in try expressions
@@ -1604 +1598 @@
              * e.g.) T[\ninf, nan\] where { ninf AND NOT nan }
              */
-            TraitTypeWhere(BaseType baseType,
-                           Option<WhereClause> whereClause
-                               = Option.<WhereClause>none());
+            TraitTypeWhere(BaseType baseType, Option<WhereClause> whereClause);
             /**
              * array dimensionality
@@ -1658 +1650 @@
              * nonterminal header
              */
-            NonterminalHeader(Modifiers mods = Modifiers.None,   /* Only Modifiers.Private is allowed */
+            NonterminalHeader(Modifiers mods, /* Only Modifiers.Private is allowed */
                               Id name,
                               List<NonterminalParameter> params,
-                              List<StaticParam> staticParams
-                                = Collections.<StaticParam>emptyList(),
+                              List<StaticParam> staticParams,
                               Option<Type> paramType,
-                              Option<WhereClause> whereClause
-                                = Option.<WhereClause>none());
+                              Option<WhereClause> whereClause);
 
             /**

trunk/ProjectFortress/build.xml

@@ -304 +304 @@
     <delete file="FortressLibrary.ast"/>
     <delete file="FortressLibrary.tfs"/>
+    <delete file="${basedir}/tests/printing/test_output.txt" />
     <delete file="testFile.txt"/>
     <delete file="${src}/com/sun/fortress/scala_src/nodes/FortressAst.scala" />

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

@@ -195 +195 @@
     public static ObjectTraitIndex buildObjectExprIndex(ObjectExpr obj) {
         Span fake_span = NodeFactory.makeSpan("FAKE_SPAN");
-        Id fake_object_name = new Id(fake_span, "FAKE_NAME");
+        Id fake_object_name = NodeFactory.makeId(fake_span, "FAKE_NAME");
         IndexBuilder builder = new IndexBuilder();
 

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

@@ -35 +35 @@
 import com.sun.fortress.nodes.VarType;
 import com.sun.fortress.nodes_util.NodeUtil;
+import com.sun.fortress.nodes_util.NodeFactory;
 import com.sun.fortress.useful.Debug;
 
@@ -131 +132 @@
                 newFreeVarRefs.add(var);
             } else if( NodeUtil.isBoolParam(spOp.unwrap()) ) {
-                this.add( new BoolRef(var.getSpan(), var.getVarId()) );
+                this.add( NodeFactory.makeBoolRef(var.getSpan(), var.getVarId()) );
             } else if( NodeUtil.isIntParam(spOp.unwrap()) ) {
-                this.add( new IntRef(var.getSpan(), var.getVarId()) );
+                this.add( NodeFactory.makeIntRef(var.getSpan(), var.getVarId()) );
             } else if( NodeUtil.isNatParam(spOp.unwrap()) ) {
-                this.add( new IntRef(var.getSpan(), var.getVarId()) );
+                this.add( NodeFactory.makeIntRef(var.getSpan(), var.getVarId()) );
             } else {
                 throw new DesugarerError( "Unexpected Static Param type " +

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

@@ -34 +34 @@
 import com.sun.fortress.nodes.*;
 import com.sun.fortress.nodes_util.Span;
+import com.sun.fortress.nodes_util.NodeFactory;
 import com.sun.fortress.useful.Debug;
 
@@ -242 +243 @@
                           enclosingObjectDecl :
                           enclosingTraitDecl).unwrap().getSpan();
-            Option<Type> type = objExprTypeEnv.type( new Id(s, "self") );
+            Option<Type> type = objExprTypeEnv.type( NodeFactory.makeId(s, "self") );
             freeNames.setEnclosingSelfType(type);
         }

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

@@ -833 +833 @@
 
         if( NodeUtil.isBoolParam(sParam) ) {
-            BoolRef boolRef = new BoolRef(span, (Id)sParam.getName());
+            BoolRef boolRef = NodeFactory.makeBoolRef(span, (Id)sParam.getName());
             return new BoolArg(span, boolRef);
         } else if( NodeUtil.isIntParam(sParam) ) {
-            IntRef intRef = new IntRef(span, (Id)sParam.getName());
+            IntRef intRef = NodeFactory.makeIntRef(span, (Id)sParam.getName());
             return new IntArg(span, intRef);
         } else if( NodeUtil.isNatParam(sParam) ) {
-            IntRef intRef = new IntRef(span, (Id)sParam.getName());
+            IntRef intRef = NodeFactory.makeIntRef(span, (Id)sParam.getName());
             return new IntArg(span, intRef);
         } else if( NodeUtil.isTypeParam(sParam) ) {

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

@@ -49 +49 @@
 public class PreDisambiguationDesugaringVisitor extends NodeUpdateVisitor {
 
-    private final Id anyTypeId = new Id(NodeFactory.makeSpan("singleton"), WellKnownNames.anyTypeName);
+    private final Id anyTypeId = NodeFactory.makeId(NodeFactory.makeSpan("singleton"), WellKnownNames.anyTypeName);
 
     /** If the extends clause of a trait declaration, an object declaration, or

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

@@ -299 +299 @@
 
     private ExprDisambiguator extendWithSelf(Span span) {
-        Set<Id> selfSet = Collections.singleton(new Id(span, "self"));
+        Set<Id> selfSet = Collections.singleton(NodeFactory.makeId(span, "self"));
         return extendWithVars(selfSet);
     }
 
     private ExprDisambiguator extendWithOutcome(Span span) {
-        Set<Id> outcomeSet = Collections.singleton(new Id(span, "outcome"));
+        Set<Id> outcomeSet = Collections.singleton(NodeFactory.makeId(span, "outcome"));
         return extendWithVars(outcomeSet);
     }

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

@@ -165 +165 @@
         Id key = entry.getKey();
         if (table.containsKey(key)) {
-            table.get(key).add(new Id(key.getSpan(),
+            table.get(key).add(NodeFactory.makeId(key.getSpan(),
                                       Option.some(apiEntry.getKey()),
                                       key.getText()));
@@ -171 +171 @@
         } else {
             Set<Id> matches = new HashSet<Id>();
-            matches.add(new Id(key.getSpan(),
+            matches.add(NodeFactory.makeId(key.getSpan(),
                                Option.some(apiEntry.getKey()),
                                key.getText()));
@@ -236 +236 @@
                 if (fnName instanceof Id ) {
                     Id _fnName = (Id)fnName;
-                    Id name = new Id(_fnName.getSpan(),
+                    Id name = NodeFactory.makeId(_fnName.getSpan(),
                             Option.some(apiEntry.getKey()),
                             _fnName.getText());
@@ -545 +545 @@
 
     private Id ignoreApi(Id id) {
-        return new Id(id.getSpan(), id.getText());
+        return NodeFactory.makeId(id.getSpan(), id.getText());
     }
 

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

@@ -347 +347 @@
                     return p.getKind().accept(new NodeAbstractVisitor<StaticArg>() {
                             @Override public StaticArg forKindBool(KindBool k) {
-                                return new BoolArg(s, new BoolRef(s, name));
+                                return new BoolArg(s, NodeFactory.makeBoolRef(s, name));
                             }
                             @Override public StaticArg forKindDim(KindDim p) {
@@ -353 +353 @@
                             }
                             @Override public StaticArg forKindInt(KindInt p) {
-                                return new IntArg(s, new IntRef(s, name));
+                                return new IntArg(s, NodeFactory.makeIntRef(s, name));
                             }
                             @Override public StaticArg forKindNat(KindNat p) {
-                                return new IntArg(s, new IntRef(s, name));
+                                return new IntArg(s, NodeFactory.makeIntRef(s, name));
                                 // TODO: shouldn't there be a NatArg class?
                             }
@@ -363 +363 @@
                             }
                             @Override public StaticArg forKindUnit(KindUnit p) {
-                                return new UnitArg(s, new UnitRef(s, name));
+                                return new UnitArg(s, new UnitRef(s, false, name));
                             }
                             @Override public StaticArg forKindOp(KindOp p) {
@@ -559 +559 @@
                 NodeAbstractVisitor<StaticArg> v =new NodeAbstractVisitor<StaticArg>(){
                     @Override public StaticArg forKindBool(KindBool k) {
-                        return new BoolArg(arg.getSpan(), new BoolRef(arg.getSpan(), (Id)name));
+                        return new BoolArg(arg.getSpan(), NodeFactory.makeBoolRef(arg.getSpan(), (Id)name));
                     }
                     @Override
@@ -567 +567 @@
                     @Override
                     public StaticArg forKindInt(KindInt k) {
-                        return new IntArg(arg.getSpan(), new IntRef(arg.getSpan(), (Id)name));
+                        return new IntArg(arg.getSpan(), NodeFactory.makeIntRef(arg.getSpan(), (Id)name));
                     }
                     @Override
                     public StaticArg forKindNat(KindNat k) {
-                        return new IntArg(arg.getSpan(), new IntRef(arg.getSpan(), (Id)name));
+                        return new IntArg(arg.getSpan(), NodeFactory.makeIntRef(arg.getSpan(), (Id)name));
                     }
                     @Override
@@ -580 +580 @@
                     public StaticArg forKindUnit(KindUnit k) {
                         return new UnitArg(arg.getSpan(),
-                                           new UnitRef(arg.getSpan(), (Id)name));
+                                           new UnitRef(arg.getSpan(), false, (Id)name));
                     }
                     @Override

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

@@ -61 +61 @@
             Param p = NodeFactory.makeParam(_ast.getSpan(),
                                             Modifiers.None,
-                                            new Id(_ast.getSpan(), "fakeParamForImplicitSetter"),
+                                            NodeFactory.makeId(_ast.getSpan(), "fakeParamForImplicitSetter"),
                                             _ast.getIdType());
                 return Collections.singletonList(p);

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

@@ -67 +67 @@
                 Id _var = (Id)var;
                 if (_var.getApiName().isSome())
-                    return binding(new Id(_var.getSpan(), _var.getText()));
+                    return binding(NodeFactory.makeId(_var.getSpan(), _var.getText()));
             }
             return parent.binding(var);
@@ -102 +102 @@
                 Id _var = (Id)var;
                 if (_var.getApiName().isSome())
-                    return declarationSite(new Id(_var.getSpan(), _var.getText()));
+                    return declarationSite(NodeFactory.makeId(_var.getSpan(), _var.getText()));
             }
             return parent.declarationSite(var);

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

@@ -390 +390 @@
         for (String sup : supers) {
             BaseType supT = (BaseType) parseType(sup);
-            extendsClause.add(new TraitTypeWhere(span, supT, Option.<WhereClause>none()));
+            extendsClause.add(NodeFactory.makeTraitTypeWhere(span, supT, Option.<WhereClause>none()));
         }
         TraitDecl ast;

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

@@ -41 +41 @@
     public Option<TypeConsIndex> typeCons(Id name) {
         TypeConsIndex result;
-        Id simpleName = new Id(NodeFactory.makeSpan(name), name.getText());
+        Id simpleName = NodeFactory.makeId(NodeFactory.makeSpan(name), name.getText());
         // TODO: Shouldn't qualified names only point to APIs? -- Dan
         if (name.getApiName().isNone() ||

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

@@ -355 +355 @@
                     List<BaseType> reduced = reduceDisjuncts(normalThrows.unwrap(),
                                                              _emptyHistory);
-                    if (reduced.isEmpty()) { return new Effect(NodeFactory.makeSpan(e), e.isIoEffect()); }
+                    if (reduced.isEmpty()) { return NodeFactory.makeEffect(NodeFactory.makeSpan(e), e.isIoEffect()); }
                     else if (reduced.equals(e.getThrowsClause().unwrap())) {
                         return e;

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

@@ -463 +463 @@
         for (String sup : supers) {
             BaseType supT = (BaseType) parseType(sup);
-            extendsClause.add(new TraitTypeWhere(span, supT, Option.<WhereClause>none()));
+            extendsClause.add(NodeFactory.makeTraitTypeWhere(span, supT, Option.<WhereClause>none()));
         }
         TraitDecl ast;
@@ -607 +607 @@
 
     private static Effect parseEffect(String s) {
-        if (s.length() == 0) { return new Effect(span); }
+        if (s.length() == 0) { return NodeFactory.makeEffect(span); }
 
         boolean io = false;
         s = s.trim();
-        if (s.equals("io")) { return new Effect(span, true); }
+        if (s.equals("io")) { return NodeFactory.makeEffect(span, true); }
         else if (s.startsWith("io ")) { io = true; s = s.substring(3).trim(); }
         else if (s.endsWith(" io")) { io = true; s = s.substring(0, s.length()-3).trim(); }

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

@@ -106 +106 @@
         for (String sup : supers) {
             BaseType supT = (BaseType) parseType(sup);
-            extendsClause.add(new TraitTypeWhere(span, supT, Option.<WhereClause>none()));
+            extendsClause.add(NodeFactory.makeTraitTypeWhere(span, supT, Option.<WhereClause>none()));
         }
         TraitDecl ast = NodeFactory.makeTraitDecl(span, NodeFactory.makeId(name), sparams,

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

@@ -40 +40 @@
 import com.sun.fortress.compiler.index.Variable;
 import com.sun.fortress.nodes.AnonymousFnName;
+import com.sun.fortress.nodes.APIName;
 import com.sun.fortress.nodes.BoolArg;
 import com.sun.fortress.nodes.BoolRef;
@@ -190 +191 @@
             result.add(param.getKind().accept(new NodeAbstractVisitor<StaticArg>() {
                         public StaticArg forKindBool(KindBool k) {
-                            return new BoolArg(new Span(), new BoolRef(new Span(), (Id)name));
+                            return new BoolArg(new Span(), NodeFactory.makeBoolRef(new Span(), (Id)name));
                         }
                         public StaticArg forKindDim(KindDim k) {
@@ -196 +197 @@
                         }
                         public StaticArg forKindInt(KindInt k) {
-                            return new IntArg(new Span(), new IntRef(new Span(), (Id)name));
+                            return new IntArg(new Span(), NodeFactory.makeIntRef(new Span(), (Id)name));
                         }
                         public StaticArg forKindNat(KindNat k) {
-                            return new IntArg(new Span(), new IntRef(new Span(), (Id)name));
+                            return new IntArg(new Span(), NodeFactory.makeIntRef(new Span(), (Id)name));
                         }
                         public StaticArg forKindType(KindType k) {
@@ -206 +207 @@
                         }
                         public StaticArg forKindUnit(KindUnit k) {
-                            return new UnitArg(new Span(), new UnitRef(new Span(), (Id)name));
+                            return new UnitArg(new Span(), new UnitRef(new Span(), false, (Id)name));
                         }
                         public StaticArg forKindOp(KindOp that) {
@@ -221 +222 @@
 
     static Op removeApi(Op id) {
-        return new Op(id.getSpan(), id.getText(), id.getFixity(), id.isEnclosing());
+        return new Op(id.getSpan(), Option.<APIName>none(),
+                      id.getText(), id.getFixity(), id.isEnclosing());
     }
 
     static IdOrOpOrAnonymousName removeApi(IdOrOpOrAnonymousName id) {
         return id.accept(new NodeDepthFirstVisitor<IdOrOpOrAnonymousName>(){
-                @Override public IdOrOpOrAnonymousName forId(Id that) { return removeApi(that); }
-                @Override
-                public IdOrOpOrAnonymousName forOp(Op that) {
-                    return new Op(that.getSpan(), that.getText(), that.getFixity(), that.isEnclosing());
-                }
-                @Override
-                public IdOrOpOrAnonymousName forAnonymousFnName(AnonymousFnName that) {
-                    return new AnonymousFnName(that.getSpan());
-                }
-                @Override
-                public IdOrOpOrAnonymousName forConstructorFnName(ConstructorFnName that) {
-                    return new ConstructorFnName(that.getSpan(), that.getDef());
-                }
+                        @Override public IdOrOpOrAnonymousName forId(Id that) { return removeApi(that); }
+                        @Override
+                        public IdOrOpOrAnonymousName forOp(Op that) {
+                            return new Op(that.getSpan(), Option.<APIName>none(),
+                                          that.getText(), that.getFixity(), that.isEnclosing());
+                        }
+                        @Override
+                        public IdOrOpOrAnonymousName forAnonymousFnName(AnonymousFnName that) {
+                                return new AnonymousFnName(that.getSpan(),
+                                                           Option.<APIName>none());
+                        }
+                        @Override
+                        public IdOrOpOrAnonymousName forConstructorFnName(ConstructorFnName that) {
+                                return new ConstructorFnName(that.getSpan(),
+                                                             Option.<APIName>none(),
+                                                             that.getDef());
+                        }
         });
     }
@@ -451 +457 @@
             for (FnDecl decl : decls) {
                 overloads.add(genericArrowFromDecl(decl));
-                mods = mods.combine(decl.getMods());
             }
             this.mods = mods;
@@ -495 +500 @@
             if( mutable )
                 return true;
+
             return mods.isMutable();
         }
@@ -508 +514 @@
      * Replace all of the inference variables given with their corresponding types.
      */
-    public abstract TypeEnv replaceAllIVars(Map<_InferenceVarType, Type> ivars);
+        public abstract TypeEnv replaceAllIVars(Map<_InferenceVarType, Type> ivars);
 }

trunk/ProjectFortress/src/com/sun/fortress/interpreter/glue/NativeApp.java

@@ -114 +114 @@
 
     public <RetType> RetType accept(NodeVisitor<RetType> visitor) {
-        return visitor.forId(new Id(NodeFactory.makeSpan(""), ""));
+        return visitor.forId(NodeFactory.makeId(NodeFactory.makeSpan(""), ""));
     }
     public void accept(NodeVisitor_void visitor) {}

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

@@ -458 +458 @@
         if (i > 0) {
             return ExprFactory.makeFieldRef(s, dottedReference(s, i - 1),
-                                            new Id(s,WellKnownNames.secretParentName));
+                                            NodeFactory.makeId(s,WellKnownNames.secretParentName));
         } else {
             throw new Error("Confusion in member reference numbering.");
@@ -765 +765 @@
         Id id = lvb.getName();
         if ("_".equals(id.getText())) {
-            Id newId = new Id(id.getSpan(), WellKnownNames.tempForUnderscore(id));
+            Id newId = NodeFactory.makeId(id.getSpan(), WellKnownNames.tempForUnderscore(id));
             return NodeFactory.makeLValue(lvb, newId);
         }
@@ -917 +917 @@
             int element_index = 0;
             for (LValue lv : lhs) {
-                Id newName = new Id(at, "$" + element_index);
+                Id newName = NodeFactory.makeId(at, "$" + element_index);
                 Option<Type> type = lv.getIdType();
                 newdecls.add(new VarDecl(at, Useful.list(lv),

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

@@ -675 +675 @@
                                     Expr body) {
         return makeFnExpr(span, false, Option.<Type>none(),
-                          new AnonymousFnName(span),
+                          new AnonymousFnName(span, Option.<APIName>none()),
                           Collections.<StaticParam>emptyList(), params,
                           returnType, Option.<WhereClause>none(),

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

@@ -284 +284 @@
         return makeFnDecl(span, mods, name, staticParams, params, returnType,
                           throwsC, whereC, contract,
-                          new Id(span, "FN$"+span.toString()),
+                          makeId(span, "FN$"+span.toString()),
                           Option.<Expr>none(), Option.<Id>none());
     }
@@ -299 +299 @@
         return makeFnDecl(span, mods, name, staticParams, params, returnType,
                           throwsC, whereC, contract,
-                          new Id(span, "FN$"+span.toString()),
+                          makeId(span, "FN$"+span.toString()),
                           body, Option.<Id>none());
     }
@@ -491 +491 @@
     public static Param makeAbsParam(Type type) {
         return makeParam(type.getSpan(), Modifiers.None,
-                         new Id(type.getSpan(), "_"), type);
+                         makeId(type.getSpan(), "_"), type);
     }
 
@@ -792 +792 @@
     }
 
-    /***************************************************************************/
-
-
-    public static Id makeTemporaryId() {
-        return makeId("$$bogus_name$$");
-    }
-
-    public static Op makeTemporaryOp() {
-        return makeOp("$$bogus_name$$");
+    /** Create an "empty" effect at the given location. */
+    public static Effect makeEffect(SourceLoc loc) {
+        return makeEffect(new Span(loc, loc));
+    }
+
+    public static Effect makeEffect(Span span) {
+        return makeEffect(span, Option.<List<BaseType>>none(), false);
+    }
+
+    public static Effect makeEffect(List<BaseType> throwsClause) {
+        return makeEffect(FortressUtil.spanAll(throwsClause),
+                          Option.some(throwsClause), false);
+    }
+
+    public static Effect makeEffect(SourceLoc defaultLoc, List<BaseType> throwsClause) {
+        return makeEffect(FortressUtil.spanAll(defaultLoc, throwsClause),
+                          Option.some(throwsClause), false);
+    }
+
+    public static Effect makeEffect(Option<List<BaseType>> throwsClause) {
+        Span span = FortressUtil.spanAll(throwsClause.unwrap(Collections.<BaseType>emptyList()));
+        return makeEffect(span, throwsClause, false);
+    }
+
+    public static Effect makeEffect(SourceLoc defaultLoc, Option<List<BaseType>> throwsClause) {
+        Span span = FortressUtil.spanAll(defaultLoc,
+                throwsClause.unwrap(Collections.<BaseType>emptyList()));
+        return makeEffect(span, throwsClause, false);
+    }
+
+    public static Effect makeEffect(Span span, boolean ioEffect) {
+        return new Effect(span, Option.<List<BaseType>>none(), ioEffect);
+    }
+
+
+    public static Effect makeEffect(Span span, Option<List<BaseType>> throwsC,
+                                    boolean ioEffect) {
+        return new Effect(span, throwsC, ioEffect);
+    }
+
+    public static TraitTypeWhere makeTraitTypeWhere(BaseType in_type) {
+        Span sp = in_type.getSpan();
+        return makeTraitTypeWhere(sp, in_type,
+                                  Option.<WhereClause>none());
+    }
+
+    public static TraitTypeWhere makeTraitTypeWhere(BaseType in_type, Option<WhereClause> in_where) {
+        if ( in_where.isSome() )
+            return makeTraitTypeWhere(new Span(in_type.getSpan(), in_where.unwrap().getSpan()), in_type, in_where);
+        else
+            return makeTraitTypeWhere(in_type.getSpan(), in_type, in_where);
+    }
+
+    public static TraitTypeWhere makeTraitTypeWhere(Span span, BaseType type,
+                                                    Option<WhereClause> where) {
+        return new TraitTypeWhere(span, type, where);
+    }
+
+    public static ConstructorFnName makeConstructorFnName(GenericWithParams def) {
+        return new ConstructorFnName(def.getSpan(), Option.<APIName>none(), def);
+    }
+
+    public static Id makeId(Span span, String name) {
+        return makeId(span, Option.<APIName>none(), name);
+    }
+
+    public static Id makeId(Span span, Option<APIName> apiName, String text) {
+        return new Id(span, apiName, text);
+    }
+
+
+    public static Id bogusId(Span span) {
+        return makeId(span, Option.<APIName>none(), "_");
+    }
+
+    public static Id makeId(Id id, String newName) {
+        return makeId(id.getSpan(), id.getApiName(), newName);
+    }
+
+    public static Id makeId(Span span, Id id) {
+        return makeId(span, id.getApiName(), id.getText());
+    }
+
+    public static Id makeId(Iterable<Id> apiIds, Id id) {
+        Span span;
+        Option<APIName> api;
+        if (IterUtil.isEmpty(apiIds)) {
+            span = id.getSpan();
+            api = Option.none();
+        }
+        else {
+            APIName n = makeAPIName(apiIds);
+            span = FortressUtil.spanTwo(n, id);
+            api = Option.some(n);
+        }
+        return makeId(span, api, id.getText());
+    }
+
+    public static Id makeId(Span span, String api, String name) {
+        List<Id> apis = new ArrayList<Id>();
+        apis.add(makeId(span, api));
+        apis = Useful.immutableTrimmedList(apis);
+        return makeId(span, Option.some(makeAPIName(span, apis)), name);
+    }
+
+    public static Id makeId(Span span, Iterable<Id> apiIds, Id id) {
+        Option<APIName> api;
+        if (IterUtil.isEmpty(apiIds)) { api = Option.none(); }
+        else { api = Option.some(makeAPIName(apiIds)); }
+        return makeId(span, api, id.getText());
+    }
+
+    public static Id makeId(Span span, Id id, Iterable<Id> ids) {
+        Option<APIName> api;
+        Id last;
+        if (IterUtil.isEmpty(ids)) { api = Option.none(); last = id; }
+        else { api = Option.some(makeAPIName(id, IterUtil.skipLast(ids)));
+        last = IterUtil.last(ids);
+        }
+        return makeId(span, api, last.getText());
+    }
+
+    public static Id makeId(Span span, APIName api, Id id) {
+        return makeId(span, Option.some(api), id.getText());
+    }
+
+    /** Assumes {@code ids} is nonempty. */
+    public static Id makeId(Iterable<Id> ids) {
+        return makeId(IterUtil.skipLast(ids), IterUtil.last(ids));
+    }
+
+    public static Id makeId(String nameFirst, String... nameRest) {
+        Iterable<Id> ids = IterUtil.compose(makeId(nameFirst),
+                IterUtil.map(IterUtil.asIterable(nameRest), STRING_TO_ID));
+        return makeId(ids);
+    }
+
+    public static Id makeId(APIName api, Id name) {
+        return makeId(FortressUtil.spanTwo(api, name), Option.some(api),
+                name.getText());
+    }
+
+    public static Id makeId(APIName api, Id name, Span span) {
+        return makeId(span, Option.some(api), name.getText());
+    }
+
+    public static Id makeId(Option<APIName> api, Id name) {
+        return makeId(name.getSpan(), api, name.getText());
+    }
+
+    public static Id makeId(Span span, APIName api, String name) {
+        return makeId(span, Option.some(api), name);
+    }
+
+    public static Id makeId(String string) {
+        return makeId(new Span(), string);
     }
 
@@ -813 +960 @@
         }
         ids = Useful.immutableTrimmedList(ids);
-        return new APIName(FortressUtil.spanTwo(first, last), ids);
+        return makeAPIName(FortressUtil.spanTwo(first, last), ids);
     }
 
@@ -822 +969 @@
             ids.addAll(rest.getApiName().unwrap().getIds());
         }
-        ids.add(new Id(rest.getSpan(), rest.getText()));
+        ids.add(makeId(rest.getSpan(), rest.getText()));
         ids = Useful.immutableTrimmedList(ids);
-        return new APIName(FortressUtil.spanTwo(first, rest), ids);
+        return makeAPIName(FortressUtil.spanTwo(first, rest), ids);
+    }
+
+    public static APIName makeAPIName(Span span, List<Id> apis) {
+        return makeAPIName(span, apis, Useful.<Id>dottedList(apis).intern());
+    }
+
+    public static APIName makeAPIName(Span span, String s) {
+        return makeAPIName(span, Useful.list(makeId(span, s)));
+    }
+
+    public static APIName makeAPIName(Span span, Id s) {
+        return makeAPIName(span, Useful.list(s));
+    }
+
+    public static APIName makeAPIName(Id s) {
+        return makeAPIName(s.getSpan(), Useful.list(s));
+    }
+
+    public static APIName makeAPIName(Span span, List<Id> apis, String text) {
+        return new APIName(span, apis, text);
+    }
+
+    public static APIName makeAPIName(String s) {
+        return makeAPIName(stringToIds(s));
+    }
+
+    public static APIName makeAPIName(Iterable<Id> ids) {
+        return makeAPIName(FortressUtil.spanAll(ids), CollectUtil.makeList(ids));
+    }
+
+    public static APIName makeAPIName(Id id, Iterable<Id> ids) {
+        return makeAPIName(CollectUtil.makeList(IterUtil.compose(id, ids)));
+    }
+
+    public static APIName makeAPIName(Span span, Iterable<Id> ids) {
+        return makeAPIName(span, CollectUtil.makeList(ids));
+    }
+
+    public static BoolRef makeBoolRef(String string) {
+        return makeBoolRef(new Span(), false, makeId(string), lexicalDepth);
+    }
+
+    public static BoolRef makeBoolRef(BoolRef old, int depth) {
+        return makeBoolRef(old.getSpan(), old.isParenthesized(), old.getName(), depth);
+    }
+
+    public static BoolRef makeBoolRef(Span span, Id name) {
+        return makeBoolRef(span, false, name, lexicalDepth);
+    }
+
+    public static BoolRef makeBoolRef(Span span, boolean parenthesized,
+                                      Id name, int depth) {
+        return new BoolRef(span, parenthesized, name, depth);
+    }
+
+    public static BoolBinaryOp makeBoolBinaryOp(Span span,
+                                                BoolExpr left, BoolExpr right, Op op) {
+        return makeBoolBinaryOp(span, false, left, right, op);
+    }
+
+    public static BoolBinaryOp makeBoolBinaryOp(Span span, boolean parenthesized,
+                                                BoolExpr left, BoolExpr right, Op op) {
+        return new BoolBinaryOp(span, parenthesized, left, right, op);
+    }
+
+    public static IntBinaryOp makeIntBinaryOp(Span span,
+                                              IntExpr left, IntExpr right, Op op) {
+        return makeIntBinaryOp(span, false, left, right, op);
+    }
+
+    public static IntBinaryOp makeIntBinaryOp(Span span, boolean parenthesized,
+                                              IntExpr left, IntExpr right, Op op) {
+        return new IntBinaryOp(span, parenthesized, left, right, op);
+    }
+
+    public static IntRef makeIntRef(String string) {
+        return makeIntRef(new Span(), makeId(string));
+    }
+
+    public static IntRef makeIntRef(IntRef old, int depth) {
+        return makeIntRef(old.getSpan(), old.isParenthesized(), old.getName(), depth);
+    }
+
+    public static IntRef makeIntRef(Span span, Id name) {
+        return new IntRef(span, false, name, lexicalDepth);
+    }
+
+    public static IntRef makeIntRef(Span span, boolean parenthesized,
+                                    Id name, int depth) {
+        return new IntRef(span, parenthesized, name, depth);
+    }
+
+    /***************************************************************************/
+
+
+    public static Id makeTemporaryId() {
+        return makeId("$$bogus_name$$");
+    }
+
+    public static Op makeTemporaryOp() {
+        return makeOp("$$bogus_name$$");
     }
 
     public static Id makeIdFromLast(Id id) {
-        return new Id(id.getSpan(), id.getText());
-    }
-
-    public static TraitTypeWhere makeTraitTypeWhere(BaseType in_type) {
-        Span sp = in_type.getSpan();
-        return new TraitTypeWhere(sp, in_type,
-                                  Option.<WhereClause>none());
-    }
-
-    public static TraitTypeWhere makeTraitTypeWhere(BaseType in_type, Option<WhereClause> in_where) {
-        if ( in_where.isSome() )
-            return new TraitTypeWhere(new Span(in_type.getSpan(), in_where.unwrap().getSpan()), in_type, in_where);
-        else
-            return new TraitTypeWhere(in_type.getSpan(), in_type, in_where);
+        return makeId(id.getSpan(), id.getText());
     }
 
@@ -865 +1100 @@
 
     public static UnitRef makeUnitRef(Span span, String name) {
-        return new UnitRef(span, makeId(name));
+        return new UnitRef(span, false, makeId(name));
     }
 
@@ -883 +1118 @@
     }
 
-    /** Create an "empty" effect at the given location. */
-    public static Effect makeEffect(SourceLoc loc) {
-        return new Effect(new Span(loc, loc));
-    }
-
-    public static Effect makeEffect(List<BaseType> throwsClause) {
-        return new Effect(FortressUtil.spanAll(throwsClause), Option.some(throwsClause));
-    }
-
-    public static Effect makeEffect(SourceLoc defaultLoc, List<BaseType> throwsClause) {
-        return new Effect(FortressUtil.spanAll(defaultLoc, throwsClause),
-                Option.some(throwsClause));
-    }
-
-    public static Effect makeEffect(Option<List<BaseType>> throwsClause) {
-        Span span = FortressUtil.spanAll(throwsClause.unwrap(Collections.<BaseType>emptyList()));
-        return new Effect(span, throwsClause);
-    }
-
-    public static Effect makeEffect(SourceLoc defaultLoc, Option<List<BaseType>> throwsClause) {
-        Span span = FortressUtil.spanAll(defaultLoc,
-                throwsClause.unwrap(Collections.<BaseType>emptyList()));
-        return new Effect(span, throwsClause);
-    }
-
     public static KeywordType makeKeywordType(Id name, Type type) {
         return new KeywordType(new Span(), name, type);
-    }
-
-    public static ConstructorFnName makeConstructorFnName(GenericWithParams def) {
-        return new ConstructorFnName(def.getSpan(), def);
-    }
-
-    public static APIName makeAPIName(Span span, String s) {
-        return new APIName(span, Useful.list(new Id(span, s)));
-    }
-
-    public static APIName makeAPIName(Span span, Id s) {
-        return new APIName(span, Useful.list(s));
-    }
-
-    public static APIName makeAPIName(Id s) {
-        return new APIName(s.getSpan(), Useful.list(s));
     }
 
@@ -940 +1134 @@
     }
 
-    public static APIName makeAPIName(String s) {
-        return makeAPIName(stringToIds(s));
-    }
-
-    public static APIName makeAPIName(Iterable<Id> ids) {
-        return new APIName(FortressUtil.spanAll(ids), CollectUtil.makeList(ids));
-    }
-
-    public static APIName makeAPIName(Id id, Iterable<Id> ids) {
-        return makeAPIName(CollectUtil.makeList(IterUtil.compose(id, ids)));
-    }
-
-    public static APIName makeAPIName(Span span, Iterable<Id> ids) {
-        return new APIName(span, CollectUtil.makeList(ids));
-    }
-
     /**
      * Create a APIName from the name of the file with the given path.
@@ -975 +1153 @@
         String file = new File(path).getName();
         if (file.length() <= 4) {
-            return error(new Id(span, "_"), "Invalid file name.");
+            return error(makeId(span, "_"), "Invalid file name.");
         }
         for (String n : file.substring(0, file.length()-4).split(delimiter)) {
-            ids.add(new Id(span, n));
+            ids.add(makeId(span, n));
         }
         ids = Useful.immutableTrimmedList(ids);
-        return new APIName(span, ids);
-    }
-
-    public static Id bogusId(Span span) {
-        return new Id(span, Option.<APIName>none(), "_");
-    }
-
-    public static Id makeId(Id id, String newName) {
-        return new Id(id.getSpan(), id.getApiName(), newName);
-    }
-
-    public static Id makeId(Span span, String s) {
-        return new Id(span, Option.<APIName>none(), s);
-    }
-
-    public static Id makeId(Span span, Id id) {
-        return new Id(span, id.getApiName(), id.getText());
-    }
-
-    public static Id makeId(Iterable<Id> apiIds, Id id) {
-        Span span;
-        Option<APIName> api;
-        if (IterUtil.isEmpty(apiIds)) {
-            span = id.getSpan();
-            api = Option.none();
-        }
-        else {
-            APIName n = makeAPIName(apiIds);
-            span = FortressUtil.spanTwo(n, id);
-            api = Option.some(n);
-        }
-        return new Id(span, api, id.getText());
-    }
-
-    public static Id makeId(Span span, String api, String name) {
-        List<Id> apis = new ArrayList<Id>();
-        apis.add(makeId(span, api));
-        apis = Useful.immutableTrimmedList(apis);
-        return new Id(span, Option.some(new APIName(span, apis)), name);
-    }
-
-    public static Id makeId(Span span, Iterable<Id> apiIds, Id id) {
-        Option<APIName> api;
-        if (IterUtil.isEmpty(apiIds)) { api = Option.none(); }
-        else { api = Option.some(makeAPIName(apiIds)); }
-        return new Id(span, api, id.getText());
-    }
-
-    public static Id makeId(Span span, Id id, Iterable<Id> ids) {
-        Option<APIName> api;
-        Id last;
-        if (IterUtil.isEmpty(ids)) { api = Option.none(); last = id; }
-        else { api = Option.some(makeAPIName(id, IterUtil.skipLast(ids)));
-        last = IterUtil.last(ids);
-        }
-        return new Id(span, api, last.getText());
-    }
-
-    public static Id makeId(Span span, APIName api, Id id) {
-        return new Id(span, Option.some(api), id.getText());
-    }
-
-    /** Assumes {@code ids} is nonempty. */
-    public static Id makeId(Iterable<Id> ids) {
-        return makeId(IterUtil.skipLast(ids), IterUtil.last(ids));
-    }
-
-    public static Id makeId(String nameFirst, String... nameRest) {
-        Iterable<Id> ids = IterUtil.compose(makeId(nameFirst),
-                IterUtil.map(IterUtil.asIterable(nameRest), STRING_TO_ID));
-        return makeId(ids);
-    }
-
-    public static Id makeId(APIName api, Id name) {
-        return new Id(FortressUtil.spanTwo(api, name), Option.some(api),
-                name.getText());
-    }
-
-    public static Id makeId(APIName api, Id name, Span span) {
-        return new Id(span, Option.some(api), name.getText());
-    }
-
-    public static Id makeId(Option<APIName> api, Id name) {
-        return new Id(name.getSpan(), api, name.getText());
-    }
-
-    public static Id makeId(Span span, APIName api, String name) {
-        return new Id(span, Option.some(api), name);
-    }
-
-    public static Id makeId(String string) {
-        return new Id(new Span(), string);
+        return makeAPIName(span, ids);
     }
 
@@ -1080 +1167 @@
 
     public static Op makeEnclosing(Span in_span, String in_open, String in_close) {
-        return new Op(in_span, PrecedenceMap.ONLY.canon(in_open + " " + in_close),
+        return new Op(in_span, Option.<APIName>none(),
+                      PrecedenceMap.ONLY.canon(in_open + " " + in_close),
                       enclosing, true);
     }
@@ -1095 +1183 @@
 
     public static Op makeOp(String name) {
-        return new Op(new Span(), PrecedenceMap.ONLY.canon(name), unknownFix, false);
+        return new Op(new Span(),  Option.<APIName>none(),
+                      PrecedenceMap.ONLY.canon(name), unknownFix, false);
     }
 
     public static Op makeOp(Span span, String name) {
-        return new Op(span, PrecedenceMap.ONLY.canon(name), unknownFix, false);
+        return new Op(span, Option.<APIName>none(),
+                      PrecedenceMap.ONLY.canon(name), unknownFix, false);
     }
 
     public static Op makeOp(Span span, String name, Fixity fixity) {
-        return new Op(span, PrecedenceMap.ONLY.canon(name), fixity, false);
+        return new Op(span, Option.<APIName>none(),
+                      PrecedenceMap.ONLY.canon(name), fixity, false);
     }
 
     public static Op makeOp(Op op, String name) {
-        return new Op(op.getSpan(), PrecedenceMap.ONLY.canon(name),
+        return new Op(op.getSpan(), Option.<APIName>none(),
+                      PrecedenceMap.ONLY.canon(name),
                       op.getFixity(), op.isEnclosing());
     }
 
     public static Op makeOpInfix(Span span, String name) {
-        return new Op(span, PrecedenceMap.ONLY.canon(name), infix, false);
+        return new Op(span, Option.<APIName>none(),
+                      PrecedenceMap.ONLY.canon(name), infix, false);
     }
 
@@ -1127 +1220 @@
 
     public static Op makeOpPrefix(Span span, String name) {
-        return new Op(span, PrecedenceMap.ONLY.canon(name), prefix, false);
+        return new Op(span, Option.<APIName>none(),
+                      PrecedenceMap.ONLY.canon(name), prefix, false);
     }
 
@@ -1135 +1229 @@
 
     public static Op makeOpPostfix(Span span, String name) {
-        return new Op(span, PrecedenceMap.ONLY.canon(name), postfix, false);
+        return new Op(span, Option.<APIName>none(),
+                      PrecedenceMap.ONLY.canon(name), postfix, false);
     }
 
@@ -1152 +1247 @@
 
     public static Op makeOpNofix(Op op) {
-        return new Op(op.getSpan(), op.getText(), nofix, op.isEnclosing());
+        return new Op(op.getSpan(), Option.<APIName>none(),
+                      op.getText(), nofix, op.isEnclosing());
     }
 
     public static Op makeOpMultifix(Op op) {
-        return new Op(op.getSpan(), op.getText(), multifix, op.isEnclosing());
+        return new Op(op.getSpan(), Option.<APIName>none(),
+                      op.getText(), multifix, op.isEnclosing());
     }
 
     public static Op makeOpEnclosing(Span span, String name) {
-        return new Op(span, PrecedenceMap.ONLY.canon(name), enclosing, false);
+        return new Op(span, Option.<APIName>none(),
+                      PrecedenceMap.ONLY.canon(name), enclosing, false);
     }
 
     public static Op makeOpBig(Span span, String name) {
-        return new Op(span, PrecedenceMap.ONLY.canon(name), big, false);
+        return new Op(span, Option.<APIName>none(),
+                      PrecedenceMap.ONLY.canon(name), big, false);
     }
 
     public static Op makeOpUnknown(Span span, String name) {
-        return new Op(span, PrecedenceMap.ONLY.canon(name), unknownFix, false);
+        return new Op(span, Option.<APIName>none(),
+                      PrecedenceMap.ONLY.canon(name), unknownFix, false);
     }
 
@@ -1179 +1279 @@
             return makeEnclosing(op.getSpan(), left, right);
         } else
-            return new Op(op.getSpan(), PrecedenceMap.ONLY.canon("BIG " + op.getText()), big, op.isEnclosing() );
+            return new Op(op.getSpan(), Option.<APIName>none(),
+                          PrecedenceMap.ONLY.canon("BIG " + op.getText()), big, op.isEnclosing() );
     }
 
     public static StaticParam makeTypeParam(String name) {
         Span s = new Span();
-        return new StaticParam(s, new Id(s, name),
+        return new StaticParam(s, makeId(s, name),
                                Collections.<BaseType>emptyList(),
                                Option.<Type>none(), false,
@@ -1194 +1295 @@
         List<BaseType> supers = new ArrayList<BaseType>(1);
         supers.add(makeVarType(sup));
-        return new StaticParam(s, new Id(s, name), supers,
+        return new StaticParam(s, makeId(s, name), supers,
                                Option.<Type>none(), false,
                                new KindType());
@@ -1208 +1309 @@
     public static StaticParam makeBoolParam(String name) {
         Span s = new Span();
-        return new StaticParam(s, new Id(s, name),
+        return new StaticParam(s, makeId(s, name),
                                Collections.<BaseType>emptyList(),
                                Option.<Type>none(), false,
@@ -1216 +1317 @@
     public static StaticParam makeDimParam(String name) {
         Span s = new Span();
-        return new StaticParam(s, new Id(s, name),
+        return new StaticParam(s, makeId(s, name),
                                Collections.<BaseType>emptyList(),
                                Option.<Type>none(), false,
@@ -1224 +1325 @@
     public static StaticParam makeUnitParam(String name) {
         Span s = new Span();
-        return new StaticParam(s, new Id(s, name),
+        return new StaticParam(s, makeId(s, name),
                                Collections.<BaseType>emptyList(),
                                Option.<Type>none(), false,
@@ -1232 +1333 @@
     public static StaticParam makeIntParam(String name) {
         Span s = new Span();
-        return new StaticParam(s, new Id(s, name),
+        return new StaticParam(s, makeId(s, name),
                                Collections.<BaseType>emptyList(),
                                Option.<Type>none(), false,
@@ -1240 +1341 @@
     public static StaticParam makeNatParam(String name) {
         Span s = new Span();
-        return new StaticParam(s, new Id(s, name),
+        return new StaticParam(s, makeId(s, name),
                                Collections.<BaseType>emptyList(),
                                Option.<Type>none(), false,
@@ -1266 +1367 @@
     }
 
-    public static BoolRef makeBoolRef(String string) {
-        return new BoolRef(new Span(), makeId(string));
-    }
 
     public static BoolArg makeBoolArg(String string) {
@@ -1274 +1372 @@
     }
 
-    public static IntRef makeIntRef(String string) {
-        return new IntRef(new Span(), makeId(string));
-    }
-
     public static IntExpr makeIntVal(String i) {
         Span span = new Span();
-        return new IntBase(span, ExprFactory.makeIntLiteralExpr(span,
-                                                                new BigInteger(i)));
+        return new IntBase(span, false,
+                           ExprFactory.makeIntLiteralExpr(span,
+                                                          new BigInteger(i)));
     }
 
@@ -1319 +1414 @@
 
     public static VarDecl makeVarDecl(Span span, String name, Expr init) {
-        Id id = new Id(span, name);
+        Id id = makeId(span, name);
         FortressUtil.validId(id);
         LValue bind = new LValue(span, id,
@@ -1333 +1428 @@
             }
             public BoolExpr forBoolRef(BoolRef b) {
-                return new BoolRef(b.getSpan(), true, b.getName());
+                return makeBoolRef(b.getSpan(), true, b.getName(), b.getLexicalDepth());
             }
             public BoolExpr forBoolUnaryOp(BoolUnaryOp b) {
@@ -1339 +1434 @@
             }
             public BoolExpr forBoolBinaryOp(BoolBinaryOp b) {
-                return new BoolBinaryOp(b.getSpan(), true,
+                return makeBoolBinaryOp(b.getSpan(), true,
                                         b.getLeft(), b.getRight(), b.getOp());
             }
@@ -1381 +1476 @@
             }
             public IntExpr forIntRef(IntRef i) {
-                return new IntRef(i.getSpan(), true, i.getName());
+                return makeIntRef(i.getSpan(), true, i.getName(), i.getLexicalDepth());
             }
             public IntExpr forIntBinaryOp(IntBinaryOp i) {
-                return new IntBinaryOp(i.getSpan(), true, i.getLeft(),
+                return makeIntBinaryOp(i.getSpan(), true, i.getLeft(),
                                        i.getRight(), i.getOp());
             }
@@ -1467 +1562 @@
     public static Import makeImportStar(APIName api, List<IdOrOpOrAnonymousName> excepts) {
         return new ImportStar(makeSpan(api, excepts), Option.<String>none(), api, excepts);
-    }
-
-    public static BoolRef makeBoolRef(BoolRef old, int depth) {
-        return new BoolRef(old.getSpan(), old.isParenthesized(), old.getName(), depth);
-    }
-
-
-    public static IntRef makeIntRef(IntRef old, int depth) {
-        return new IntRef(old.getSpan(), old.isParenthesized(), old.getName(), depth);
     }
 

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

@@ -543 +543 @@
     public static final Fn<String, Id> StringToIdFn = new Fn<String, Id>() {
             public Id apply(String x) {
-                return new Id(new Span(), x);
+                return NodeFactory.makeId(new Span(), x);
             }
         };

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

@@ -18 +18 @@
 package com.sun.fortress.nodes_util;
 
+import com.sun.fortress.nodes.APIName;
 import com.sun.fortress.nodes.Fixity;
 import com.sun.fortress.nodes.Node;
@@ -139 +140 @@
     /** Return a new operator with the fixity prepended to the text. */
     public static Op decorateOperator(Op o) {
-        return new Op(o.getSpan(), fixityDecorator(o.getFixity(), o.getText()), o.getFixity(), o.isEnclosing());
+        return new Op(o.getSpan(), Option.<APIName>none(),
+                      fixityDecorator(o.getFixity(), o.getText()),
+                      o.getFixity(), o.isEnclosing());
     }
 
@@ -148 +151 @@
             return o;
         }
-        return new Op(o.getSpan(), o.getText().substring(i+1), o.getFixity(), o.isEnclosing());
+        return new Op(o.getSpan(), Option.<APIName>none(),
+                      o.getText().substring(i+1),
+                      o.getFixity(), o.isEnclosing());
     }
 

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

@@ -62 +62 @@
            TupleType _d = (TupleType)d;
            for (Type argT : _d.getElements()) {
-               Id name = new Id(argT.getSpan(), "_");
+               Id name = NodeFactory.makeId(argT.getSpan(), "_");
                params.add(NodeFactory.makeParam(argT.getSpan(), mods, name, argT));
            }
            if (_d.getVarargs().isSome()) {
                Type argT = _d.getVarargs().unwrap();
-               Id name = new Id(argT.getSpan(), "_");
+               Id name = NodeFactory.makeId(argT.getSpan(), "_");
                params.add(NodeFactory.makeVarargsParam(argT.getSpan(), mods, name, argT));
            }
@@ -74 +74 @@
 
        } else {
-           Id name = new Id(d.getSpan(), "_");
+           Id name = NodeFactory.makeId(d.getSpan(), "_");
            params.add(NodeFactory.makeParam(d.getSpan(), mods, name, d));
        }

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

@@ -53 +53 @@
 
 Id Id =
-     <FIRST> a1:IdText { yyValue = new Id(createSpan(yyStart,yyCount), a1); };
+     <FIRST> a1:IdText { yyValue = NodeFactory.makeId(createSpan(yyStart,yyCount), a1); };
 
 /* IdOrOpName ::= Id | OpName */
@@ -61 +61 @@
 Id BindId =
      Id
-   / a1:"_" { yyValue = new Id(createSpan(yyStart,yyCount), a1); };
+   / a1:"_" { yyValue = NodeFactory.makeId(createSpan(yyStart,yyCount), a1); };
 
 /* BindIdList ::= BindId (w , w BindId)* */
@@ -101 +101 @@
            yyValue = NodeFactory.makeAPIName(span, bogusId);
        } else if (FortressUtil.validId(a1))
-           yyValue = NodeFactory.makeAPIName(span, new Id(span, a1));
+           yyValue = NodeFactory.makeAPIName(span, NodeFactory.makeId(span, a1));
        else if (FortressUtil.validOp(a1)) {
            log(span, a1 + " is not a valid Fortress identifier.");
@@ -112 +112 @@
    / a1:idOrKeyword a2s:(dot idOrKeyword)* &(w ellipses)
      { Span span = createSpan(yyStart,yyCount);
-       List<Id> ids = CollectUtil.makeList(IterUtil.compose(new Id(span, a1),
+       List<Id> ids = CollectUtil.makeList(IterUtil.compose(NodeFactory.makeId(span, a1),
                                                        IterUtil.map(a2s.list(),
                                                                     NodeUtil.StringToIdFn)));
@@ -133 +133 @@
    / a1:idOrKeyword a2s:(dot idOrKeyword)*
      { Span span = createSpan(yyStart,yyCount);
-       List<Id> ids = CollectUtil.makeList(IterUtil.compose(new Id(span, a1),
+       List<Id> ids = CollectUtil.makeList(IterUtil.compose(NodeFactory.makeId(span, a1),
                                                        IterUtil.map(a2s.list(),
                                                                     NodeUtil.StringToIdFn)));

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

@@ -196 +196 @@
    / Unpasting
      { Span span = createSpan(yyStart,yyCount);
-       yyValue = NodeFactory.makeLValue(span, new Id(span, "_"));
+       yyValue = NodeFactory.makeLValue(span, NodeFactory.makeId(span, "_"));
      };
 
@@ -227 +227 @@
 /* CaseClause ::= NoNewlineExpr w => w BlockElems */
 CaseClause CaseClause = a1:NoNewlineExpr w match w a2:BlockElems
-     { yyValue = new CaseClause(createSpan(yyStart,yyCount), a1, a2); };
+     { yyValue = new CaseClause(createSpan(yyStart,yyCount), a1, a2,
+                                Option.<FunctionalRef>none());
+     };

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

@@ -122 +122 @@
 transient IntExpr IntVal =
      a1:IntLiteralExpr
-     { yyValue = new IntBase(createSpan(yyStart,yyCount), a1); }
+     { yyValue = new IntBase(createSpan(yyStart,yyCount), false, a1); }
    / a1:QualifiedName
-     { yyValue = new IntRef(createSpan(yyStart,yyCount), a1); };
+     { yyValue = NodeFactory.makeIntRef(createSpan(yyStart,yyCount), a1); };
 
 /* IntExpr ::=
@@ -156 +156 @@
            public IntExpr run(IntExpr base) {
                Op plus = NodeFactory.makeOpInfix(a1.getSpan(), "+");
-               return new IntBinaryOp(createSpan(yyStart,yyCount),
+               return NodeFactory.makeIntBinaryOp(createSpan(yyStart,yyCount),
                                       (IntExpr)base, a1, plus);
            }};
@@ -166 +166 @@
            public IntExpr run(IntExpr base) {
                Op minus = NodeFactory.makeOpInfix(a1.getSpan(), "-");
-               return new IntBinaryOp(createSpan(yyStart,yyCount),
+               return NodeFactory.makeIntBinaryOp(createSpan(yyStart,yyCount),
                                       (IntExpr)base, a1, minus);
            }};
@@ -176 +176 @@
            public IntExpr run(IntExpr base) {
                Op product = NodeFactory.makeOpInfix(a1.getSpan(), " ");
-               return new IntBinaryOp(createSpan(yyStart,yyCount),
+               return NodeFactory.makeIntBinaryOp(createSpan(yyStart,yyCount),
                                       (IntExpr)base, a1, product);
            }};
@@ -191 +191 @@
                        "An exponentiation should not be immediately followed " +
                        "by an exponentiation.");
-                   return new IntBinaryOp(span, (IntExpr)base, a1, exponent);
-               } return new IntBinaryOp(span, (IntExpr)base, a1, exponent);
+                   return NodeFactory.makeIntBinaryOp(span, (IntExpr)base, a1, exponent);
+               } return NodeFactory.makeIntBinaryOp(span, (IntExpr)base, a1, exponent);
            }};
      };
@@ -211 +211 @@
      { Span span = createSpan(yyStart,yyCount);
        Op not = NodeFactory.makeOpPrefix(span, "NOT");
-       yyValue = new BoolUnaryOp(span, a1, not);
+       yyValue = new BoolUnaryOp(span, false, a1, not);
      }
    / a1:BoolConstraintHead w OR w a2:BoolExpr
      { Span span = createSpan(yyStart,yyCount);
        Op op = NodeFactory.makeOpInfix(span, "OR");
-       yyValue = new BoolBinaryOp(span, a1, a2, op);
+       yyValue = NodeFactory.makeBoolBinaryOp(span, a1, a2, op);
      }
    / a1:BoolConstraintHead w AND w a2:BoolExpr
      { Span span = createSpan(yyStart,yyCount);
        Op op = NodeFactory.makeOpInfix(span, "AND");
-       yyValue = new BoolBinaryOp(span, a1, a2, op);
+       yyValue = NodeFactory.makeBoolBinaryOp(span, a1, a2, op);
      }
    / a1:BoolConstraintHead w IMPLIES w a2:BoolExpr
      { Span span = createSpan(yyStart,yyCount);
        Op op = NodeFactory.makeOpInfix(span, "IMPLIES");
-       yyValue = new BoolBinaryOp(span, a1, a2, op);
+       yyValue = NodeFactory.makeBoolBinaryOp(span, a1, a2, op);
      }
    / a1:BoolConstraintHead w equals w a2:BoolExpr
      { Span span = createSpan(yyStart,yyCount);
        Op op = NodeFactory.makeOpInfix(span, "=");
-       yyValue = new BoolBinaryOp(span, a1, a2, op);
+       yyValue = NodeFactory.makeBoolBinaryOp(span, a1, a2, op);
      };
 
@@ -252 +252 @@
                Span span = createSpan(yyStart,yyCount);
                Op op = NodeFactory.makeOpInfix(span, "OR");
-               return new BoolBinaryOp(span, (BoolConstraint)base, a1, op);
+               return NodeFactory.makeBoolBinaryOp(span, (BoolConstraint)base, a1, op);
            }};
      };
@@ -262 +262 @@
                Span span = createSpan(yyStart,yyCount);
                Op op = NodeFactory.makeOpInfix(span, "AND");
-               return new BoolBinaryOp(span, (BoolConstraint)base, a1, op);
+               return NodeFactory.makeBoolBinaryOp(span, (BoolConstraint)base, a1, op);
            }};
      };
@@ -272 +272 @@
                Span span = createSpan(yyStart,yyCount);
                Op op = NodeFactory.makeOpInfix(span, "IMPLIES");
-               return new BoolBinaryOp(span, (BoolConstraint)base, a1, op);
+               return NodeFactory.makeBoolBinaryOp(span, (BoolConstraint)base, a1, op);
            }};
      };
@@ -282 +282 @@
                Span span = createSpan(yyStart,yyCount);
                Op op = NodeFactory.makeOpInfix(span, "");
-               return new BoolBinaryOp(span, (BoolConstraint)base, a1, op);
+               return NodeFactory.makeBoolBinaryOp(span, (BoolConstraint)base, a1, op);
            }};
      };
@@ -293 +293 @@
 transient private BoolExpr BoolVal =
      a1:"true"
-     { yyValue = new BoolBase(createSpan(yyStart,yyCount), true); }
+     { yyValue = new BoolBase(createSpan(yyStart,yyCount), false, true); }
    / a1:"false"
-     { yyValue = new BoolBase(createSpan(yyStart,yyCount), false); }
+     { yyValue = new BoolBase(createSpan(yyStart,yyCount), false, false); }
    / a1:QualifiedName
-     { yyValue = new BoolRef(createSpan(yyStart,yyCount), a1); };
+     { yyValue = NodeFactory.makeBoolRef(createSpan(yyStart,yyCount), a1); };
 
 /* BoolExpr ::=
@@ -315 +315 @@
      { Span span = createSpan(yyStart,yyCount);
        Op not = NodeFactory.makeOpPrefix(span, "NOT");
-       yyValue = new BoolUnaryOp(span, a1, not);
+       yyValue = new BoolUnaryOp(span, false, a1, not);
      };
 
@@ -331 +331 @@
                Span span = createSpan(yyStart,yyCount);
                Op op = NodeFactory.makeOpInfix(span, "OR");
-               return new BoolBinaryOp(span, (BoolExpr)base, a1, op);
+               return NodeFactory.makeBoolBinaryOp(span, (BoolExpr)base, a1, op);
            }};
      };
@@ -341 +341 @@
                Span span = createSpan(yyStart,yyCount);
                Op op = NodeFactory.makeOpInfix(span, "AND");
-               return new BoolBinaryOp(span, (BoolExpr)base, a1, op);
+               return NodeFactory.makeBoolBinaryOp(span, (BoolExpr)base, a1, op);
            }};
      };
@@ -351 +351 @@
                Span span = createSpan(yyStart,yyCount);
                Op op = NodeFactory.makeOpInfix(span, "IMPLIES");
-               return new BoolBinaryOp(span, (BoolExpr)base, a1, op);
+               return NodeFactory.makeBoolBinaryOp(span, (BoolExpr)base, a1, op);
            }};
      };
@@ -361 +361 @@
                Span span = createSpan(yyStart,yyCount);
                Op op = NodeFactory.makeOpInfix(span, "=");
-               return new BoolBinaryOp(span, (BoolExpr)base, a1, op);
+               return NodeFactory.makeBoolBinaryOp(span, (BoolExpr)base, a1, op);
            }};
      };
@@ -382 +382 @@
      a1:"dimensionless"
      { Span span = createSpan(yyStart,yyCount);
-       yyValue = new UnitRef(span, NodeFactory.makeId(span, a1));
+       yyValue = new UnitRef(span, false, NodeFactory.makeId(span, a1));
      }
    / a1:QualifiedName
-     { yyValue = new UnitRef(createSpan(yyStart,yyCount), a1); }
+     { yyValue = new UnitRef(createSpan(yyStart,yyCount), false, a1); }
    / openparen w a1:UnitExpr w closeparen
      { yyValue = NodeFactory.makeInParentheses(a1); };
@@ -400 +400 @@
            public UnitExpr run(UnitExpr base) {
                Op product = NodeFactory.makeOpInfix(a1.getSpan(), " ");
-               return new UnitBinaryOp(createSpan(yyStart,yyCount),
+               return new UnitBinaryOp(createSpan(yyStart,yyCount), false,
                                        (UnitExpr)base, a1, product);
            }};
@@ -410 +410 @@
            public UnitExpr run(UnitExpr base) {
                Op quotient = NodeFactory.makeOpInfix(a1.getSpan(), "/");
-               return new UnitBinaryOp(createSpan(yyStart,yyCount),
+               return new UnitBinaryOp(createSpan(yyStart,yyCount), false,
                                        (UnitExpr)base, a1, quotient);
            }};
@@ -420 +420 @@
            public UnitExpr run(UnitExpr base) {
                Op exponent = NodeFactory.makeOpInfix(a1.getSpan(), "^");
-               return new UnitBinaryOp(createSpan(yyStart,yyCount),
+               return new UnitBinaryOp(createSpan(yyStart,yyCount), false,
                                        (UnitExpr)base, a1, exponent);
            }};
@@ -559 +559 @@
    / a1:"true"
      { Span span = createSpan(yyStart,yyCount);
-       yyValue = new BoolArg(span, new BoolBase(span, true));
+       yyValue = new BoolArg(span, new BoolBase(span, false, true));
      }
    / a1:"false"
      { Span span = createSpan(yyStart,yyCount);
-       yyValue = new BoolArg(span, new BoolBase(span, false));
+       yyValue = new BoolArg(span, new BoolBase(span, false, false));
      }
    / !(QualifiedName (w DOT / w slash / w per / w DimPostfixOp) / "dimensionless")

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

@@ -143 +143 @@
        Span span = createSpan(yyStart+9,8);
        yyValue = FortressUtil.mkFnDecl(createSpan(yyStart,yyCount), mods,
-                                       new Id(span,"coerce"),a1, params, a4, a6);
+                                       NodeFactory.makeId(span,"coerce"),a1, params, a4, a6);
      };
 
@@ -157 +157 @@
        Span span = createSpan(yyStart+9,8);
        yyValue = FortressUtil.mkFnDecl(createSpan(yyStart,yyCount), mods,
-                                       new Id(span, "coerce"),
+                                       NodeFactory.makeId(span, "coerce"),
                                        a1, params, a4);
     };

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

@@ -51 +51 @@
      PlainParam
    / a1:self
-     { yyValue = NodeFactory.makeParam(new Id(createSpan(yyStart,yyCount),
+     { yyValue = NodeFactory.makeParam(NodeFactory.makeId(createSpan(yyStart,yyCount),
                                               "self")); };
 
 Param AbsParam :=
      a1:self
-     { yyValue = NodeFactory.makeParam(new Id(createSpan(yyStart,yyCount),
+     { yyValue = NodeFactory.makeParam(NodeFactory.makeId(createSpan(yyStart,yyCount),
                                               "self")); }
    / AbsPlainParam;

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

@@ -53 +53 @@
        else
            where = Option.some(a2);
-       yyValue = new TraitTypeWhere(createSpan(yyStart,yyCount),
-                                    a1, where);
+       yyValue = NodeFactory.makeTraitTypeWhere(createSpan(yyStart,yyCount),
+                                                a1, where);
      };
 

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

@@ -112 +112 @@
           else
               where = Option.some(whereClauses);
-          yyValue = new NonterminalHeader(createSpan(yyStart, yyCount), mod, name, params, staticParams, type1, where);
+          yyValue = new NonterminalHeader(createSpan(yyStart, yyCount), mod, name,
+                                          params, staticParams, type1, where);
         };
 

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

@@ -88 +88 @@
     }
 
-    private static Effect effect = new Effect(NodeFactory.makeSpan("singleton"));
+    private static Effect effect = NodeFactory.makeEffect(NodeFactory.makeSpan("singleton"));
 
     public static Effect emptyEffect() {

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

@@ -127 +127 @@
         String s = removeEscape(result_id.getText());
         // TODO is span correct below?
-        return new PrefixedSymbol(that.getSpan(), new Id(result_id.getSpan(), s), result_symbol);
+        return new PrefixedSymbol(that.getSpan(), NodeFactory.makeId(result_id.getSpan(), s), result_symbol);
     }
 

trunk/ProjectFortress/src/com/sun/fortress/tests/unit_tests/ConstructorsJUTest.java

@@ -77 +77 @@
 
     public void testId() {
-        Id id1 = new Id(newSpan("cat", 1, 2, 3), "TheIdString");
-        Id id2 = new Id(newSpan("cat", 1, 2, 3), "TheIdString");
-        Id id3 = new Id(newSpan("cat", 1, 2, 999), "TheIdString");
-        Id id4 = new Id(newSpan("cat", 1, 2, 3), "AnotherString");
+        Id id1 = NodeFactory.makeId(newSpan("cat", 1, 2, 3), "TheIdString");
+        Id id2 = NodeFactory.makeId(newSpan("cat", 1, 2, 3), "TheIdString");
+        Id id3 = NodeFactory.makeId(newSpan("cat", 1, 2, 999), "TheIdString");
+        Id id4 = NodeFactory.makeId(newSpan("cat", 1, 2, 3), "AnotherString");
         Assert.assertEquals(id1, id2);
         Assert.assertTrue(id1.equals(id3)); // We ignore Sourceloc for equality
@@ -88 +88 @@
 
     Id newId(String id, int l, int c1, int c2) {
-        return new Id(newSpan("somefile", l, c1, c2), id);
+        return NodeFactory.makeId(newSpan("somefile", l, c1, c2), id);
     }
     Id newId(String id) {
-        return new Id(newSpan("somefile", 1, 2, 3), id);
+        return NodeFactory.makeId(newSpan("somefile", 1, 2, 3), id);
     }
     public void testAPIName() {