Changeset 3200

Timestamp:

12/11/08 20:43:23 (12 months ago)

Author:

sukyoungryu

Message:

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

Location:

trunk/ProjectFortress

Files:

• astgen/Fortress.ast (modified) (2 diffs)
• src/com/sun/fortress/compiler/typechecker/TypeChecker.java (modified) (17 diffs)
• src/com/sun/fortress/interpreter/evaluator/Evaluator.java (modified) (2 diffs)
• src/com/sun/fortress/interpreter/evaluator/_WrappedFValue.java (modified) (1 diff)
• src/com/sun/fortress/interpreter/rewrite/DesugarerVisitor.java (modified) (5 diffs)
• src/com/sun/fortress/nodes_util/ExprFactory.java (modified) (15 diffs)
• src/com/sun/fortress/parser/DelimitedExpr.rats (modified) (3 diffs)
• src/com/sun/fortress/parser/Expression.rats (modified) (3 diffs)
• src/com/sun/fortress/parser/Literal.rats (modified) (2 diffs)
• src/com/sun/fortress/parser/LocalDecl.rats (modified) (2 diffs)
• src/com/sun/fortress/parser/NoNewlineExpr.rats (modified) (2 diffs)
• src/com/sun/fortress/parser/preparser/PreCompilation.rats (modified) (2 diffs)
• src/com/sun/fortress/parser_util/precedence_resolver/ASTUtil.java (modified) (1 diff)
• src/com/sun/fortress/syntax_abstractions/phases/ComposingSyntaxDefTranslator.java (modified) (1 diff)
• src/com/sun/fortress/syntax_abstractions/phases/EllipsesJUTest.java (modified) (9 diffs)
• src/com/sun/fortress/syntax_abstractions/phases/Transform.java (modified) (1 diff)
• src/com/sun/fortress/tests/unit_tests/ConstructorsJUTest.java (modified) (2 diffs)

trunk/ProjectFortress/astgen/Fortress.ast

@@ -443 +443 @@
              * expression
              */
-            root abstract Expr(ignoreForEquals boolean parenthesized = false,
-                               ignoreForEquals Option<Type> exprType = Option.<Type>none());
+            root abstract Expr(ignoreForEquals boolean parenthesized,
+                               ignoreForEquals Option<Type> exprType);
 
                 /**
@@ -888 +888 @@
                          * e.g.) x y
                          */
-                        _RewriteFnApp(Expr function, Expr argument) implements InAfterTypeChecking;
+                        _RewriteFnApp(Expr function, Expr argument)
+                                     implements InAfterTypeChecking;
                         /**
                          * expression using operators

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

@@ -928 +928 @@
                 }
 
-                _RewriteFnApp new_node = new _RewriteFnApp(that.getSpan(),
+                _RewriteFnApp new_node = ExprFactory.make_RewriteFnApp(that.getSpan(),
                                 that.isParenthesized(),
                                 result_type,
@@ -1633 +1633 @@
                                         errorMsg("A 'spawn' expression must not occur inside an 'atomic' expression."));
 
-                AtomicExpr new_node = new AtomicExpr(that.getSpan(),
+                AtomicExpr new_node = ExprFactory.makeAtomicExpr(that.getSpan(),
                                 that.isParenthesized(),
                                 expr_result.type(),
@@ -2005 +2005 @@
                 }
 
-                ChainExpr new_node = new ChainExpr(that.getSpan(),
+                ChainExpr new_node = ExprFactory.makeChainExpr(that.getSpan(),
                                 that.isParenthesized(),
                                 Option.<Type>some(Types.BOOLEAN),
@@ -2145 +2145 @@
 
                 Type result_type = subtypeChecker.join(frontTypes);
-                Do new_node = new Do(that.getSpan(),
+                Do new_node = ExprFactory.makeDo(that.getSpan(),
                                 that.isParenthesized(),
                                 some(result_type),
@@ -2279 +2279 @@
                 }
 
-                FieldRef new_node = new FieldRef(that.getSpan(),
+                FieldRef new_node = ExprFactory.makeFieldRef(that.getSpan(),
                                 that.isParenthesized(),
                                 result_type,
@@ -2608 +2608 @@
                 TypeCheckerResult body_void = this.checkSubtype(body_result.type().unwrap(), Types.VOID, that.getBody(), err);
 
-                For for_ = new For(that.getSpan(),
+                For for_ = ExprFactory.makeFor(that.getSpan(),
                                 that.isParenthesized(),
                                 Option.<Type>some(Types.VOID),
@@ -2926 +2926 @@
                 labelExitTypes.remove(that.getName());
 
-                Label new_node = new Label(that.getSpan(),
+                Label new_node = ExprFactory.makeLabel(that.getSpan(),
                                 that.isParenthesized(),
                                 labelType,
@@ -2953 +2953 @@
                                         body_results.get(body_results.size()-1).type();
 
-                                LetFn new_node = new LetFn(that.getSpan(),
+                                LetFn new_node = ExprFactory.makeLetFn(that.getSpan(),
                                                 that.isParenthesized(),
                                                 body_type,
@@ -3029 +3029 @@
                     }
                     Expr arg = that.getExprs().get(1);
-                    _RewriteFnApp fnApp = new _RewriteFnApp(new Span(front.getSpan(), arg.getSpan()),
-                                                            front, arg);
+                    _RewriteFnApp fnApp = ExprFactory.make_RewriteFnApp(front, arg);
 
                     // Simulate a TypeCheckerResult for the front, giving it a fresh arrow type.
@@ -3210 +3209 @@
                                 }
                                 // Otherwise, make a new MathPrimary that is one element shorter, and recur
-                                _RewriteFnApp fn = new _RewriteFnApp(new Span(front.getSpan(), arg.getSpan()),
-                                                front,
-                                                ((ExprMI)arg).getExpr());
+                                _RewriteFnApp fn = ExprFactory.make_RewriteFnApp(front,
+                                                                                 ((ExprMI)arg).getExpr());
                                 MathPrimary new_primary = ExprFactory.makeMathPrimary(that.getSpan(),
                                                                                       that.isParenthesized(),
@@ -3254 +3252 @@
                                                 item_iter.remove(); // remove fn from item list
                                                 // replace both with fn appication
-                                                _RewriteFnApp fn = new _RewriteFnApp(new Span(front.getSpan(),arg.getSpan()), front, ((ExprMI)arg).getExpr());
+                                                _RewriteFnApp fn = ExprFactory.make_RewriteFnApp(front, ((ExprMI)arg).getExpr());
                                                 item_iter.add(new NonParenthesisDelimitedMI(fn.getSpan(),fn));
                                                 // static error if the argument is immediately followed by a non-expression element.
@@ -3916 +3914 @@
 
                 Type expr_type = Types.makeThreadType(bodyResult.type().unwrap());
-                Spawn new_node = new Spawn(that.getSpan(),
+                Spawn new_node = ExprFactory.makeSpawn(that.getSpan(),
                                 that.isParenthesized(),
                                 Option.<Type>some(expr_type),
@@ -3928 +3926 @@
         @Override
         public TypeCheckerResult forStringLiteralExpr(StringLiteralExpr that) {
-                StringLiteralExpr new_node = new StringLiteralExpr(that.getSpan(),
+                StringLiteralExpr new_node = ExprFactory.makeStringLiteralExpr(that.getSpan(),
                                 that.isParenthesized(),
                                 Option.<Type>some(Types.STRING),
@@ -3994 +3992 @@
                                 "This expression is of type " + expr_result.type().unwrap());
 
-                Throw new_node = new Throw(that.getSpan(),
+                Throw new_node = ExprFactory.makeThrow(that.getSpan(),
                                 that.isParenthesized(),
                                 Option.<Type>some(Types.BOTTOM),
@@ -4115 +4113 @@
                                         errorMsg("A 'spawn' expression must not occur inside a 'try atomic' expression."));
 
-                TryAtomicExpr new_node = new TryAtomicExpr(that.getSpan(),
+                TryAtomicExpr new_node = ExprFactory.makeTryAtomicExpr(that.getSpan(),
                                 that.isParenthesized(),
                                 expr_result.type(),
@@ -4228 +4226 @@
                                 @Override
                                 public Node forAsExpr(AsExpr that) {
-                                        return new AsExpr(that.getSpan(), that.isParenthesized(), some(annotatedType),
-                                                        (Expr)expr_result.ast(), annotatedType);
+                                        return ExprFactory.makeAsExpr(that.getSpan(), that.isParenthesized(), some(annotatedType),
+                                                                      (Expr)expr_result.ast(), annotatedType);
                                 }
 
                                 @Override
                                 public Node forAsIfExpr(AsIfExpr that) {
-                                        return new AsIfExpr(that.getSpan(), that.isParenthesized(), some(annotatedType),
+                                        return ExprFactory.makeAsIfExpr(that.getSpan(), that.isParenthesized(), some(annotatedType),
                                                         (Expr)expr_result.ast(), annotatedType);
                                 }
@@ -4504 +4502 @@
                 TypeCheckerResult void_result = this.checkSubtype(body_result.type().unwrap(), Types.VOID, that.getBody(), void_err);
 
-                While new_node = new While(that.getSpan(),
+                While new_node = ExprFactory.makeWhile(that.getSpan(),
                                 that.isParenthesized(),
                                 Option.<Type>some(Types.VOID),

trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/Evaluator.java

@@ -364 +364 @@
             }
             if (f.isAtomicBlock())
-                return forAtomicExpr(new AtomicExpr(x.getSpan(), false,
-                                                    f));
+                return forAtomicExpr(ExprFactory.makeAtomicExpr(x.getSpan(), f));
             return f.accept(new Evaluator(this));
        }
@@ -377 +376 @@
            }
            if (f.isAtomicBlock())
-               tasks[i] = new TupleTask(new AtomicExpr(x.getSpan(), false,
-                                                       f), this);
+               tasks[i] = new TupleTask(ExprFactory.makeAtomicExpr(x.getSpan(), f), this);
            else
                tasks[i] = new TupleTask(f, new Evaluator(this));

trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/_WrappedFValue.java

@@ -39 +39 @@
      */
     public _WrappedFValue(Span in_span, boolean in_is_parenthesized, FValue in_fValue) {
-        super(in_span, in_is_parenthesized);
+        super();
         if (in_fValue == null) {
             throw new java.lang.IllegalArgumentException("Parameter 'fValue' to the _WrappedFValue constructor was null");

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

@@ -218 +218 @@
         @Override
         Expr replacement(VarRef original) {
-            return new FieldRef(original.getSpan(), false,
+            return ExprFactory.makeFieldRef(original.getSpan(),
                                 // Use this constructor
                                 // here because it is a
@@ -457 +457 @@
         }
         if (i > 0) {
-            return new FieldRef(s, false, dottedReference(s, i - 1),
-                                new Id(s,WellKnownNames.secretParentName));
+            return ExprFactory.makeFieldRef(s, dottedReference(s, i - 1),
+                                            new Id(s,WellKnownNames.secretParentName));
         } else {
             throw new Error("Confusion in member reference numbering.");
@@ -920 +920 @@
                 Option<Type> type = lv.getIdType();
                 newdecls.add(new VarDecl(at, Useful.list(lv),
-                                         Option.<Expr>some(new FieldRef(at, false, init, newName))));
+                                         Option.<Expr>some(ExprFactory.makeFieldRef(at, init, newName))));
                 element_index++;
             }
@@ -960 +960 @@
         objectExprs.add(rwoe);
 
-        return visitNode(new _RewriteObjectExprRef(rwoe.getSpan(), rwoe.isParenthesized(), rwoe.getExprType(), rwoe.getGenSymName(), rwoe.getStaticArgs()));
+        return visitNode(new _RewriteObjectExprRef(rwoe.getSpan(),
+                                                   rwoe.isParenthesized(),
+                                                   rwoe.getExprType(),
+                                                   rwoe.getGenSymName(),
+                                                   rwoe.getStaticArgs()));
    }
 
@@ -1099 +1103 @@
     public Node forFor(For f) {
         Block df = f.getBody();
-        Do doBlock = new Do(df.getSpan(),Useful.list(df));
+        Do doBlock = ExprFactory.makeDo(df.getSpan(),Useful.list(df));
         return visitLoop(f.getSpan(), f.getGens(), doBlock);
     }

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

@@ -977 +977 @@
     public static If makeIf(Span sp, IfClause _if) {
         List<IfClause> ifclauses = Collections.singletonList(_if);
-        return new If(sp, ifclauses, Option.<Block>none());
+        return makeIf(sp, ifclauses, Option.<Block>none());
     }
 
@@ -1026 +1026 @@
                             equalsOp, inOp, clauses, elseClause);
     }
+
+    public static ChainExpr makeChainExpr(Expr e, Op _op, Expr _expr) {
+        List<Link> links = new ArrayList<Link>(1);
+        Link link = new Link(NodeFactory.makeSpan(_op, _expr), makeOpRef(NodeFactory.makeOpInfix(_op)), _expr);
+        links.add(link);
+        return makeChainExpr(NodeFactory.makeSpan(e, _expr), e, links);
+    }
+
+    public static ChainExpr makeChainExpr(Span sp, Expr e, Op _op, Expr _expr) {
+        List<Link> links = new ArrayList<Link>(1);
+        Link link = new Link(NodeFactory.makeSpan(_op, _expr),
+                             makeOpRef(NodeFactory.makeOpInfix(_op)), _expr);
+        links.add(link);
+        return makeChainExpr(sp, e, links);
+    }
+
+    public static ChainExpr makeChainExpr(Span span,
+                                          Expr first, List<Link> links) {
+        return makeChainExpr(span, false, Option.<Type>none(), first, links);
+    }
+
+    public static ChainExpr makeChainExpr(Span span,
+                                          boolean parenthesized,
+                                          Option<Type> exprType,
+                                          Expr first, List<Link> links) {
+        return new ChainExpr(span, parenthesized, exprType, first, links);
+    }
+
+    public static _RewriteFnApp make_RewriteFnApp(Expr e_1, Expr e_2) {
+        return make_RewriteFnApp(FortressUtil.spanTwo(e_1, e_2), false,
+                                 Option.<Type>none(), e_1, e_2);
+    }
+
+    public static _RewriteFnApp make_RewriteFnApp(Span span,
+                                                  boolean parenthesized,
+                                                  Option<Type> exprType,
+                                                  Expr function,
+                                                  Expr argument) {
+        return new _RewriteFnApp(span, parenthesized, exprType, function,
+                                 argument);
+    }
+
+    public static FieldRef makeFieldRef(FieldRef expr, Span span) {
+        return makeFieldRef(span, expr.isParenthesized(),
+                            expr.getExprType(), expr.getObj(), expr.getField());
+    }
+
+    public static FieldRef makeFieldRef(FieldRef expr, Expr receiver, Id field) {
+        return makeFieldRef(expr.getSpan(), expr.isParenthesized(),
+                            expr.getExprType(), receiver, field);
+    }
+
+    public static FieldRef make_RewriteFieldRef(FieldRef expr,
+                                                Expr receiver, Id field) {
+        return makeFieldRef(expr.getSpan(), expr.isParenthesized(),
+                            expr.getExprType(), receiver, field);
+    }
+
+    public static FieldRef makeFieldRef(Span span, Expr receiver, Id field) {
+        return makeFieldRef(span, false, Option.<Type>none(), receiver, field);
+    }
+
+    public static FieldRef makeFieldRef(Expr receiver, Id field) {
+        return makeFieldRef(FortressUtil.spanTwo(receiver, field), receiver, field);
+    }
+
+    public static FieldRef makeFieldRef(Span span,
+                                        boolean parenthesized,
+                                        Option<Type> exprType,
+                                        Expr obj, Id field) {
+        return new FieldRef(span, parenthesized, exprType, obj, field);
+    }
+
+    public static AtomicExpr makeAtomicExpr(Span span, Expr expr) {
+        return makeAtomicExpr(span, false, Option.<Type>none(), expr);
+    }
+
+    public static AtomicExpr makeAtomicExpr(Span span,
+                                            boolean parenthesized,
+                                            Option<Type> exprType,
+                                            Expr expr) {
+        return new AtomicExpr(span, parenthesized, exprType, expr);
+    }
+
+    public static For makeFor(Span span,
+                              List<GeneratorClause> gens,
+                              Block body) {
+        return makeFor(span, false, Option.<Type>none(), gens, body);
+    }
+
+    public static For makeFor(Span span,
+                              boolean parenthesized,
+                              Option<Type> exprType,
+                              List<GeneratorClause> gens,
+                              Block body) {
+        return new For(span, parenthesized, exprType, gens, body);
+    }
+
+    public static Spawn makeSpawn(Span span,
+                                  Expr body) {
+        return makeSpawn(span, false, Option.<Type>none(), body);
+    }
+
+    public static Spawn makeSpawn(Span span,
+                                  boolean parenthesized,
+                                  Option<Type> exprType,
+                                  Expr body) {
+        return new Spawn(span, parenthesized, exprType, body);
+    }
+
+
+    public static TryAtomicExpr makeTryAtomicExpr(Span span,
+                                                  Expr expr) {
+        return makeTryAtomicExpr(span, false, Option.<Type>none(), expr);
+    }
+
+    public static TryAtomicExpr makeTryAtomicExpr(Span span,
+                                                  boolean parenthesized,
+                                                  Option<Type> exprType,
+                                                  Expr expr) {
+        return new TryAtomicExpr(span, parenthesized, exprType, expr);
+    }
+
+    public static LetFn makeLetFn(Span span,
+                                  List<Expr> body,
+                                  List<FnDecl> fns) {
+        return makeLetFn(span, false, Option.<Type>none(),
+                         body, fns);
+    }
+
+    public static LetFn makeLetFn(Span span,
+                                  boolean parenthesized,
+                                  Option<Type> exprType,
+                                  List<Expr> body,
+                                  List<FnDecl> fns) {
+        return new LetFn(span, parenthesized, exprType, body, fns);
+    }
+
+    public static Throw makeThrow(Span sp, String st) {
+        Id id = NodeFactory.makeId(sp, WellKnownNames.fortressLibrary, st);
+        return makeThrow(sp, makeVarRef(sp, id));
+    }
+
+    public static Throw makeThrow(Span span,
+                                  Expr expr) {
+        return makeThrow(span, false, Option.<Type>none(), expr);
+    }
+
+    public static Throw makeThrow(Span span,
+                                  boolean parenthesized,
+                                  Option<Type> exprType,
+                                  Expr expr) {
+        return new Throw(span, parenthesized, exprType, expr);
+    }
+
+    public static StringLiteralExpr makeStringLiteralExpr(Span span, String s) {
+        return makeStringLiteralExpr(span, false, Option.<Type>none(), s);
+    }
+
+    public static StringLiteralExpr makeStringLiteralExpr(Span span,
+                                                          boolean parenthesized,
+                                                          Option<Type> exprType,
+                                                          String text) {
+        return new StringLiteralExpr(span, parenthesized, exprType, text);
+    }
+
+    public static FloatLiteralExpr makeFloatLiteralExpr(Span span,
+                                                        boolean parenthesized,
+                                                        Option<Type> exprType,
+                                                        String text,
+                                                        BigInteger intPart,
+                                                        BigInteger numerator,
+                                                        int denomBase,
+                                                        int denomPower) {
+        return new FloatLiteralExpr(span, parenthesized, exprType, text,
+                                    intPart, numerator, denomBase, denomPower);
+    }
+
+    public static AsExpr makeAsExpr(Span span,
+                                    Expr expr, Type annType) {
+        return makeAsExpr(span, false, Option.<Type>none(), expr, annType);
+    }
+
+    public static AsExpr makeAsExpr(Span span,
+                                    boolean parenthesized,
+                                    Option<Type> exprType,
+                                    Expr expr, Type annType) {
+        return new AsExpr(span, parenthesized, exprType, expr, annType);
+    }
+
+    public static AsIfExpr makeAsIfExpr(Span span,
+                                        Expr expr, Type annType) {
+        return makeAsIfExpr(span, false, Option.<Type>none(), expr, annType);
+    }
+
+    public static AsIfExpr makeAsIfExpr(Span span,
+                                        boolean parenthesized,
+                                        Option<Type> exprType,
+                                        Expr expr, Type annType) {
+        return new AsIfExpr(span, parenthesized, exprType, expr, annType);
+    }
+
+    public static While makeWhile(Span sp, Expr cond) {
+        // Might not work; empty Do may be naughty.
+        return makeWhile(sp, makeGeneratorClause(cond.getSpan(), cond),
+                         makeDo(sp, Collections.<Block>emptyList()));
+    }
+
+    public static While makeWhile(Span span,
+                                  GeneratorClause testExpr,
+                                  Do body) {
+        return makeWhile(span, false, Option.<Type>none(),
+                         testExpr, body);
+    }
+
+    public static While makeWhile(Span span,
+                                  boolean parenthesized,
+                                  Option<Type> exprType,
+                                  GeneratorClause testExpr,
+                                  Do body) {
+        return new While(span, parenthesized, exprType, testExpr, body);
+    }
+
+    public static Label makeLabel(Span span,
+                                  Id name, Block body) {
+        return makeLabel(span, false, Option.<Type>none(), name, body);
+    }
+
+    public static Label makeLabel(Span span,
+                                  boolean parenthesized,
+                                  Option<Type> exprType,
+                                  Id name, Block body) {
+        return new Label(span, parenthesized, exprType, name, body);
+    }
+
+    public static Do makeDo(Span sp, Option<Type> t, Expr e) {
+        List<Expr> b = Collections.singletonList(e);
+        List<Block> body = new ArrayList<Block>(1);
+        body.add(makeBlock(sp, t, false, true, b));
+        return makeDo(sp, false, t, body);
+    }
+
+    public static Do makeDo(Span sp, Option<Type> t, List<Expr> exprs) {
+        List<Block> body = new ArrayList<Block>(1);
+        body.add(makeBlock(sp, t, false, true, exprs));
+        return makeDo(sp, false, t, body);
+    }
+
+    public static Do makeDo(Span span,
+                            List<Block> fronts) {
+        return makeDo(span, false, Option.<Type>none(), fronts);
+    }
+
+    public static Do makeDo(Span span,
+                            boolean parenthesized,
+                            Option<Type> exprType,
+                            List<Block> fronts) {
+        return new Do(span, parenthesized, exprType, fronts);
+    }
+
+
 
                                           /*
@@ -1127 +1388 @@
             }
         }
-        return new FloatLiteralExpr(span, false, s,
-                intPart, numerator, denomBase, denomPower);
+        return makeFloatLiteralExpr(span, false, Option.<Type>none(), s,
+                                    intPart, numerator, denomBase, denomPower);
     }
 
@@ -1134 +1395 @@
         return let_expr.accept(new NodeAbstractVisitor<LetExpr>() {
             public LetExpr forLetFn(LetFn expr) {
-                return new LetFn(expr.getSpan(),false, body, expr.getFns());
+                return ExprFactory.makeLetFn(expr.getSpan(), body, expr.getFns());
             }
             public LetExpr forLocalVarDecl(LocalVarDecl expr) {
@@ -1169 +1430 @@
     }
 
-    public static StringLiteralExpr makeStringLiteralExpr(Span span, String s) {
-        return new StringLiteralExpr(span, s);
-    }
-
-    public static FieldRef makeFieldRef(FieldRef expr, Span span) {
-        return new FieldRef(span, expr.isParenthesized(),
-                            expr.getExprType(), expr.getObj(), expr.getField());
-    }
-
-    public static FieldRef makeFieldRef(FieldRef expr, Expr receiver, Id field) {
-        return new FieldRef(expr.getSpan(), expr.isParenthesized(),
-                            expr.getExprType(), receiver, field);
-    }
-
-    public static FieldRef make_RewriteFieldRef(FieldRef expr,
-                                                Expr receiver, Id field) {
-        return new FieldRef(expr.getSpan(), expr.isParenthesized(),
-                            expr.getExprType(), receiver, field);
-    }
-
-    public static FieldRef makeFieldRef(Span span, Expr receiver, Id field) {
-        return new FieldRef(span, receiver, field);
-    }
-
-    public static FieldRef makeFieldRef(Expr receiver, Id field) {
-        return new FieldRef(FortressUtil.spanTwo(receiver, field), false,
-                            receiver, field);
-    }
-
     public static Expr makeReceiver(Iterable<Id> ids) {
         Expr expr = makeVarRef(IterUtil.first(ids));
@@ -1206 +1438 @@
     }
 
-    public static While makeWhile(Span sp, Expr cond) {
-        // Might not work; empty Do may be naughty.
-        return new While(sp, makeGeneratorClause(cond.getSpan(), cond),
-                new Do(sp, Collections.<Block>emptyList()));
-    }
-
-    public static Do makeDo(Span sp, Option<Type> t, Expr e) {
-        List<Expr> b = Collections.singletonList(e);
-        List<Block> body = new ArrayList<Block>(1);
-        body.add(makeBlock(sp, t, false, true, b));
-        return new Do(sp, t, body);
-    }
-
-    public static Do makeDo(Span sp, Option<Type> t, List<Expr> exprs) {
-        List<Block> body = new ArrayList<Block>(1);
-        body.add(makeBlock(sp, t, false, true, exprs));
-        return new Do(sp, t, body);
-    }
-
-    public static ChainExpr makeChainExpr(Expr e, Op _op, Expr _expr) {
-        List<Link> links = new ArrayList<Link>(1);
-        Link link = new Link(NodeFactory.makeSpan(_op, _expr), makeOpRef(NodeFactory.makeOpInfix(_op)), _expr);
-        links.add(link);
-        return new ChainExpr(NodeFactory.makeSpan(e, _expr), e, links);
-    }
-
-    public static ChainExpr makeChainExpr(Span sp, Expr e, Op _op, Expr _expr) {
-     List<Link> links = new ArrayList<Link>(1);
-        Link link = new Link(NodeFactory.makeSpan(_op, _expr), makeOpRef(NodeFactory.makeOpInfix(_op)), _expr);
-        links.add(link);
-        return new ChainExpr(sp, e, links);
-    }
-
-    /**
-     * Throws a standard (FortressLibrary) exception
-     * @param sp
-     * @param st
-     * @return
-     */
-    public static Throw makeThrow(Span sp, String st) {
-        Id id = NodeFactory.makeId(sp, WellKnownNames.fortressLibrary, st);
-        return new Throw(sp, makeVarRef(sp, id));
-    }
-
-    /**
-     * Uses the Spans from e_1 and e_2.
-     */
-    public static _RewriteFnApp make_RewriteFnApp(Expr e_1, Expr e_2) {
-        return new _RewriteFnApp(FortressUtil.spanTwo(e_1, e_2), e_1, e_2);
-    }
-
     public static Expr makeInParentheses(Expr expr) {
         return expr.accept(new NodeAbstractVisitor<Expr>() {
             @Override
             public Expr for_RewriteFnApp(_RewriteFnApp that) {
-                return new _RewriteFnApp(that.getSpan(),true,that.getFunction(),that.getArgument());
+                return make_RewriteFnApp(that.getSpan(), true, that.getExprType(),
+                                         that.getFunction(), that.getArgument());
             }
         public Expr forAsExpr(AsExpr e) {
-            return new AsExpr(e.getSpan(), true, e.getExpr(), e.getAnnType());
+            return makeAsExpr(e.getSpan(), true, e.getExprType(),
+                              e.getExpr(), e.getAnnType());
         }
         public Expr forAsIfExpr(AsIfExpr e) {
-            return new AsIfExpr(e.getSpan(), true, e.getExpr(), e.getAnnType());
+            return makeAsIfExpr(e.getSpan(), true, e.getExprType(),
+                                e.getExpr(), e.getAnnType());
         }
 
@@ -1285 +1469 @@
         }
         public Expr forDo(Do e) {
-            return new Do(e.getSpan(), true, e.getFronts());
+            return makeDo(e.getSpan(), true, e.getExprType(), e.getFronts());
         }
         public Expr forFor(For e) {
-            return new For(e.getSpan(), true, e.getGens(), e.getBody());
+            return makeFor(e.getSpan(), true, e.getExprType(), e.getGens(),
+                           e.getBody());
         }
         public Expr forIf(If e) {
-            return new If(e.getSpan(), true, e.getClauses(),
-                    e.getElseClause());
+            return makeIf(e.getSpan(), true, e.getExprType(),
+                          e.getClauses(), e.getElseClause());
         }
         public Expr forLabel(Label e) {
-            return new Label(e.getSpan(), true, e.getName(), e.getBody());
+            return makeLabel(e.getSpan(), true, e.getExprType(),
+                             e.getName(), e.getBody());
         }
         public Expr forMathPrimary(MathPrimary e) {
@@ -1308 +1494 @@
         public Expr for_RewriteObjectExpr(_RewriteObjectExpr e) {
             return new _RewriteObjectExpr(e.getSpan(), true,
+                                          e.getExprType(),
                     e.getExtendsClause(), e.getDecls(),
                     e.getImplicitTypeParameters(),
@@ -1330 +1517 @@
         }
         public Expr forWhile(While e) {
-            return new While(e.getSpan(), true, e.getTestExpr(), e.getBody());
+            return makeWhile(e.getSpan(), true, e.getExprType(),
+                             e.getTestExpr(), e.getBody());
         }
         public Expr forAccumulator(Accumulator e) {
@@ -1338 +1526 @@
         }
         public Expr forAtomicExpr(AtomicExpr e) {
-            return new AtomicExpr(e.getSpan(), true, e.getExpr());
+            return makeAtomicExpr(e.getSpan(), true, e.getExprType(), e.getExpr());
         }
         public Expr forExit(Exit e) {
@@ -1346 +1534 @@
 
         public Expr forSpawn(Spawn e) {
-            return new Spawn(e.getSpan(), true, e.getBody());
+            return makeSpawn(e.getSpan(), true, e.getExprType(), e.getBody());
         }
         public Expr forThrow(Throw e) {
-            return new Throw(e.getSpan(), true, e.getExpr());
+            return makeThrow(e.getSpan(), true, e.getExprType(), e.getExpr());
         }
         public Expr forTryAtomicExpr(TryAtomicExpr e) {
-            return new TryAtomicExpr(e.getSpan(), true, e.getExpr());
+            return makeTryAtomicExpr(e.getSpan(), true, e.getExprType(),
+                                     e.getExpr());
         }
         public Expr forFnExpr(FnExpr e) {
@@ -1361 +1550 @@
         }
         public Expr forLetFn(LetFn e) {
-            return new LetFn(e.getSpan(), true, e.getBody(), e.getFns());
+            return makeLetFn(e.getSpan(), true, e.getExprType(), e.getBody(), e.getFns());
         }
         public Expr forLocalVarDecl(LocalVarDecl e) {
@@ -1386 +1575 @@
         }
         public Expr forFloatLiteralExpr(FloatLiteralExpr e) {
-            return new FloatLiteralExpr(e.getSpan(), true, e.getText(),
+            return makeFloatLiteralExpr(e.getSpan(), true, e.getExprType(),
+                                        e.getText(),
                     e.getIntPart(), e.getNumerator(),
                     e.getDenomBase(), e.getDenomPower());
@@ -1399 +1589 @@
         }
         public Expr forStringLiteralExpr(StringLiteralExpr e) {
-            return new StringLiteralExpr(e.getSpan(), true, e.getText());
+            return makeStringLiteralExpr(e.getSpan(), true, e.getExprType(),
+                                         e.getText());
         }
         public Expr forVoidLiteralExpr(VoidLiteralExpr e) {
@@ -1414 +1605 @@
         }
         public Expr forChainExpr(ChainExpr e) {
-            return new ChainExpr(e.getSpan(), true, e.getFirst(),
-                    e.getLinks());
+            return makeChainExpr(e.getSpan(), true, e.getExprType(), e.getFirst(),
+                                 e.getLinks());
         }
         public Expr forFieldRef(FieldRef e) {
-            return new FieldRef(e.getSpan(), true, e.getObj(),
-                    e.getField());
+            return makeFieldRef(e.getSpan(), true, e.getExprType(),
+                                e.getObj(), e.getField());
         }
         public Expr forMethodInvocation(MethodInvocation e) {

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

@@ -66 +66 @@
                          a1 + "' at " + a1.getSpan() + " and\n'" +
                          a3 + "' at " + a3.getSpan());
-       yyValue = new Label(createSpan(yyStart,yyCount), false, a1, a2);
+       yyValue = ExprFactory.makeLabel(createSpan(yyStart,yyCount), a1, a2);
      }
    / <ErrorProduction>
@@ -82 +82 @@
      }
    / while w a1:GeneratorClause w a2:Do
-     { yyValue = new While(createSpan(yyStart,yyCount), false, a1, a2); }
+     { yyValue = ExprFactory.makeWhile(createSpan(yyStart,yyCount), a1, a2); }
    / for w a1:GeneratorClauseList w a2:DoFront w end
-     { yyValue = new For(createSpan(yyStart,yyCount), false, a1, a2); }
+     { yyValue = ExprFactory.makeFor(createSpan(yyStart,yyCount), a1, a2); }
    / if w a1:GeneratorClause w then w a2:BlockElems a3:(w Elifs)? a4:(w Else)? w end
      { IfClause ic = new IfClause(FortressUtil.spanTwo(a1,a2), a1, a2);
@@ -164 +164 @@
 /* Do ::= (DoFront w also w)* DoFront w end */
 Do Do = a1s:(DoFront w also w)* a2:DoFront w end
-     { yyValue = new Do(createSpan(yyStart, yyCount), false,
-                        FortressUtil.mkList(a1s.list(), a2));
+     { yyValue = ExprFactory.makeDo(createSpan(yyStart, yyCount),
+                                    FortressUtil.mkList(a1s.list(), a2));
      };
 

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

@@ -68 +68 @@
      { yyValue = new Action<Expr>() {
            public Expr run(Expr base) {
-               return new AsExpr(createSpan(yyStart,yyCount), false, (Expr)base,
-                                 a1);
+               return ExprFactory.makeAsExpr(createSpan(yyStart,yyCount), (Expr)base,
+                                             a1);
            }};
      };
@@ -77 +77 @@
      { yyValue = new Action<Expr>() {
            public Expr run(Expr base) {
-               return new AsIfExpr(createSpan(yyStart,yyCount), false,
-                                   (Expr)base, a1);
+               return ExprFactory.makeAsIfExpr(createSpan(yyStart,yyCount),
+                                               (Expr)base, a1);
            }};
      };
@@ -691 +691 @@
      }
    / atomic w a1:AtomicBack
-     { yyValue = new AtomicExpr(createSpan(yyStart,yyCount), false, a1); }
+     { yyValue = ExprFactory.makeAtomicExpr(createSpan(yyStart,yyCount), a1); }
    / tryatomic w a1:AtomicBack
-     { yyValue = new TryAtomicExpr(createSpan(yyStart,yyCount), false, a1); }
+     { yyValue = ExprFactory.makeTryAtomicExpr(createSpan(yyStart,yyCount), a1); }
    / spawn w a1:Expr
-     { yyValue = new Spawn(createSpan(yyStart,yyCount), false, a1); }
+     { yyValue = ExprFactory.makeSpawn(createSpan(yyStart,yyCount), a1); }
    / throw w a1:Expr
-     { yyValue = new Throw(createSpan(yyStart,yyCount), false, a1); };
+     { yyValue = ExprFactory.makeThrow(createSpan(yyStart,yyCount), a1); };
 
 /* AtomicBack ::=

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

@@ -175 +175 @@
            str = str.concat(c);
        }
-       yyValue = new StringLiteralExpr(createSpan(yyStart,yyCount), false, str);
+       yyValue = ExprFactory.makeStringLiteralExpr(createSpan(yyStart,yyCount), str);
      }
    / "\u201c" a1:StringLiteralContent* "\u201d"
@@ -182 +182 @@
            str = str.concat(c);
        }
-       yyValue = new StringLiteralExpr(createSpan(yyStart,yyCount), false, str);
+       yyValue = ExprFactory.makeStringLiteralExpr(createSpan(yyStart,yyCount), str);
      }
    / <ErrorProduction1> ["] a1:StringLiteralContent* "\u201d"
      { Span span = createSpan(yyStart,yyCount);
        log(span, "The opening and closing marks of a string literal must match.");
-       yyValue = new StringLiteralExpr(span, false, "");
+       yyValue = ExprFactory.makeStringLiteralExpr(span, "");
      }
    / <ErrorProduction2> "\u201c" a1:StringLiteralContent* ["]
      { Span span = createSpan(yyStart,yyCount);
        log(span, "The opening and closing marks of a string literal must match.");
-       yyValue = new StringLiteralExpr(span, false, "");
+       yyValue = ExprFactory.makeStringLiteralExpr(span, "");
      };
 private String StringLiteralContent =

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

@@ -65 +65 @@
    / a1:NoNewlineExpr a2:(s comma w NoNewlineGeneratorClauseList)?
      { if (a2 == null) yyValue = a1;
-       else yyValue = new For(createSpan(yyStart,yyCount), false,
-                              a2, ExprFactory.makeBlock(a1));
+       else yyValue = ExprFactory.makeFor(createSpan(yyStart,yyCount),
+                                          a2, ExprFactory.makeBlock(a1));
      };
 
@@ -76 +76 @@
      a1:LocalFnDecl a2s:(br LocalFnDecl)*
      { List<FnDecl> fns = FortressUtil.mkList(a1, a2s.list());
-       yyValue = new LetFn(createSpan(yyStart,yyCount), false,
+       yyValue = ExprFactory.makeLetFn(createSpan(yyStart,yyCount),
                            FortressUtil.emptyExprs(), fns);
      }

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

@@ -69 +69 @@
        yyValue = new Action<Expr>() {
            public Expr run(Expr base) {
-               return new AsExpr(createSpan(yyStart,yyCount), false, (Expr)base,
-                                 t);
+               return ExprFactory.makeAsExpr(createSpan(yyStart,yyCount), (Expr)base,
+                                             t);
            }};
      };
@@ -79 +79 @@
        yyValue = new Action<Expr>() {
            public Expr run(Expr base) {
-               return new AsIfExpr(createSpan(yyStart,yyCount), false,
-                                   (Expr)base, t);
+               return ExprFactory.makeAsIfExpr(createSpan(yyStart,yyCount),
+                                               (Expr)base, t);
            }};
      };

trunk/ProjectFortress/src/com/sun/fortress/parser/preparser/PreCompilation.rats

@@ -149 +149 @@
            str = str.concat(c);
        }
-       yyValue = new StringLiteralExpr(createSpan(yyStart,yyCount), false, str);
+       yyValue = ExprFactory.makeStringLiteralExpr(createSpan(yyStart,yyCount), str);
      }
    / "\u201c" a1:StringLiteralContent* "\u201d"
@@ -156 +156 @@
            str = str.concat(c);
        }
-       yyValue = new StringLiteralExpr(createSpan(yyStart,yyCount), false, str);
+       yyValue = ExprFactory.makeStringLiteralExpr(createSpan(yyStart,yyCount), str);
      }
    / <ErrorProduction1> ["] a1:StringLiteralContent* "\u201d"
      { Span span = createSpan(yyStart,yyCount);
        log(span, "The opening and closing marks of a string literal must match.");
-       yyValue = new StringLiteralExpr(span, false, "");
+       yyValue = ExprFactory.makeStringLiteralExpr(span, "");
      }
    / <ErrorProduction2> "\u201c" a1:StringLiteralContent* ["]
      { Span span = createSpan(yyStart,yyCount);
        log(span, "The opening and closing marks of a string literal must match.");
-       yyValue = new StringLiteralExpr(span, false, "");
+       yyValue = ExprFactory.makeStringLiteralExpr(span, "");
      };
 private String StringLiteralContent =

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

@@ -123 +123 @@
     //             chain_expr_links = links; }))
     static Expr chain(Span span, Expr first, List<Link> links) {
-        return new ChainExpr(span, false, first, links);
+        return ExprFactory.makeChainExpr(span, first, links);
     }
 

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

@@ -588 +588 @@
         indents.add(3);
         code.add("StringLiteralExpr " + prefixJavaVariable(name) +
-                 " = new StringLiteralExpr(NodeFactory.makeSpan(\"blame ComposingSyntaxDefTranslater\"), \"\"+" + prefixJavaVariable(id) + ");");
+                 " = ExprFactory.makeStringLiteralExpr(NodeFactory.makeSpan(\"blame ComposingSyntaxDefTranslater\"), \"\"+" + prefixJavaVariable(id) + ");");
         return name;
     }

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

@@ -57 +57 @@
             original = ExprFactory.makeTightJuxt(new Span(), exprs);
             EllipsesEnvironment env = new EllipsesEnvironment();
-            env.add( NodeFactory.makeId( "x" ), 1, mkList(new StringLiteralExpr(span,  "hello" )) );
+            env.add( NodeFactory.makeId( "x" ), 1, mkList(ExprFactory.makeStringLiteralExpr(span,  "hello" )) );
             actual = original.accept( new EllipsesVisitor( env ) );
         }
@@ -63 +63 @@
         {
             List<Expr> exprs = new ArrayList<Expr>();
-            exprs.add( new StringLiteralExpr(span,  "hello" ) );
+            exprs.add( ExprFactory.makeStringLiteralExpr(span,  "hello" ) );
             expected = ExprFactory.makeTightJuxt( new Span(), exprs );
         }
@@ -79 +79 @@
             original = ExprFactory.makeTightJuxt(new Span(), exprs);
             EllipsesEnvironment env = new EllipsesEnvironment();
-            env.add( NodeFactory.makeId( "x" ), 1, mkList(new StringLiteralExpr(span, "hello" ), new StringLiteralExpr(span, "goodbye" ) ) );
+            env.add( NodeFactory.makeId( "x" ), 1, mkList(ExprFactory.makeStringLiteralExpr(span, "hello" ), ExprFactory.makeStringLiteralExpr(span, "goodbye" ) ) );
             actual = original.accept( new EllipsesVisitor( env ) );
         }
@@ -85 +85 @@
         {
             expected = ExprFactory.makeTightJuxt( new Span(),
-                                                  new StringLiteralExpr(span, "hello" ),
-                                                  new StringLiteralExpr(span, "goodbye" ) );
+                                                  ExprFactory.makeStringLiteralExpr(span, "hello" ),
+                                                  ExprFactory.makeStringLiteralExpr(span, "goodbye" ) );
         }
 
@@ -99 +99 @@
         {
             List<Expr> blocks = new ArrayList<Expr>();
-            blocks.add( new StringLiteralExpr(span, "hi" ) );
+            blocks.add( ExprFactory.makeStringLiteralExpr(span, "hi" ) );
             blocks.add( mkTemplate( "x" ) );
             Expr extra = ExprFactory.makeBlock(span,  blocks );
@@ -106 +106 @@
             original = ExprFactory.makeTightJuxt(new Span(), exprs );
             EllipsesEnvironment env = new EllipsesEnvironment();
-            env.add( NodeFactory.makeId( "x" ), 1, mkList( new StringLiteralExpr(span, "a"), new StringLiteralExpr(span, "b" ) ) );
+            env.add( NodeFactory.makeId( "x" ), 1, mkList( ExprFactory.makeStringLiteralExpr(span, "a"), ExprFactory.makeStringLiteralExpr(span, "b" ) ) );
             actual = original.accept( new EllipsesVisitor( env ) );
         }
@@ -112 +112 @@
         {
             List<Expr> exprs = new ArrayList<Expr>();
-            exprs.add( ExprFactory.makeBlock(span, mkExprList( new StringLiteralExpr(span, "hi" ),
-                                              new StringLiteralExpr(span, "a" ) ) ) );
-            exprs.add( ExprFactory.makeBlock(span,  mkExprList( new StringLiteralExpr(span, "hi" ),
-                                              new StringLiteralExpr(span, "b" ) ) ) );
+            exprs.add( ExprFactory.makeBlock(span, mkExprList( ExprFactory.makeStringLiteralExpr(span, "hi" ),
+                                              ExprFactory.makeStringLiteralExpr(span, "a" ) ) ) );
+            exprs.add( ExprFactory.makeBlock(span,  mkExprList( ExprFactory.makeStringLiteralExpr(span, "hi" ),
+                                              ExprFactory.makeStringLiteralExpr(span, "b" ) ) ) );
             expected = ExprFactory.makeTightJuxt(new Span(), exprs );
         }
@@ -130 +130 @@
             List<Expr> extra = mkExprList(mkTemplate("i"), mkTemplate("j"));
             List<Expr> exprs = new ArrayList<Expr>();
-            exprs.add( new StringLiteralExpr(span, "bar" ) );
+            exprs.add( ExprFactory.makeStringLiteralExpr(span, "bar" ) );
             exprs.add( new _EllipsesExpr(new Span(), ExprFactory.makeTightJuxt(new Span(), extra ) ) );
             original = ExprFactory.makeTightJuxt(new Span(), exprs );
             EllipsesEnvironment env = new EllipsesEnvironment();
-            env.add( NodeFactory.makeId( "i" ), 0, new StringLiteralExpr(span, "a" ) );
-            env.add( NodeFactory.makeId( "j" ), 1, mkList( new StringLiteralExpr(span, "1" ),
-                                                           new StringLiteralExpr(span, "2" ),
-                                                           new StringLiteralExpr(span, "3" ) ) );
+            env.add( NodeFactory.makeId( "i" ), 0, ExprFactory.makeStringLiteralExpr(span, "a" ) );
+            env.add( NodeFactory.makeId( "j" ), 1, mkList( ExprFactory.makeStringLiteralExpr(span, "1" ),
+                                                           ExprFactory.makeStringLiteralExpr(span, "2" ),
+                                                           ExprFactory.makeStringLiteralExpr(span, "3" ) ) );
             actual = original.accept( new EllipsesVisitor( env ) );
         }
@@ -143 +143 @@
         {
             expected = ExprFactory.makeTightJuxt(new Span(),
-                                     mkExprList( new StringLiteralExpr(span, "bar" ),
+                                     mkExprList( ExprFactory.makeStringLiteralExpr(span, "bar" ),
                                                  ExprFactory.makeTightJuxt(new Span(),
-                                                                           new StringLiteralExpr(span, "a"),
-                                                                           new StringLiteralExpr(span, "1")),
+                                                                           ExprFactory.makeStringLiteralExpr(span, "a"),
+                                                                           ExprFactory.makeStringLiteralExpr(span, "1")),
                                                  ExprFactory.makeTightJuxt(new Span(),
-                                                                           new StringLiteralExpr(span, "a"),
-                                                                           new StringLiteralExpr(span, "2")),
+                                                                           ExprFactory.makeStringLiteralExpr(span, "a"),
+                                                                           ExprFactory.makeStringLiteralExpr(span, "2")),
                                                  ExprFactory.makeTightJuxt(new Span(),
-                                                                           new StringLiteralExpr(span, "a"),
-                                                                           new StringLiteralExpr(span, "3"))));
+                                                                           ExprFactory.makeStringLiteralExpr(span, "a"),
+                                                                           ExprFactory.makeStringLiteralExpr(span, "3"))));
         }
 

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

@@ -235 +235 @@
             Block body_result = (Block) recur(that.getBody());
             setSyntaxEnvironment(save);
-            return new Label(NodeFactory.makeSpan(that), exprType_result, newId, body_result);
+            return ExprFactory.makeLabel(NodeFactory.makeSpan(that), that.isParenthesized(),
+                                         exprType_result, newId, body_result);
         } else {
             return super.forLabel(that);

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

@@ -151 +151 @@
         Span span1 = newSpan("cat", 1, 2, 3);
         Span span2 = newSpan("cat", 1, 2, 3);
-        StringLiteralExpr sl1 = new StringLiteralExpr(span1, false, "123");
-        StringLiteralExpr sl2 = new StringLiteralExpr(span2, false, "123");
-        StringLiteralExpr sl3 = new StringLiteralExpr(span1, false, "124");
+        StringLiteralExpr sl1 = ExprFactory.makeStringLiteralExpr(span1, "123");
+        StringLiteralExpr sl2 = ExprFactory.makeStringLiteralExpr(span2, "123");
+        StringLiteralExpr sl3 = ExprFactory.makeStringLiteralExpr(span1, "124");
 
         een(sl1, sl2, sl3);
@@ -181 +181 @@
     StringLiteralExpr newString(String s) {
         Span span1 = newSpan("cat", 1, 2, 3);
-        return new StringLiteralExpr(span1, false, s);
+        return ExprFactory.makeStringLiteralExpr(span1, s);
     }
     IntLiteralExpr newInt(String s) {