Changeset 3111

Timestamp:

11/26/08 13:22:06 (12 months ago)

Author:

sukyoungryu

Message:

[ast refactoring] Merged AbstractTupleExpr?, TupleExpr?, ArgExpr?, and VarargsExpr? to TupleExpr?.

Location:

trunk/ProjectFortress

Files:

• astgen/Fortress.ast (modified) (2 diffs)
• src/com/sun/fortress/compiler/typechecker/TypeChecker.java (modified) (3 diffs)
• src/com/sun/fortress/interpreter/evaluator/Evaluator.java (modified) (4 diffs)
• src/com/sun/fortress/interpreter/evaluator/LHSEvaluator.java (modified) (3 diffs)
• src/com/sun/fortress/interpreter/evaluator/LHSToLValue.java (modified) (2 diffs)
• src/com/sun/fortress/nodes_util/ExprFactory.java (modified) (1 diff)
• src/com/sun/fortress/parser/DelimitedExpr.rats (modified) (2 diffs)
• src/com/sun/fortress/tools/FortressAstToConcrete.java (modified) (2 diffs)

trunk/ProjectFortress/astgen/Fortress.ast

@@ -814 +814 @@
                 /**
                  * labeled expression: tuple expression or argument expression
-                 */
-                abstract AbstractTupleExpr(List<Expr> exprs);
-                    /**
-                     * tuple expression
-                     * TupleExpr ::= ( (Expr,)+ Expr )
-                     * e.g.) (1, 2, 5)
-                     */
-                    TupleExpr();
-                    /**
-                     * argument expression
-                     * ArgExpr ::= ( (Expr,)* (Expr...,)? KeywordExpr(, KeywordExpr)* )
-                     *           | ( (Expr,)* Expr... )
-                     *           | TupleExpr
-                     * e.g.) (1, 2, [3 4]..., x = 5)
-                     */
-                    ArgExpr(Option<VarargsExpr> varargs
-                                = Option.<VarargsExpr>none(),
-                            List<KeywordExpr> keywords
-                                = Collections.<KeywordExpr>emptyList(),
-                            boolean inApp = false);
+                 *
+                 * tuple expression
+                 * TupleExpr ::= ( (Expr,)+ Expr )
+                 *
+                 * argument expression
+                 * ArgExpr ::= ( (Expr,)* (Expr...,)? KeywordExpr(, KeywordExpr)* )
+                 *           | ( (Expr,)* Expr... )
+                 *           | TupleExpr
+                 * e.g.) (1, 2, [3 4]..., x = 5)
+                 * e.g.) (1, 2, 5)
+                 */
+                TupleExpr(List<Expr> exprs,
+                          Option<Expr> varargs = Option.<Expr>none(),
+                          List<KeywordExpr> keywords
+                              = Collections.<KeywordExpr>emptyList(),
+                          boolean inApp = false);
                 /**
                  * typecase expression
@@ -2041 +2037 @@
             GeneratorClause(List<Id> bind, Expr init);
             /**
-             * varargs expression used in tuple expressions
-             * Expr...
-             * e.g.) [3 4 5]...
-             */
-            VarargsExpr(Expr varargs);
-            /**
              * keyword type used in tuple types
              * Names must be unqualified.

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

@@ -1025 +1025 @@
         }
 
-        /*
-         * FIXME: Figure out what type these should have and make them propogate ast
-         */
-        @Override
-        public TypeCheckerResult forArgExprOnly(ArgExpr that, Option<TypeCheckerResult> exprType_result,
-                        List<TypeCheckerResult> exprs_result,
-                        Option<TypeCheckerResult> varargs_result,
-                        List<TypeCheckerResult> keywords_result) {
-                if (varargs_result.isSome()) {
-                        return TypeCheckerResult.compose(that,
-                                        subtypeChecker,
-                                        TypeCheckerResult.compose(that, subtypeChecker, exprs_result),
-                                        TypeCheckerResult.compose(that, subtypeChecker, varargs_result.unwrap()), TypeCheckerResult.compose(that, subtypeChecker, keywords_result));
-                } else {
-                        return TypeCheckerResult.compose(that,
-                                        subtypeChecker,
-                                        TypeCheckerResult.compose(that, subtypeChecker, exprs_result), TypeCheckerResult.compose(that, subtypeChecker, keywords_result));
-                }
-        }
-
         // This case is only called for single element arrays ( e.g., [5] )
         // and not for pieces of ArrayElements
@@ -4104 +4084 @@
         @Override
         public TypeCheckerResult forTupleExprOnly(TupleExpr that, Option<TypeCheckerResult> exprType_result,
-                        List<TypeCheckerResult> exprs_result) {
+                                                  List<TypeCheckerResult> exprs_result,
+                                                  Option<TypeCheckerResult> varargs_result,
+                                                  List<TypeCheckerResult> keywords_result) {
+            if ( varargs_result.isSome() || keywords_result.size() > 0 ) { // ArgExpr
+                /*
+                 * FIXME: Figure out what type these should have and make them propogate ast
+                 */
+                if (varargs_result.isSome()) {
+                        return TypeCheckerResult.compose(that,
+                                        subtypeChecker,
+                                        TypeCheckerResult.compose(that, subtypeChecker, exprs_result),
+                                        TypeCheckerResult.compose(that, subtypeChecker, varargs_result.unwrap()), TypeCheckerResult.compose(that, subtypeChecker, keywords_result));
+                } else {
+                        return TypeCheckerResult.compose(that,
+                                        subtypeChecker,
+                                        TypeCheckerResult.compose(that, subtypeChecker, exprs_result), TypeCheckerResult.compose(that, subtypeChecker, keywords_result));
+                }
+            } else {
                 List<Type> types = new ArrayList<Type>(exprs_result.size());
                 for (TypeCheckerResult r : exprs_result) {
@@ -4123 +4120 @@
                 return TypeCheckerResult.compose(new_node, tuple_type,
                                 subtypeChecker, exprs_result);
+            }
         }
 

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

@@ -70 +70 @@
 import com.sun.fortress.nodes.AbstractNode;
 import com.sun.fortress.nodes.AmbiguousMultifixOpExpr;
-import com.sun.fortress.nodes.ArgExpr;
 import com.sun.fortress.nodes.ArrayComprehension;
 import com.sun.fortress.nodes.ArrayComprehensionClause;
@@ -161 +160 @@
 public class Evaluator extends EvaluatorBase<FValue> {
      boolean debug = false;
-    final private static boolean isArgExpr = false;
 
     public FValue eval(Expr e) {
@@ -261 +259 @@
                 // an Expr in this context.  Yet it isn't an Expr, and
                 // we can't pass the lhses to the numerous functions
-                // which expect a List<Expr>---for example ArgExpr
+                // which expect a List<Expr>---for example,
+                // TupleExpr with a varargs or keywords
                 // or evalExprListParallel!  This is extremely annoying!
                 List<FValue> lhsComps = new ArrayList<FValue>(lhsSize);
@@ -1605 +1604 @@
     }
 
-    public FValue forArgExpr(ArgExpr x) {
-        List<Expr> exprs = x.getExprs();
-        /*
-        if (!isArgExpr)
-            error(x, "Tuples are not allowed to have varargs or keyword expressions.");
-        */
-        return FTuple.make(evalExprListParallel(exprs));
-    }
-
     public FValue forTupleExpr(TupleExpr x) {
-        List<Expr> exprs = x.getExprs();
-        return FTuple.make(evalExprListParallel(exprs));
+        if ( x.getVarargs().isSome() || x.getKeywords().size() > 0 ) { // ArgExpr
+            List<Expr> exprs = x.getExprs();
+            return FTuple.make(evalExprListParallel(exprs));
+        } else {
+            List<Expr> exprs = x.getExprs();
+            return FTuple.make(evalExprListParallel(exprs));
+        }
     }
 

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

@@ -52 +52 @@
 import com.sun.fortress.nodes.SubscriptExpr;
 import com.sun.fortress.nodes.Enclosing;
-import com.sun.fortress.nodes.ArgExpr;
 import com.sun.fortress.nodes.TupleExpr;
 import com.sun.fortress.nodes.Type;
@@ -273 +272 @@
 
     /* (non-Javadoc)
-     * @see com.sun.fortress.interpreter.nodes.NodeVisitor#forArgExpr(com.sun.fortress.interpreter.nodes.ArgExpr)
-     */
-    @Override
-    public Voidoid forArgExpr(ArgExpr x) {
+     * @see com.sun.fortress.interpreter.nodes.NodeVisitor#forTupleExpr(com.sun.fortress.interpreter.nodes.TupleExpr)
+     */
+    @Override
+    public Voidoid forTupleExpr(TupleExpr x) {
         if (!(value instanceof FTuple)) {
             error(x, evaluator.e, errorMsg("RHS yields non-tuple ", value));
@@ -289 +288 @@
         return null;
     }
-
-    /* (non-Javadoc)
-     * @see com.sun.fortress.interpreter.nodes.NodeVisitor#forTupleExpr(com.sun.fortress.interpreter.nodes.TupleExpr)
-     */
-    @Override
-    public Voidoid forTupleExpr(TupleExpr x) {
-        if (!(value instanceof FTuple)) {
-            error(x, evaluator.e, errorMsg("RHS yields non-tuple ", value));
-        }
-        FTuple t = (FTuple)value;
-        Iterator<FValue> rhsIterator = t.getVals().iterator();
-        for (Expr lhs : x.getExprs()) {
-            // TODO: arity matching and exotic tuple types.
-            lhs.accept(new LHSEvaluator(evaluator, rhsIterator.next()));
-        }
-
-        return null;
-    }
 }

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

@@ -32 +32 @@
 import com.sun.fortress.nodes.LValue;
 import com.sun.fortress.nodes.SubscriptExpr;
-import com.sun.fortress.nodes.ArgExpr;
 import com.sun.fortress.nodes.TupleExpr;
 import com.sun.fortress.nodes.VarRef;
@@ -125 +124 @@
 
     /* (non-Javadoc)
-     * @see com.sun.fortress.interpreter.nodes.NodeVisitor#forArgExpr(com.sun.fortress.interpreter.nodes.ArgExpr)
-     */
-    @Override
-    public Lhs forArgExpr(ArgExpr x) {
-        return NI.nyi("nested tuple in LHS of binding");
-    }
-
-    /* (non-Javadoc)
      * @see com.sun.fortress.interpreter.nodes.NodeVisitor#forTupleExpr(com.sun.fortress.interpreter.nodes.TupleExpr)
      */

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

@@ -762 +762 @@
                     e.getFinallyClause());
         }
-        public Expr forArgExpr(ArgExpr e) {
-            return new ArgExpr(e.getSpan(), true, e.getExprs(), e.getVarargs());
-        }
         public Expr forTupleExpr(TupleExpr e) {
-            return new TupleExpr(e.getSpan(), true, e.getExprs());
+            return new TupleExpr(e.getSpan(), true, e.getExprs(), e.getVarargs(), e.getKeywords());
         }
         public Expr forTypecase(Typecase e) {

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

@@ -186 +186 @@
      a3:KeywordExpr a4s:(w comma w KeywordExpr)* w closeparen
      { List<Expr> es = a1s.list();
-       Option<VarargsExpr> vs = ((a2 != null) ?
-                              Option.some(new VarargsExpr(a2.getSpan(), a2)) :
-                              Option.<VarargsExpr>none());
+       Option<Expr> vs = ((a2 != null) ? Option.some(a2)
+                                       : Option.<Expr>none());
        List<KeywordExpr> ks = new ArrayList<KeywordExpr>();
        ks.add(a3);
@@ -194 +193 @@
            ks.add(b);
        }
-       yyValue = new ArgExpr(createSpan(yyStart,yyCount), false, es, vs, ks);
+       yyValue = new TupleExpr(createSpan(yyStart,yyCount), false, es, vs, ks);
      }
    / openparen w a1s:(Expr w comma w)* a2:Expr w ellipses w closeparen
-     { Option<VarargsExpr> vs = Option.some(new VarargsExpr(a2.getSpan(), a2));
-       yyValue = new ArgExpr(createSpan(yyStart,yyCount),false,a1s.list(),vs);
+     { Option<Expr> vs = Option.some(a2);
+       yyValue = new TupleExpr(createSpan(yyStart,yyCount),false,a1s.list(),vs);
      }
    / TupleExpr ;

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

@@ -1284 +1284 @@
 
     @Override public String forTupleExprOnly(TupleExpr that, Option<String> exprType_result,
-                                             List<String> exprs_result) {
-        if ( exprs_result.size() == 1 )
-            return handleParen( exprs_result.get(0),
-                                that.isParenthesized() );
-        else {
+                                             List<String> exprs_result,
+                                             Option<String> varargs_result,
+                                             List<String> keywords_result) {
+        if ( varargs_result.isSome() || keywords_result.size() > 0 ) { // ArgExpr
             StringBuilder s = new StringBuilder();
 
             s.append( "(" );
-            s.append( join(exprs_result, ", ") );
+            int exprs_size = exprs_result.size();
+            int varargs_size = (varargs_result.isSome()) ? 1 : 0;
+            int keywords_size = keywords_result.size();
+            s.append( join(exprs_result, ", " ) );
+            if ( varargs_size == 1 ) {
+                if ( exprs_size > 0 )
+                    s.append( ", " );
+                s.append( varargs_result.unwrap() );
+                s.append( "..." );
+            }
+            if ( keywords_size > 0 ) {
+                if ( exprs_size + varargs_size > 0)
+                    s.append( ", " );
+                s.append( join(keywords_result, ", ") );
+            }
             s.append( ")" );
 
             return s.toString();
-        }
-    }
-
-    @Override public String forArgExprOnly(ArgExpr that, Option<String> exprType_result,
-                                           List<String> exprs_result,
-                                           Option<String> varargs_result,
-                                           List<String> keywords_result) {
-        StringBuilder s = new StringBuilder();
-
-        s.append( "(" );
-        int exprs_size = exprs_result.size();
-        int varargs_size = (varargs_result.isSome()) ? 1 : 0;
-        int keywords_size = keywords_result.size();
-        s.append( join(exprs_result, ", " ) );
-        if ( varargs_size == 1 ) {
-            if ( exprs_size > 0 )
-                s.append( ", " );
-            s.append( varargs_result.unwrap() );
-        }
-        if ( keywords_size > 0 ) {
-            if ( exprs_size + varargs_size > 0)
-                s.append( ", " );
-            s.append( join(keywords_result, ", ") );
-        }
-        s.append( ")" );
-
-        return s.toString();
+        } else {
+            if ( exprs_result.size() == 1 )
+                return handleParen( exprs_result.get(0),
+                                    that.isParenthesized() );
+            else {
+                StringBuilder s = new StringBuilder();
+
+                s.append( "(" );
+                s.append( join(exprs_result, ", ") );
+                s.append( ")" );
+
+                return s.toString();
+            }
+        }
     }
 
@@ -2914 +2914 @@
     }
 
-    @Override public String forVarargsExprOnly(VarargsExpr that,
-                                               String varargs_result) {
-        return varargs_result + "...";
-    }
-
     @Override public String forKeywordTypeOnly(KeywordType that,
                                                String name_result,