Changeset 3189

Timestamp:

12/10/08 13:53:50 (12 months ago)

Author:

sukyoungryu

Message:

[ast refactoring] Removed optional fields of OpExpr? and AmbiguousMultifixOpExpr?.

Location:

trunk/ProjectFortress

Files:

• astgen/Fortress.ast (modified) (2 diffs)
• src/com/sun/fortress/compiler/desugarer/DesugaringVisitor.java (modified) (2 diffs)
• src/com/sun/fortress/compiler/desugarer/PreDisambiguationDesugaringVisitor.java (modified) (4 diffs)
• src/com/sun/fortress/compiler/typechecker/TypeChecker.java (modified) (8 diffs)
• src/com/sun/fortress/interpreter/evaluator/Evaluator.java (modified) (1 diff)
• src/com/sun/fortress/interpreter/rewrite/DesugarerVisitor.java (modified) (2 diffs)
• src/com/sun/fortress/nodes_util/ExprFactory.java (modified) (5 diffs)
• src/com/sun/fortress/parser_util/precedence_resolver/ASTUtil.java (modified) (4 diffs)

trunk/ProjectFortress/astgen/Fortress.ast

@@ -932 +932 @@
                          * e.g.) 3 + 5
                          */
-                        OpExpr(FunctionalRef op,
-                               List<Expr> args = Collections.<Expr>emptyList());
+                        OpExpr(FunctionalRef op, List<Expr> args);
                         /**
                          * If an expression uses and operator, and that operator
@@ -944 +943 @@
                          * e.g.) 3+4+5+6
                          */
-                        AmbiguousMultifixOpExpr(FunctionalRef infix_op, FunctionalRef multifix_op,
-                                                List<Expr> args = Collections.<Expr>emptyList())
+                        AmbiguousMultifixOpExpr(FunctionalRef infix_op,
+                                                FunctionalRef multifix_op,
+                                                List<Expr> args)
                                                implements OutAfterTypeChecking;
                         /**

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

@@ -27 +27 @@
 import edu.rice.cs.plt.tuple.Option;
 import edu.rice.cs.plt.tuple.Pair;
+import java.util.Arrays;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -420 +421 @@
                         if ( that.getAssignOp().isSome() ) {
                             Expr _lhs = (Expr)lhs_that.accept(DesugaringVisitor.this);
-                            rhs = ExprFactory.makeOpExpr(span, lhs_that.getExprType(),
+                            rhs = ExprFactory.makeOpExpr(span, lhs_that.isParenthesized(),
+                                                         lhs_that.getExprType(),
                                                          that.getAssignOp().unwrap(),
-                                                         _lhs, rhs);
+                                                         Arrays.asList(_lhs, rhs));
                         }
                         return ExprFactory.makeMethodInvocation(span, that.isParenthesized(),

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

@@ -121 +121 @@
 
         if( prefix || suffix ) {
-            OpExpr new_op = new OpExpr(that.getSpan(), that.isParenthesized(), that.getInfix_op(), that.getArgs());
+            OpExpr new_op = ExprFactory.makeOpExpr(that.getSpan(),
+                                                   that.isParenthesized(),
+                                                   that.getExprType(),
+                                                   that.getInfix_op(),
+                                                   that.getArgs());
             return recur(new_op);
         }
@@ -139 +143 @@
         }
         else {
-            new_op = new OpExpr(that.getSpan(), that.isParenthesized(), op_result, args_result);
+            new_op = ExprFactory.makeOpExpr(that.getSpan(),
+                                            that.isParenthesized(),
+                                            that.getExprType(),
+                                            op_result,
+                                            args_result);
         }
         return cleanupOpExpr(new_op);
@@ -179 +187 @@
                 arg = thunk(arg);
             }
-            res = ExprFactory.makeOpExpr(sp,qop,res,arg);
+            res = ExprFactory.makeOpExpr(sp, qop, res, arg);
         }
         return res;
@@ -195 +203 @@
                                   List<StaticArg> staticArgs) {
         body = visitGenerators(span, gens, body);
-        Expr opexp = ExprFactory.makeOpExpr(span,op,staticArgs);
+        Expr opexp = ExprFactory.makeOpExpr(span, op, staticArgs);
         Expr res = ExprFactory.makeTightJuxt(span, false,
                                              Useful.list(BIGOP_NAME,

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

@@ -313 +313 @@
                                         last_non_fn = Option.some(chunk_element.second());
                                 else
-                                        last_non_fn = Option.<Expr>some(ExprFactory.makeOpExpr(infix_juxt, last_non_fn.unwrap(), chunk_element.second()));
+                                        last_non_fn = Option.<Expr>some(ExprFactory.makeOpExpr(infix_juxt,
+                                                                                               last_non_fn.unwrap(),
+                                                                                               chunk_element.second()));
                         }
                         else {
@@ -1006 +1008 @@
                 // See if we can successfully typecheck this expression as a multifix one.
                 TypeCheckerResult multi_result =
-                        (new OpExpr(that.getSpan(),that.isParenthesized(),that.getMultifix_op(),that.getArgs()).accept(this));
+                        (ExprFactory.makeOpExpr(that.getSpan(),
+                                                that.isParenthesized(),
+                                                that.getExprType(),
+                                                that.getMultifix_op(),
+                                                that.getArgs()).accept(this));
 
                 if( multi_result.isSuccessful() ) {
@@ -1986 +1992 @@
 
                         // Check a temporary binary op, to see if the result is <: Boolean
-                        OpExpr tempOpExpr = new OpExpr(new Span(prev.getSpan(),next.getSpan()), false , op, Useful.list(prev, next));
+                        OpExpr tempOpExpr = ExprFactory.makeOpExpr(FortressUtil.spanTwo(prev,next),
+                                                                   op, prev, next);
                         TypeCheckerResult temp_op_result = tempOpExpr.accept(this);
                         temps_result.add(temp_op_result);
@@ -3117 +3124 @@
                 // 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);
+                OpExpr multi_op_expr = ExprFactory.makeOpExpr(that.getSpan(),
+                                                              that.isParenthesized(),
+                                                              that.getExprType(),
+                                                              that.getMultiJuxt(),
+                                                              new_juxt_exprs);
                 TypeCheckerResult multi_op_result = multi_op_expr.accept(this);
                 if( multi_op_result.type().isSome() ) {
@@ -3127 +3138 @@
                 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));
+                OpExpr cur_op_expr = ExprFactory.makeOpExpr(FortressUtil.spanTwo(expr_1,expr_2),
+                                                            that.getInfixJuxt(),
+                                                            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));
+                    cur_op_expr = ExprFactory.makeOpExpr(FortressUtil.spanTwo(cur_op_expr,next_expr),
+                                                         that.getInfixJuxt(),
+                                                         cur_op_expr, next_expr);
                 }
                 // typecheck this result instead
@@ -3699 +3714 @@
                 Type applicationType = app_result.unwrap().first();
 
-                OpExpr new_node = new OpExpr(that.getSpan(),
-                                that.isParenthesized(),
-                                Option.<Type>some(applicationType),
-                                (FunctionalRef)op_result.ast(),
-                                (List<Expr>)TypeCheckerResult.astFromResults(args_result));
+                OpExpr new_node = ExprFactory.makeOpExpr(that.getSpan(),
+                                                         that.isParenthesized(),
+                                                         Option.<Type>some(applicationType),
+                                                         (FunctionalRef)op_result.ast(),
+                                                         (List<Expr>)TypeCheckerResult.astFromResults(args_result));
 
                 // If we have a type, constraints must be propagated up.
@@ -4616 +4631 @@
                 // Moved this to seperate 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(),exprs);
+                OpExpr multi_op_expr = ExprFactory.makeOpExpr(that.getSpan(),that.getMultiJuxt(),exprs);
                 TypeCheckerResult multi_op_result = multi_op_expr.accept(this);
                 if( multi_op_result.type().isSome() ) {
@@ -4626 +4641 @@
                 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));
+                OpExpr cur_op_expr = ExprFactory.makeOpExpr(FortressUtil.spanTwo(expr_1,expr_2),
+                                                            that.getInfixJuxt(),
+                                                            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));
+                        cur_op_expr = ExprFactory.makeOpExpr(FortressUtil.spanTwo(cur_op_expr,next_expr),
+                                                             that.getInfixJuxt(),
+                                                             cur_op_expr, next_expr);
                 }
                 // typecheck this result instead

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

@@ -1068 +1068 @@
     @Override
     public FValue forAmbiguousMultifixOpExpr(AmbiguousMultifixOpExpr that) {
-        return this.forOpExpr(new OpExpr(that.getSpan(), that.isParenthesized(), that.getMultifix_op(), that.getArgs()));
+        return this.forOpExpr(ExprFactory.makeOpExpr(that.getSpan(),
+                                                     that.isParenthesized(),
+                                                     that.getExprType(),
+                                                     that.getMultifix_op(),
+                                                     that.getArgs()));
     }
 

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

@@ -678 +678 @@
         // remove these nodes and they should never appear at this
         // phase of execution. However, now we simply create an OpExpr.
-        Node node = new OpExpr(op.getSpan(), op.isParenthesized(), op.getInfix_op(), op.getArgs());
+        Node node = ExprFactory.makeOpExpr(op.getSpan(),
+                                           op.isParenthesized(),
+                                           op.getExprType(),
+                                           op.getInfix_op(),
+                                           op.getArgs());
         return visitNode(node);
     }
@@ -1607 +1611 @@
                         visitedArgs.size() == 1 ? visitedArgs.get(0) :
                             new TupleExpr(NodeFactory.makeSpan("impossible", visitedArgs),
-                                    visitedArgs));
+                                          visitedArgs));
             }
         } else  if (expr instanceof FieldRef) {

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

@@ -122 +122 @@
         return new MethodInvocation(span, isParenthesized, type, obj, field,
                                     staticArgs, expr);
+    }
+
+    public static OpExpr makeOpExpr(Span span, Op op) {
+        return makeOpExpr(span, makeOpRef(op));
+    }
+
+    public static OpExpr makeOpExpr(Span span, Op op, Expr arg) {
+        return makeOpExpr(span, false, Option.<Type>none(), makeOpRef(op),
+                          Collections.singletonList(arg));
+    }
+
+    public static OpExpr makeOpExpr(Span span, Op op, Expr first,
+                                    Expr second) {
+        return makeOpExpr(span, false, Option.<Type>none(), makeOpRef(op),
+                          Arrays.asList(first, second));
+    }
+
+    public static OpExpr makeOpExpr(Span span, Op op, List<StaticArg> staticArgs) {
+        return makeOpExpr(span, makeOpRef(op, staticArgs));
+    }
+
+    public static OpExpr makeOpExpr(Span span, FunctionalRef op) {
+        return makeOpExpr(span, false, Option.<Type>none(), op,
+                          Collections.<Expr>emptyList());
+    }
+
+    public static OpExpr makeOpExpr(Span span, FunctionalRef op,
+                                    List<Expr> args) {
+        return makeOpExpr(span, false, Option.<Type>none(), op, args);
+    }
+
+    public static OpExpr makeOpExpr(Span span, FunctionalRef op,
+                                    Expr first, Expr second) {
+        return makeOpExpr(span, false, Option.<Type>none(),
+                          op, Arrays.asList(first, second));
+    }
+
+    public static OpExpr makeOpExpr(Span span, Option<Type> ty, FunctionalRef op,
+                                    Expr first, Expr second) {
+        return makeOpExpr(span, false, ty, op, Arrays.asList(first, second));
+    }
+
+    public static OpExpr makeOpExpr(Span span, Op op, Expr arg,
+                                    List<StaticArg> staticArgs) {
+        return makeOpExpr(span, false, Option.<Type>none(),
+                          makeOpRef(op, staticArgs),
+                          Collections.singletonList(arg));
+    }
+
+    public static OpExpr makeOpExpr(Expr e,FunctionalRef op) {
+        return makeOpExpr(FortressUtil.spanTwo(e, op), false,
+                          Option.<Type>none(),
+                          op, Useful.list(e));
+    }
+
+    public static OpExpr makeOpExpr(FunctionalRef op, Expr e_1, Expr e_2) {
+        return makeOpExpr(FortressUtil.spanTwo(e_1, e_2), op, e_1, e_2);
+    }
+
+    public static OpExpr makeOpExpr(Span span, boolean isParenthesized,
+                                    Option<Type> ty, FunctionalRef op,
+                                    List<Expr> exprs) {
+        return new OpExpr(span, isParenthesized, ty, op, exprs);
     }
 
@@ -368 +431 @@
     }
 
-    public static OpExpr makeOpExpr(Span span, Option<Type> ty, FunctionalRef op,
-                                    Expr first, Expr second) {
-        return new OpExpr(span, false, ty, op, Arrays.asList(first, second));
-    }
-
-    public static OpExpr makeOpExpr(Span span, Op op) {
-        return new OpExpr(span, false, makeOpRef(op));
-    }
-
-    public static OpExpr makeOpExpr(Span span, Op op, Expr arg) {
-        return new OpExpr(span, false, makeOpRef(op),
-                Collections.singletonList(arg));
-    }
-
-    public static OpExpr makeOpExpr(Span span, Op op, Expr first,
-                                    Expr second) {
-        return new OpExpr(span, false, makeOpRef(op),
-                          Arrays.asList(first, second));
-    }
-
-    public static OpExpr makeOpExpr(Span span, Op op, List<StaticArg> staticArgs) {
-        return new OpExpr(span, false, makeOpRef(op, staticArgs));
-    }
-
-    public static OpExpr makeOpExpr(Span span, Op op, Expr arg,
-            List<StaticArg> staticArgs) {
-        return new OpExpr(span, false, makeOpRef(op, staticArgs),
-                          Collections.singletonList(arg));
-    }
-
-    /**
-     * Creates an OpExpr using the Spans from e_1 and e_2.
-     */
-    public static OpExpr makeOpExpr(FunctionalRef op, Expr e_1, Expr e_2) {
-     return new OpExpr(new Span(e_1.getSpan(), e_2.getSpan()), false, op, Useful.list(e_1, e_2));
-    }
-
-    public static OpExpr makeOpExpr(Expr e,FunctionalRef op) {
-     return new OpExpr(new Span(e.getSpan(),op.getSpan()),false,op,Useful.list(e));
-    }
-
     public static FnRef make_RewriteFnRefOverloading(Span span, FnRef original, Type type) {
         return new FnRef(span, original.isParenthesized(), original.getExprType(),
@@ -930 +952 @@
         }
         public Expr forOpExpr(OpExpr e) {
-            return new OpExpr(e.getSpan(), true, e.getOp(), e.getArgs());
+            return makeOpExpr(e.getSpan(), true, e.getExprType(), e.getOp(), e.getArgs());
         }
         @Override
-                public Expr forAmbiguousMultifixOpExpr(AmbiguousMultifixOpExpr that) {
-                return new AmbiguousMultifixOpExpr(that.getSpan(), true,
-                                                           that.getInfix_op(), that.getMultifix_op(),
-                                                           that.getArgs());
-                }
+            public Expr forAmbiguousMultifixOpExpr(AmbiguousMultifixOpExpr that) {
+            return new AmbiguousMultifixOpExpr(that.getSpan(), true, that.getExprType(),
+                                               that.getInfix_op(), that.getMultifix_op(),
+                                               that.getArgs());
+        }
         public Expr forArrayElement(ArrayElement e) {
             return makeArrayElement(e.getSpan(), true, e.getExprType(),
@@ -1046 +1068 @@
                               op.getLexicalDepth(),new_original_name,new_ops,
                               Option.<Type>none());
-     return ExprFactory.makeOpExpr(new_op, lhs, rhs);
+     return makeOpExpr(new_op, lhs, rhs);
     }
 
@@ -1069 +1091 @@
                               op.getLexicalDepth(),new_original_name,new_ops,
                               Option.<Type>none());
-     return ExprFactory.makeOpExpr(e, new_op);
+     return makeOpExpr(e, new_op);
     }
 

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

@@ -59 +59 @@
     public static Expr infix(Span span, Expr left, Op op, Expr right) {
         return ExprFactory.makeOpExpr(span, NodeFactory.makeOpInfix(op),
-                                       left, right);
+                                      left, right);
     }
 
@@ -66 +66 @@
     static Expr prefix(Op op, Expr arg) {
         return ExprFactory.makeOpExpr(arg.getSpan(),
-                                       NodeFactory.makeOpPrefix(op), arg);
+                                      NodeFactory.makeOpPrefix(op), arg);
     }
 
@@ -89 +89 @@
 
         if (args.size() > 2) {
-                return new AmbiguousMultifixOpExpr(span, false, infix_op, multifix_op, args);
+            return new AmbiguousMultifixOpExpr(span, false, Option.<Type>none(),
+                                               infix_op, multifix_op, args);
         }
         else if (args.size() == 2) {
-                return new OpExpr(span, false, infix_op, args);
-
+                return ExprFactory.makeOpExpr(span, infix_op, args);
         }
         else {
@@ -117 +117 @@
                                   Collections.<IdOrOp>singletonList(en),
                                   Option.<Type>none());
-            return new OpExpr(span, false, ref, args);
+            return ExprFactory.makeOpExpr(span, ref, args);
         } else {
             return error(right, "Mismatched Enclosers: " +