Changeset 3182

Timestamp:

12/09/08 17:39:54 (12 months ago)

Author:

sukyoungryu

Message:

[ast refactoring] Merged nodes: Juxt, LooseJuxt?, and TightJuxt?

Location:

trunk/ProjectFortress

Files:

• astgen/Fortress.ast (modified) (1 diff)
• src/com/sun/fortress/compiler/desugarer/DottedMethodRewriteVisitor.java (modified) (2 diffs)
• src/com/sun/fortress/compiler/desugarer/ObjectExpressionVisitor.java (modified) (4 diffs)
• src/com/sun/fortress/compiler/desugarer/PreDisambiguationDesugaringVisitor.java (modified) (1 diff)
• src/com/sun/fortress/compiler/desugarer/VarRefContainer.java (modified) (3 diffs)
• src/com/sun/fortress/compiler/typechecker/TypeChecker.java (modified) (2 diffs)
• src/com/sun/fortress/interpreter/evaluator/BuildEnvironments.java (modified) (1 diff)
• src/com/sun/fortress/interpreter/evaluator/BuildNativeEnvironment.java (modified) (1 diff)
• src/com/sun/fortress/interpreter/evaluator/Evaluator.java (modified) (8 diffs)
• src/com/sun/fortress/interpreter/glue/NativeApp.java (modified) (3 diffs)
• src/com/sun/fortress/interpreter/rewrite/DesugarerVisitor.java (modified) (6 diffs)
• src/com/sun/fortress/nodes_util/DesugarerUtil.java (modified) (3 diffs)
• src/com/sun/fortress/nodes_util/ExprFactory.java (modified) (5 diffs)
• src/com/sun/fortress/parser/Expression.rats (modified) (1 diff)
• src/com/sun/fortress/parser/templateparser/Gaps.rats (modified) (1 diff)
• src/com/sun/fortress/parser_util/FortressUtil.java (modified) (1 diff)
• src/com/sun/fortress/parser_util/precedence_resolver/ASTUtil.java (modified) (2 diffs)
• src/com/sun/fortress/syntax_abstractions/phases/EllipsesJUTest.java (modified) (10 diffs)
• src/com/sun/fortress/tools/FortressAstToConcrete.java (modified) (1 diff)

trunk/ProjectFortress/astgen/Fortress.ast

@@ -914 +914 @@
                          * e.g.) myString.replace("foo", "few")
                          * e.g.) log log n
-                         */
-                        abstract Juxt(FunctionalRef multiJuxt = ExprFactory.makeMultiJuxt(),
-                                      FunctionalRef infixJuxt = ExprFactory.makeInfixJuxt(),
-                                      List<Expr> exprs = new LinkedList<Expr>());
-                            /**
-                             * juxtaposition with intervening whitespace
-                             * e.g.) 3 5
-                             */
-                            LooseJuxt();
-                            /**
-                             * juxtaposition without intervening whitespace. If fnApp is true,
-                             * then this juxtaposition should be type checked ONLY as a function
-                             * application. This should be the case for desugarings only.
-                             * e.g.) f(3+5)
-                             */
-                            TightJuxt(boolean fnApp = false);
+                         *
+                         * loose juxtaposition
+                         * juxtaposition with intervening whitespace
+                         * e.g.) 3 5
+                         *
+                         * tight juxtaposition
+                         * juxtaposition without intervening whitespace. If fnApp is true,
+                         * then this juxtaposition should be type checked ONLY as a function
+                         * application. This should be the case for desugarings only.
+                         * e.g.) f(3+5)
+                         */
+                        Juxt(FunctionalRef multiJuxt = ExprFactory.makeMultiJuxt(),
+                             FunctionalRef infixJuxt = ExprFactory.makeInfixJuxt(),
+                             List<Expr> exprs = new LinkedList<Expr>(),
+                             boolean fnApp, boolean tight) implements OutAfterTypeChecking;
                         /**
                          * functional application

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

@@ -27 +27 @@
 import com.sun.fortress.nodes.Expr;
 import com.sun.fortress.nodes.FnRef;
-import com.sun.fortress.nodes.LooseJuxt;
+import com.sun.fortress.nodes.Juxt;
 import com.sun.fortress.nodes.MethodInvocation;
 import com.sun.fortress.nodes.Node;
 import com.sun.fortress.nodes.NodeUpdateVisitor;
 import com.sun.fortress.nodes.ObjectDecl;
-import com.sun.fortress.nodes.TightJuxt;
 import com.sun.fortress.nodes.VarRef;
 import com.sun.fortress.nodes._RewriteFnApp;
@@ -59 +58 @@
 
     @Override
-    public Node forLooseJuxt(LooseJuxt that) {
+    public Node forJuxt(Juxt that) {
         // FIXME: Not sure if I really need to recur on other things
         List<Expr> exprs_result = recurOnListOfExpr(that.getExprs());
-
         Expr first = exprs_result.get(0);
         if(first instanceof FnRef && methodRefs.contains(first)) {
             FnRef fnRef = (FnRef) first;
-            MethodInvocation mi = makeMethodInvocationFrom(
-                    fnRef, exprs_result.subList(1, exprs_result.size()) );
+            MethodInvocation mi = makeMethodInvocationFrom(fnRef, exprs_result.subList(1, exprs_result.size()) );
             exprs_result = new LinkedList<Expr>();
             exprs_result.add(mi);
         }
-
-        return forLooseJuxtOnly(that, that.getExprType(), that.getMultiJuxt(),
-                                that.getInfixJuxt(), exprs_result);
+        return forJuxtOnly(that,
+                           that.getExprType(), that.getMultiJuxt(),
+                           that.getInfixJuxt(), exprs_result);
     }
-
-
-    public Node forTightJuxt(TightJuxt that) {
-        // FIXME: Not sure if I really need to recur on other things
-        List<Expr> exprs_result = recurOnListOfExpr(that.getExprs());
-
-        Expr first = exprs_result.get(0);
-        if(first instanceof FnRef && methodRefs.contains(first)) {
-            FnRef fnRef = (FnRef) first;
-            MethodInvocation mi = makeMethodInvocationFrom(
-                    fnRef, exprs_result.subList(1, exprs_result.size()) );
-            exprs_result = new LinkedList<Expr>();
-            exprs_result.add(mi);
-        }
-
-        return forTightJuxtOnly(that, that.getExprType(), that.getMultiJuxt(),
-                                that.getInfixJuxt(), exprs_result);
-    }
-
 
     public Node for_RewriteFnApp(_RewriteFnApp that) {

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

@@ -408 +408 @@
                     Pair<Id,Type> exitFnInfo = exitFnParamMap.get(exitKey);
                     if(exitFnInfo != null) {
-                        List<Expr> exprs = new LinkedList<Expr>();
                         Option<Expr> returnExpr = that.getReturnExpr();
-
                         Id fnName = exitFnInfo.first();
                         FnRef fnRef = ExprFactory.makeFnRef(fnName);
-                        exprs.add(fnRef);
-                        exprs.add( unwrapIfSomeElseAlternative(returnExpr,
-                                     ExprFactory.makeVoidLiteralExpr(span)) );
-
-                        return ExprFactory.makeTightJuxt(span, false, exprs);
+                        Expr arg = unwrapIfSomeElseAlternative(returnExpr,
+                                                               ExprFactory.makeVoidLiteralExpr(span));
+                        return ExprFactory.make_RewriteFnApp(fnRef, arg);
                     } else {
                         return that;
@@ -426 +422 @@
 
         newObjectDecls.add(lifted);
-        TightJuxt callToLifted = makeCallToLiftedObj(lifted, that, freeNames);
+        Expr callToLifted = makeCallToLiftedObj(lifted, that, freeNames);
 
         scopeStack.pop();
@@ -435 +431 @@
 
 
-    private TightJuxt makeCallToLiftedObj(ObjectDecl lifted,
-                                          ObjectExpr objExpr,
-                                          FreeNameCollection freeNames) {
+    private Expr makeCallToLiftedObj(ObjectDecl lifted,
+                                      ObjectExpr objExpr,
+                                      FreeNameCollection freeNames) {
         Span span = objExpr.getSpan();
         Id originalName = lifted.getName();
@@ -460 +456 @@
         List<Expr> exprs = makeArgsForCallToLiftedObj(objExpr,
                                                       freeNames, enclosingSelf);
-        exprs.add(0, fnRef);
-
-        TightJuxt callToConstructor =
-            ExprFactory.makeTightJuxt(span, objExpr.isParenthesized(), exprs);
-
-        return callToConstructor;
+        Expr arg = ExprFactory.makeTuple(exprs);
+        return ExprFactory.make_RewriteFnApp(fnRef, arg);
     }
 

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

@@ -196 +196 @@
         body = visitGenerators(span, gens, body);
         Expr opexp = ExprFactory.makeOpExpr(span,op,staticArgs);
-        Expr res = new TightJuxt(span, false,
-                                 Useful.list(BIGOP_NAME,
-                                             ExprFactory.makeTuple(opexp,body)));
+        Expr res = ExprFactory.makeTightJuxt(span, false,
+                                             Useful.list(BIGOP_NAME,
+                                                         ExprFactory.makeTuple(opexp,body)));
         return (Expr)recur(res);
     }

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

@@ -37 +37 @@
 import com.sun.fortress.nodes.StaticArg;
 import com.sun.fortress.nodes.StaticParam;
-import com.sun.fortress.nodes.TightJuxt;
 import com.sun.fortress.nodes.TraitTypeWhere;
 import com.sun.fortress.nodes.Type;
@@ -155 +154 @@
     }
 
-    private TightJuxt makeCallToContainerObj() {
+    private Expr makeCallToContainerObj() {
         List<IdOrOp> fns = new LinkedList<IdOrOp>();
         Span origSpan = origDeclNode.getSpan();
@@ -163 +162 @@
                                                    containerDeclId(), fns, Collections.<StaticArg>emptyList() );
 
-        List<Expr> exprs = new LinkedList<Expr>();
-        exprs.add(fnRefToDecl);
-        exprs.add(origVar);
-
-        return( ExprFactory.makeTightJuxt(origSpan, false, exprs) );
+        return( ExprFactory.make_RewriteFnApp(fnRefToDecl, origVar) );
     }
 

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

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

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

@@ -505 +505 @@
                 // Create a little expression to run the constructor.
                 Expr init = ExprFactory.makeTightJuxt(x.getSpan(),
-                      ExprFactory.makeVarRef(x.getSpan(), WellKnownNames.obfuscatedSingletonConstructorName(fname, x), 0),
-                      ExprFactory.makeVoidLiteralExpr(x.getSpan()));
+                                                      ExprFactory.makeVarRef(x.getSpan(), WellKnownNames.obfuscatedSingletonConstructorName(fname, x), 0),
+                                                      ExprFactory.makeVoidLiteralExpr(x.getSpan()));
                 FValue init_value = new LazilyEvaluatedCell(init, containing);
                 putValue(bindInto, fname, init_value);

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

@@ -160 +160 @@
 
                 // Create a little expression to run the constructor.
-                Expr init = ExprFactory.makeTightJuxt(x.getSpan(), ExprFactory
-                        .makeVarRef(x.getSpan(), WellKnownNames.obfuscatedSingletonConstructorName(fname, x), 0),
-                        ExprFactory.makeVoidLiteralExpr(x.getSpan()));
+                Expr init = ExprFactory.makeTightJuxt(x.getSpan(),
+                                                      ExprFactory.makeVarRef(x.getSpan(), WellKnownNames.obfuscatedSingletonConstructorName(fname, x), 0),
+                                                      ExprFactory.makeVoidLiteralExpr(x.getSpan()));
                 FValue init_value = new LazilyEvaluatedCell(init, containing);
                 putValue(bindInto, fname, init_value);

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

@@ -108 +108 @@
 import com.sun.fortress.nodes.Lhs;
 import com.sun.fortress.nodes.Link;
-import com.sun.fortress.nodes.LooseJuxt;
 import com.sun.fortress.nodes.MathItem;
 import com.sun.fortress.nodes.MathPrimary;
@@ -127 +126 @@
 import com.sun.fortress.nodes.SubscriptingMI;
 import com.sun.fortress.nodes.Throw;
-import com.sun.fortress.nodes.TightJuxt;
 import com.sun.fortress.nodes.Try;
 import com.sun.fortress.nodes.TryAtomicExpr;
@@ -906 +904 @@
     }
 
-    public FValue forLooseJuxt(LooseJuxt x) {
-        return forJuxt(x);
-    }
     public FValue forJuxt(Juxt x) {
+        if ( x.isTight() ) {
+            /** Assumes wrapped FnRefs have ids fields of length 1. */
+            return forTightJuxt(x, false);
+        } else
+            return forJuxtCommon(x);
+    }
+
+    public FValue forJuxtCommon(Juxt x) {
         // This is correct except for one minor detail:
         // We should treat names from another scope as if they were functions.
@@ -920 +923 @@
             bug(x,"empty juxtaposition");
         try {
-            // times = e.getValue("juxtaposition");
+                // times = e.getValue("juxtaposition");
             times = e.getValueNull(x.getInfixJuxt());
         } catch (FortressException fe) {
@@ -1096 +1099 @@
                               "immediately followed by a non-expression " +
                               "element.");
-            } else if (arg instanceof TightJuxt) { // f(x)!
-                vargs = Useful.list(forTightJuxt((TightJuxt)arg, true));
+            } else if ( arg instanceof Juxt &&
+                        ((Juxt)arg).isTight() ) { // f(x)!
+                vargs = Useful.list(forTightJuxt((Juxt)arg, true));
             } else if (arg instanceof MathPrimary) { // f(x)^y! y[a](x)!
                 vargs = Useful.list(forMathPrimary((MathPrimary)arg, true));
@@ -1390 +1394 @@
     }
 
-    /** Assumes wrapped FnRefs have ids fields of length 1. */
-    public FValue forTightJuxt(TightJuxt x) {
-        return forTightJuxt(x, false);
-    }
-
-    private FValue forTightJuxt(TightJuxt x, boolean isPostfix) {
+    private FValue forTightJuxt(Juxt x, boolean isPostfix) {
         List<Expr> exprs = x.getExprs();
         if (exprs.size() == 0)
@@ -1453 +1452 @@
             // Please fix it if you know how to do it.  -- Sukyoung
             // Less of a hack now.  -- David
-            return forJuxt(x);
+            return forJuxtCommon(x);
         }
     }
@@ -1466 +1465 @@
      * @throws ProgramError
      */
-    private FValue juxtMemberSelection(TightJuxt x, FValue fobj, Id fld,
+    private FValue juxtMemberSelection(Juxt x, FValue fobj, Id fld,
                                        List<Expr> exprs) throws ProgramError {
         List<FValue> args = evalInvocationArgs(exprs);

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

@@ -36 +36 @@
 import com.sun.fortress.nodes.Id;
 import com.sun.fortress.nodes.IdOrOpOrAnonymousName;
+import com.sun.fortress.nodes.Juxt;
 import com.sun.fortress.nodes.MathItem;
 import com.sun.fortress.nodes.MathPrimary;
@@ -41 +42 @@
 import com.sun.fortress.nodes.StaticParam;
 import com.sun.fortress.nodes.StringLiteralExpr;
-import com.sun.fortress.nodes.TightJuxt;
 import com.sun.fortress.nodes.Type;
 import com.sun.fortress.nodes.VarRef;
@@ -153 +153 @@
         Expr fn;
         Expr arg;
-        if (body instanceof TightJuxt) {
-            List<Expr> juxts = ((TightJuxt)body).getExprs();
+        if ( body instanceof Juxt &&
+             ((Juxt)body).isTight() ) {
+            List<Expr> juxts = ((Juxt)body).getExprs();
             if (juxts.size()!=2) return defn;
             fn = juxts.get(0);

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

@@ -93 +93 @@
 import com.sun.fortress.nodes.StaticParam;
 import com.sun.fortress.nodes.TestDecl;
-import com.sun.fortress.nodes.TightJuxt;
 import com.sun.fortress.nodes.BaseType;
 import com.sun.fortress.nodes.TraitDecl;
@@ -775 +774 @@
     }
     @Override
-    public Node forTightJuxt(TightJuxt node) {
-        if (looksLikeMethodInvocation(node))
-            return translateJuxtOfDotted(node);
-        else
-            return visitNode(node);
+    public Node forJuxt(Juxt node) {
+        if ( node.isTight() ) {
+            if (looksLikeMethodInvocation(node))
+                return translateJuxtOfDotted(node);
+            else
+                return visitNode(node);
+        } else return visitNode(node);
     }
     @Override
@@ -1078 +1079 @@
             args.add(bindsAndBody(g,w.getBody()));
             Expr cond =
-                new TightJuxt(g.getSpan(), false,
-                              Useful.list(Q_WHILECOND_NAME,
-                                          ExprFactory.makeTuple(w.getSpan(),args)));
+                ExprFactory.makeTightJuxt(g.getSpan(),
+                                          Q_WHILECOND_NAME,
+                                          ExprFactory.makeTuple(w.getSpan(),args));
             w = ExprFactory.makeWhile(w.getSpan(),cond);
         }
@@ -1114 +1115 @@
         List<Param> params = Collections.emptyList();
         FnExpr fnExpr = new FnExpr(sp, params, (Expr) rewrittenExpr);
-        List<Expr> exprs = new ArrayList<Expr>(2);
-        exprs.add(fn);
-
-        exprs.add(fnExpr);
-
-        TightJuxt juxt = new TightJuxt(s.getSpan(), false, exprs);
-
-        return visitNode(juxt);
+
+        return visitNode(ExprFactory.makeTightJuxt(s.getSpan(), fn, fnExpr));
     }
 
@@ -1191 +1186 @@
             args.add(bindsAndBody(g,c.getBody()));
             if (elsePart != null) args.add(thunk(elsePart));
-            return new TightJuxt(c.getSpan(), false,
-                                 Useful.list(Q_COND_NAME,
-                                             ExprFactory.makeTuple(c.getSpan(),args)));
+            return ExprFactory.makeTightJuxt(c.getSpan(),
+                                             Q_COND_NAME,
+                                             ExprFactory.makeTuple(c.getSpan(),args));
         }
         // if expr then body else elsePart end is preserved
@@ -1218 +1213 @@
             Expr loopSel = ExprFactory.makeFieldRef(g.getSpan(),
                                                     g.getInit(), LOOP_NAME);
-            body = new TightJuxt(span, false, Useful.list(loopSel,loopBody));
+            body = ExprFactory.makeTightJuxt(span, loopSel,loopBody);
         }
         // System.out.println("Desugared to "+body.toStringVerbose());

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

@@ -134 +134 @@
         if (i==0) {
             /* Single generator as body, with no generator clauses. */
-            body = new TightJuxt(span, false,
-                             Useful.list(GENERATE_NAME,
-                                         ExprFactory.makeTuple(body,redVar,unitVar)));
+            body = ExprFactory.makeTightJuxt(span,
+                                             GENERATE_NAME,
+                                             ExprFactory.makeTuple(body,redVar,unitVar));
         } else {
             List<GeneratorClause> squozenGens =
@@ -162 +162 @@
             // Wrap the body in parentheses (as a singleton tuple) so that it can be considered
             // as the argument in a function application (denoted by the true argument).
-            body = new TightJuxt(body.getSpan(),
-                                 false,
-                                 Useful.list(unitVar, body),
-                                 true);
+            body = ExprFactory.makeTightJuxt(body.getSpan(),
+                                             false,
+                                             Useful.list(unitVar, body),
+                                             true);
             for (i--; i>=0; i--) {
                 body = oneGenerator(gens.get(i), redVar, body);
@@ -273 +273 @@
         Expr loopBody = bindsAndBody(g, body);
         Expr params = ExprFactory.makeTuple(g.getInit(), reduction, loopBody);
-        return new TightJuxt(g.getSpan(), false,
-                             Useful.list(GENERATE_NAME,params));
+        return ExprFactory.makeTightJuxt(g.getSpan(), GENERATE_NAME, params);
     }
 }

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

@@ -426 +426 @@
     }
 
-    public static TightJuxt makeTightJuxt(Span span, Expr first, Expr second) {
-        return new TightJuxt(span, false, Useful.list(first, second));
-    }
-
-    public static TightJuxt makeTightJuxt(Span span, boolean isParenthesized, List<Expr> exprs) {
-        return new TightJuxt(span, isParenthesized, Useful.immutableTrimmedList(exprs));
-    }
-
-    public static TightJuxt makeTightJuxt(Span span, List<Expr> exprs, Boolean isParenthesized, FunctionalRef infixJuxt, FunctionalRef multiJuxt){
-     return new TightJuxt(span, isParenthesized, multiJuxt, infixJuxt ,Useful.immutableTrimmedList(exprs));
+    public static Juxt makeLooseJuxt(Span span, boolean isParenthesized, List<Expr> exprs) {
+        return new Juxt(span, isParenthesized, Useful.immutableTrimmedList(exprs),
+                        false, false);
+    }
+
+    public static Juxt makeTightJuxt(Span span, Expr first, Expr second) {
+        return new Juxt(span, false, Option.<Type>none(),
+                        Useful.list(first, second), false, true);
+    }
+
+    public static Juxt makeTightJuxt(Span span, boolean isParenthesized, List<Expr> exprs) {
+        return new Juxt(span, isParenthesized, Useful.immutableTrimmedList(exprs),
+                        false, true);
+    }
+
+    public static Juxt makeTightJuxt(Span span, boolean isParenthesized, List<Expr> exprs, boolean isFnApp) {
+        return new Juxt(span, isParenthesized, Useful.immutableTrimmedList(exprs),
+                        isFnApp, true);
+    }
+
+    public static Juxt makeTightJuxt(Span span, List<Expr> exprs,
+                                     Boolean isParenthesized,
+                                     FunctionalRef infixJuxt,
+                                     FunctionalRef multiJuxt){
+        return new Juxt(span, isParenthesized, multiJuxt, infixJuxt,
+                        Useful.immutableTrimmedList(exprs),
+                        false, true);
     }
 
@@ -442 +459 @@
      * with new exprs.
      */
-    public static TightJuxt makeTightJuxt(TightJuxt that, List<Expr> exprs) {
-     return new TightJuxt(that.getSpan(), that.isParenthesized(),
-                          that.getMultiJuxt(), that.getInfixJuxt(), Useful.immutableTrimmedList(exprs));
+    public static Juxt makeTightJuxt(Juxt that, List<Expr> exprs) {
+     return new Juxt(that.getSpan(), that.isParenthesized(),
+                     that.getMultiJuxt(), that.getInfixJuxt(),
+                     Useful.immutableTrimmedList(exprs),
+                     that.isFnApp(), true);
     }
 
@@ -895 +914 @@
                     e.getArg());
         }
-        public Expr forLooseJuxt(LooseJuxt e) {
-            return new LooseJuxt(e.getSpan(), true, e.getExprs());
-        }
-        public Expr forTightJuxt(TightJuxt e) {
-            return new TightJuxt(e.getSpan(), true, e.getExprs());
+        public Expr forJuxt(Juxt e) {
+            return new Juxt(e.getSpan(), true, e.getExprType(),
+                            e.getMultiJuxt(), e.getInfixJuxt(),
+                            e.getExprs(), e.isFnApp(), e.isTight());
         }
         public Expr forFnRef(FnRef e) {
@@ -985 +1003 @@
         if (mi instanceof ExprMI) {
             Expr expr = ((ExprMI)mi).getExpr();
-            return new TightJuxt(span, Useful.list(front, expr));
+            return makeTightJuxt(span, front, expr);
         } else if (mi instanceof ExponentiationMI) {
             ExponentiationMI expo = (ExponentiationMI)mi;
@@ -1038 +1056 @@
     }
 
-    public static TemplateGapLooseJuxt makeTemplateGapLooseJuxt(Span s, Id id, List<Id> params) {
-        return new TemplateGapLooseJuxt(s, id, params);
+    public static TemplateGapJuxt makeTemplateGapJuxt(Span s, Id id, List<Id> params) {
+        return new TemplateGapJuxt(s, id, params);
     }
 

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

@@ -502 +502 @@
           public Expr run(Expr base) {
               List<Expr> exprs = FortressUtil.mkList(base, a1);
-              return new TightJuxt(FortressUtil.spanTwo(base, a1), false, exprs);
+              return ExprFactory.makeTightJuxt(FortressUtil.spanTwo(base, a1), false, exprs);
           }};
     };

trunk/ProjectFortress/src/com/sun/fortress/parser/templateparser/Gaps.rats

@@ -56 +56 @@
      };
 
-LooseJuxt LooseJuxtGap =
+Juxt LooseJuxtGap =
      <GAP> prefix "LooseJuxt" w a1:Id params:ParamList? w suffix
      { if (params == null) params = new LinkedList<Id>();
-       yyValue = ExprFactory.makeTemplateGapLooseJuxt(createSpan(yyStart,yyCount), a1, params);
+       yyValue = ExprFactory.makeTemplateGapJuxt(createSpan(yyStart,yyCount), a1, params);
      };
 

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

@@ -874 +874 @@
             exprs = exprs.reverse();
             List<Expr> javaList = Useful.immutableTrimmedList(exprs);
-            return new TightJuxt(spanAll(javaList.toArray(new AbstractNode[0]),
-                                         javaList.size()), false, javaList);
+            return new Juxt(spanAll(javaList.toArray(new AbstractNode[0]),
+                                    javaList.size()),
+                            false, javaList, false, true);
         }
     }

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

@@ -32 +32 @@
 import com.sun.fortress.nodes.Expr;
 import com.sun.fortress.nodes.Link;
-import com.sun.fortress.nodes.LooseJuxt;
 import com.sun.fortress.nodes.IdOrOp;
 import com.sun.fortress.nodes.Op;
@@ -144 +143 @@
                 }
             });
-        return new LooseJuxt(spanAll(exprs), false, _exprs.toJavaList());
+        return ExprFactory.makeLooseJuxt(spanAll(exprs), false, _exprs.toJavaList());
     }
 

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

@@ -22 +22 @@
 import com.sun.fortress.nodes.*;
 import com.sun.fortress.nodes_util.NodeFactory;
+import com.sun.fortress.nodes_util.ExprFactory;
 import com.sun.fortress.nodes_util.Span;
 
@@ -30 +31 @@
 
     static Span span = NodeFactory.makeSpan("EllipsesJUTest");
-    
+
     private <T> List<T> mkList( T... e ){
         List<T> list = new ArrayList<T>();
@@ -54 +55 @@
             List<Expr> exprs = new ArrayList<Expr>();
             exprs.add( new _EllipsesExpr(new Span(), mkTemplate( "x" ) ) );
-            original = new TightJuxt(new Span(), false, exprs); 
+            original = ExprFactory.makeTightJuxt(new Span(), false, exprs);
             EllipsesEnvironment env = new EllipsesEnvironment();
             env.add( NodeFactory.makeId( "x" ), 1, mkList(new StringLiteralExpr(span,  "hello" )) );
@@ -63 +64 @@
             List<Expr> exprs = new ArrayList<Expr>();
             exprs.add( new StringLiteralExpr(span,  "hello" ) );
-            expected = new TightJuxt( new Span(), false, exprs );
+            expected = ExprFactory.makeTightJuxt( new Span(), false, exprs );
         }
 
@@ -76 +77 @@
             List<Expr> exprs = new ArrayList<Expr>();
             exprs.add( new _EllipsesExpr(new Span(), mkTemplate( "x" ) ) );
-            original = new TightJuxt(new Span(), false, exprs); 
+            original = ExprFactory.makeTightJuxt(new Span(), false, exprs);
             EllipsesEnvironment env = new EllipsesEnvironment();
             env.add( NodeFactory.makeId( "x" ), 1, mkList(new StringLiteralExpr(span, "hello" ), new StringLiteralExpr(span, "goodbye" ) ) );
@@ -83 +84 @@
 
         {
-            List<Expr> exprs = new ArrayList<Expr>();
-            exprs.add( new StringLiteralExpr(span, "hello" ) );
-            exprs.add( new StringLiteralExpr(span, "goodbye" ) );
-            expected = new TightJuxt( new Span(), false, exprs );
+            expected = ExprFactory.makeTightJuxt( new Span(),
+                                                  new StringLiteralExpr(span, "hello" ),
+                                                  new StringLiteralExpr(span, "goodbye" ) );
         }
 
@@ -104 +104 @@
             List<Expr> exprs = new ArrayList<Expr>();
             exprs.add( new _EllipsesExpr( new Span(), extra ) );
-            original = new TightJuxt(new Span(), false, exprs );
+            original = ExprFactory.makeTightJuxt(new Span(), false, exprs );
             EllipsesEnvironment env = new EllipsesEnvironment();
             env.add( NodeFactory.makeId( "x" ), 1, mkList( new StringLiteralExpr(span, "a"), new StringLiteralExpr(span, "b" ) ) );
@@ -116 +116 @@
             exprs.add( new Block(span,  mkExprList( new StringLiteralExpr(span, "hi" ),
                                               new StringLiteralExpr(span, "b" ) ) ) );
-            expected = new TightJuxt(new Span(), false, exprs );
+            expected = ExprFactory.makeTightJuxt(new Span(), false, exprs );
         }
 
@@ -131 +131 @@
             List<Expr> exprs = new ArrayList<Expr>();
             exprs.add( new StringLiteralExpr(span, "bar" ) );
-            exprs.add( new _EllipsesExpr(new Span(), new TightJuxt(new Span(), false, extra ) ) );
-            original = new TightJuxt(new Span(), false, exprs );
+            exprs.add( new _EllipsesExpr(new Span(), ExprFactory.makeTightJuxt(new Span(), false, extra ) ) );
+            original = ExprFactory.makeTightJuxt(new Span(), false, exprs );
             EllipsesEnvironment env = new EllipsesEnvironment();
             env.add( NodeFactory.makeId( "i" ), 0, new StringLiteralExpr(span, "a" ) );
@@ -142 +142 @@
 
         {
-            expected = new TightJuxt(new Span(), false,
+            expected = ExprFactory.makeTightJuxt(new Span(), false,
                                      mkExprList( new StringLiteralExpr(span, "bar" ),
-                                                 new TightJuxt(new Span(), false,
-                                                               mkExprList( new StringLiteralExpr(span, "a"),
-                                                                           new StringLiteralExpr(span, "1"))),
-                                                 new TightJuxt(new Span(), false,
-                                                               mkExprList( new StringLiteralExpr(span, "a"),
-                                                                           new StringLiteralExpr(span, "2"))),
-                                                 new TightJuxt(new Span(), false,
-                                                               mkExprList( new StringLiteralExpr(span, "a"),
-                                                                           new StringLiteralExpr(span, "3")))));
+                                                 ExprFactory.makeTightJuxt(new Span(),
+                                                                           new StringLiteralExpr(span, "a"),
+                                                                           new StringLiteralExpr(span, "1")),
+                                                 ExprFactory.makeTightJuxt(new Span(),
+                                                                           new StringLiteralExpr(span, "a"),
+                                                                           new StringLiteralExpr(span, "2")),
+                                                 ExprFactory.makeTightJuxt(new Span(),
+                                                                           new StringLiteralExpr(span, "a"),
+                                                                           new StringLiteralExpr(span, "3"))));
         }
 
         assertEquals( actual, expected );
     }
-        
+
 }

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

@@ -1704 +1704 @@
     }
 
-    @Override public String forLooseJuxtOnly(LooseJuxt that, Option<String> exprType_result,
-                                             String multiJuxt_result,
-                                             String infixJuxt_result,
-                                             List<String> exprs_result) {
-        StringBuilder s = new StringBuilder();
-
-        for ( String expr : exprs_result ){
-            s.append( expr );
-            s.append( " " );
-        }
-
-        return handleParen( s.toString(),
-                            that.isParenthesized() );
-    }
-
-    @Override public String forTightJuxtOnly(TightJuxt that, Option<String> exprType_result,
-                                             String multiJuxt_result,
-                                             String infixJuxt_result,
-                                             List<String> exprs_result) {
-        StringBuilder s = new StringBuilder();
-
-        if ( exprs_result.isEmpty() )
-            return bug(that, "A tight juxtaposition expression should have " +
-                       "at least two subexpressions.");
-        s.append(IterUtil.first(exprs_result));
-        for ( String expr : IterUtil.skipFirst(exprs_result) ){
-            s.append( inParentheses(expr) );
-        }
-
-        if ( that.isParenthesized() )
-            return "(" + s.toString() + ")";
-        else
-            return s.toString();
+    @Override public String forJuxtOnly(Juxt that, Option<String> exprType_result,
+                                        String multiJuxt_result,
+                                        String infixJuxt_result,
+                                        List<String> exprs_result) {
+        StringBuilder s = new StringBuilder();
+
+        if ( that.isTight() ) {
+            if ( exprs_result.isEmpty() )
+                return bug(that, "A tight juxtaposition expression should have " +
+                           "at least two subexpressions.");
+            s.append(IterUtil.first(exprs_result));
+            for ( String expr : IterUtil.skipFirst(exprs_result) ){
+                s.append( inParentheses(expr) );
+            }
+            if ( that.isParenthesized() )
+                return "(" + s.toString() + ")";
+            else
+                return s.toString();
+        } else {
+            for ( String expr : exprs_result ){
+                s.append( expr );
+                s.append( " " );
+            }
+            return handleParen( s.toString(),
+                                that.isParenthesized() );
+        }
     }