Changeset 3198

Show
Ignore:
Timestamp:
12/11/08 15:16:18 (12 months ago)
Author:
sukyoungryu
Message:

[ast refactoring] Removed optional fields of ArrayComprehension?, Accumulator, BigOpApp?, Exit, FnExpr?, LocalVarDecl?, and SubscriptExpr?.

Location:
trunk/ProjectFortress
Files:
9 modified

Legend:

Unmodified
Added
Removed

  • trunk/ProjectFortress/astgen/Fortress.ast

    r3193 r3198  
    642642                 * comprehension or accumulator 
    643643                 */ 
    644                 abstract BigOpApp(List<StaticArg> staticArgs 
    645                                       = Collections.<StaticArg>emptyList()); 
     644                abstract BigOpApp(List<StaticArg> staticArgs); 
    646645                    /** 
    647646                     * summation and other reduction expression 
    … …  
    674673                 * Targets must be unqualified. 
    675674                 */ 
    676                 Exit(Option<Id> target = Option.<Id>none(), 
    677                      Option<Expr> returnExpr = Option.<Expr>none()); 
     675                Exit(Option<Id> target, Option<Expr> returnExpr); 
    678676                /** 
    679677                 * spawn expression 
    … …  
    700698                 * e.g.) fn x => x + 2 
    701699                 */ 
    702                 FnExpr(IdOrOpOrAnonymousName name = new AnonymousFnName(in_span), 
    703                        List<StaticParam> staticParams 
    704                            = Collections.<StaticParam>emptyList(), 
    705                        List<Param> params, 
    706                        Option<Type> returnType 
    707                            = Option.<Type>none(), 
    708                        Option<WhereClause> whereClause 
    709                            = Option.<WhereClause>none(), 
    710                        Option<List<BaseType>> throwsClause 
    711                            = Option.<List<BaseType>>none(), 
    712                        Expr body) 
     700                FnExpr(IdOrOpOrAnonymousName name, List<StaticParam> staticParams, 
     701                       List<Param> params, Option<Type> returnType, 
     702                       Option<WhereClause> whereClause, 
     703                       Option<List<BaseType>> throwsClause, Expr body) 
    713704                      implements Applicable; 
    714705                /** 
    … …  
    743734                     * e.g.) localVar x = 3 
    744735                     */ 
    745                     LocalVarDecl(List<LValue> lhs, 
    746                                  Option<Expr> rhs = Option.<Expr>none()); 
     736                    LocalVarDecl(List<LValue> lhs, Option<Expr> rhs); 
    747737                /** 
    748738                 * expression that is simple or using operators 
    … …  
    755745                     * e.g.) a[i] 
    756746                     */ 
    757                     SubscriptExpr(Expr obj, List<Expr> subs, 
    758                                   Option<Op> op = Option.<Op>none(), 
    759                                   List<StaticArg> staticArgs 
    760                                       = Collections.<StaticArg>emptyList()) 
    761                                   implements Lhs; 
     747                    SubscriptExpr(Expr obj, List<Expr> subs, Option<Op> op, 
     748                                  List<StaticArg> staticArgs) implements Lhs; 
    762749                    /** 
    763750                     * primary expression 

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

    r3197 r3198  
    11711171            error("Exit occurs outside of a label", that); 
    11721172        } 
    1173         Exit newExit = new Exit(that.getSpan(), that.isParenthesized(), exprType_result, target, with); 
     1173        Exit newExit = ExprFactory.makeExit(that.getSpan(), that.isParenthesized(), 
     1174                                            exprType_result, target, with); 
    11741175        if (newExit.equals(that)) { 
    11751176            return that; 

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

    r3193 r3198  
    21962196                } 
    21972197 
    2198                 Exit new_node = new Exit(that.getSpan(), 
     2198                Exit new_node = ExprFactory.makeExit(that.getSpan(), 
    21992199                                that.isParenthesized(), 
    22002200                                Option.<Type>some(Types.BOTTOM), 
    … …  
    24412441                ArrowType arr = NodeFactory.makeArrowType(FortressUtil.spanTwo(domain, return_type), 
    24422442                                domain, return_type); 
    2443                 FnExpr new_node = new FnExpr(that.getSpan(), 
     2443                FnExpr new_node = ExprFactory.makeFnExpr(that.getSpan(), 
    24442444                                that.isParenthesized(), 
     2445                                that.getExprType(), 
    24452446                                that.getName(), 
    24462447                                that.getStaticParams(), 
    … …  
    30003001                                        body_results.get(body_results.size()-1).type(); 
    30013002 
    3002                                 LocalVarDecl new_node = new LocalVarDecl(that.getSpan(), 
     3003                                LocalVarDecl new_node = ExprFactory.makeLocalVarDecl(that.getSpan(), 
    30033004                                                that.isParenthesized(), 
    30043005                                                body_type, 

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

    r3192 r3198  
    11231123 
    11241124        List<Param> params = Collections.emptyList(); 
    1125         FnExpr fnExpr = new FnExpr(sp, params, (Expr) rewrittenExpr); 
     1125        FnExpr fnExpr = ExprFactory.makeFnExpr(sp, params, (Expr) rewrittenExpr); 
    11261126 
    11271127        return visitNode(ExprFactory.makeTightJuxt(s.getSpan(), fn, fnExpr)); 

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

    r3193 r3198  
    548548    } 
    549549 
     550    public static Expr makeSubscripting(Span span, 
     551                                        String left, String right, 
     552                                        Expr base, List<Expr> args, 
     553                                        List<StaticArg> sargs) { 
     554        return makeSubscripting(span, base, left, right, args, sargs); 
     555    } 
     556 
     557    public static Expr makeSubscripting(Span span, Expr base, String open, 
     558                                        String close, List<Expr> args, 
     559                                        List<StaticArg> sargs) { 
     560        Op op = NodeFactory.makeEnclosing(span, open, close); 
     561        List<Expr> es; 
     562        if (args == null) es = FortressUtil.emptyExprs(); 
     563        else              es = args; 
     564        return makeSubscriptExpr(span, base, es, Option.<Op>some(op), sargs); 
     565    } 
     566 
     567    public static SubscriptExpr makeSubscriptExpr(Span span, Expr obj, 
     568                                                  List<Expr> subs) { 
     569        return makeSubscriptExpr(span, obj, subs, Option.<Op>none()); 
     570    } 
     571 
     572    public static SubscriptExpr makeSubscriptExpr(Span span, Expr obj, 
     573                                                  List<Expr> subs, 
     574                                                  Option<Op> op) { 
     575        return makeSubscriptExpr(span, obj, subs, op, 
     576                                 Collections.<StaticArg>emptyList()); 
     577    } 
     578 
     579    public static SubscriptExpr makeSubscriptExpr(Span span, Expr obj, 
     580                                                  List<Expr> subs, 
     581                                                  Option<Op> op, 
     582                                                  List<StaticArg> sargs) { 
     583        return makeSubscriptExpr(span, false, Option.<Type>none(), obj, 
     584                                 Useful.immutableTrimmedList(subs), op, sargs); 
     585    } 
     586 
     587    public static SubscriptExpr makeSubscriptExpr(Span span, 
     588                                                  boolean parenthesized, 
     589                                                  Option<Type> exprType, 
     590                                                  Expr obj, List<Expr> subs, 
     591                                                  Option<Op> op, 
     592                                                  List<StaticArg> staticArgs) { 
     593        return new SubscriptExpr(span, parenthesized, exprType, obj, subs, op, 
     594                                 staticArgs); 
     595    } 
     596 
     597    public static LocalVarDecl makeLocalVarDecl(Id p, Expr _r, Expr _body_expr) { 
     598        List<Expr> _body = new ArrayList<Expr>(1); 
     599        List<LValue> _lhs = new ArrayList<LValue>(1); 
     600        Option<Expr> _rhs = Option.some(_r); 
     601        _body.add(_body_expr); 
     602        _lhs.add(NodeFactory.makeLValue(p.getSpan(), p)); 
     603        return makeLocalVarDecl(FortressUtil.spanTwo(p, _r), _body, _lhs, _rhs); 
     604    } 
     605 
     606    public static LocalVarDecl makeLocalVarDecl(Span sp, Id p, Expr _r, Expr _body_expr) { 
     607        List<Expr> _body = new ArrayList<Expr>(1); 
     608        List<LValue> _lhs = new ArrayList<LValue>(1); 
     609        Option<Expr> _rhs = Option.some(_r); 
     610        _body.add(_body_expr); 
     611        _lhs.add(NodeFactory.makeLValue(sp, p)); 
     612        return makeLocalVarDecl(sp, _body, _lhs, _rhs); 
     613    } 
     614 
     615    public static LocalVarDecl makeLocalVarDecl(Span sp, List<LValue> lhs, Expr _r, Expr _body_expr) { 
     616        List<Expr> _body = new ArrayList<Expr>(1); 
     617        Option<Expr> _rhs = Option.some(_r); 
     618        _body.add(_body_expr); 
     619        return makeLocalVarDecl(sp, _body, lhs, _rhs); 
     620    } 
     621 
     622    public static LocalVarDecl makeLocalVarDecl(Span span, List<LValue> lvs, 
     623                                                Expr expr) { 
     624        return makeLocalVarDecl(span, lvs, Option.<Expr>some(expr)); 
     625    } 
     626 
     627    public static LocalVarDecl makeLocalVarDecl(Span span, List<LValue> lvs) { 
     628        return makeLocalVarDecl(span, lvs, Option.<Expr>none()); 
     629    } 
     630 
     631    public static LocalVarDecl makeLocalVarDecl(Span span, List<LValue> lvs, 
     632                                                Option<Expr> expr) { 
     633        return makeLocalVarDecl(span, Collections.<Expr>emptyList(), lvs, expr); 
     634    } 
     635 
     636    public static LocalVarDecl makeLocalVarDecl(Span sp, List<LValue> lhs, 
     637                                                Expr _r, List<Expr> _body) { 
     638        Option<Expr> _rhs = Option.some(_r); 
     639        return makeLocalVarDecl(sp, _body, lhs, _rhs); 
     640    } 
     641 
     642    public static LocalVarDecl makeLocalVarDecl(Span span, 
     643                                                List<Expr> body, 
     644                                                List<LValue> lhs, 
     645                                                Option<Expr> rhs) { 
     646        return makeLocalVarDecl(span, false, Option.<Type>none(), body, lhs, rhs); 
     647    } 
     648 
     649    public static LocalVarDecl makeLocalVarDecl(Span span, 
     650                                                boolean parenthesized, 
     651                                                Option<Type> exprType, 
     652                                                List<Expr> body, 
     653                                                List<LValue> lhs, 
     654                                                Option<Expr> rhs) { 
     655        return new LocalVarDecl(span, parenthesized, exprType, body, lhs, rhs); 
     656    } 
     657 
     658    public static FnExpr makeFnExpr(Span span, 
     659                                    List<Param> params, 
     660                                    Expr body) { 
     661        return makeFnExpr(span, params, Option.<Type>none(), 
     662                          Option.<List<BaseType>>none(), body); 
     663    } 
     664 
     665    public static FnExpr makeFnExpr(Span span, List<Param> params, 
     666                                    Option<Type> returnType, Expr body) { 
     667        return makeFnExpr(span, params, returnType, 
     668                          Option.<List<BaseType>>none(), body); 
     669    } 
     670 
     671    public static FnExpr makeFnExpr(Span span, List<Param> params, 
     672                                    Option<Type> returnType, 
     673                                    Option<List<BaseType>> throwsClause, 
     674                                    Expr body) { 
     675        return makeFnExpr(span, false, Option.<Type>none(), 
     676                          new AnonymousFnName(span), 
     677                          Collections.<StaticParam>emptyList(), params, 
     678                          returnType, Option.<WhereClause>none(), 
     679                          throwsClause, body); 
     680    } 
     681 
     682    public static FnExpr makeFnExpr(Span span, 
     683                                    boolean parenthesized, 
     684                                    Option<Type> exprType, 
     685                                    IdOrOpOrAnonymousName name, 
     686                                    List<StaticParam> staticParams, 
     687                                    List<Param> params, 
     688                                    Option<Type> returnType, 
     689                                    Option<WhereClause> whereClause, 
     690                                    Option<List<BaseType>> throwsClause, 
     691                                    Expr body) { 
     692        return new FnExpr(span, parenthesized, exprType, name, staticParams, 
     693                          params, returnType, whereClause, throwsClause, body); 
     694    } 
     695 
     696    public static Exit makeExit(Span span, 
     697                                Option<Type> typeOp, 
     698                                Option<Id> targetOp, 
     699                                Expr retExpr) { 
     700        return makeExit(span, false, typeOp, targetOp, Option.<Expr>some(retExpr)); 
     701    } 
     702 
     703    public static Exit makeExit(Span span, 
     704                                Option<Type> typeOp, 
     705                                Option<Id> targetOp, 
     706                                Option<Expr> retExpr) { 
     707        return makeExit(span, false, typeOp, targetOp, retExpr); 
     708    } 
     709 
     710    public static Exit makeExit(Span span, 
     711                                boolean parenthesized, 
     712                                Option<Type> typeOp, 
     713                                Option<Id> targetOp, 
     714                                Option<Expr> retExpr) { 
     715        return new Exit(span, parenthesized, typeOp, targetOp, retExpr); 
     716    } 
     717 
     718    public static ArrayComprehension makeArrayComprehension(Span span, 
     719                                                            List<StaticArg> staticArgs, 
     720                                                            List<ArrayComprehensionClause> clauses) { 
     721        return makeArrayComprehension(span, false, Option.<Type>none(), 
     722                                      staticArgs, clauses); 
     723    } 
     724 
     725    public static ArrayComprehension makeArrayComprehension(Span span, 
     726                                                            boolean parenthesized, 
     727                                                            Option<Type> exprType, 
     728                                                            List<StaticArg> staticArgs, 
     729                                                            List<ArrayComprehensionClause> clauses) { 
     730        return new ArrayComprehension(span, parenthesized, exprType, staticArgs, clauses); 
     731    } 
     732 
     733    public static Accumulator makeAccumulator(Span span, 
     734                                              List<StaticArg> staticArgs, 
     735                                              Op accOp, 
     736                                              List<GeneratorClause> gens, 
     737                                              Expr body) { 
     738        return makeAccumulator(span, false, Option.<Type>none(), staticArgs, 
     739                               accOp, gens, body); 
     740    } 
     741 
     742    public static Accumulator makeAccumulator(Span span, 
     743                                              boolean parenthesized, 
     744                                              Option<Type> exprType, 
     745                                              List<StaticArg> staticArgs, 
     746                                              Op accOp, 
     747                                              List<GeneratorClause> gens, 
     748                                              Expr body) { 
     749        return new Accumulator(span, parenthesized, exprType, staticArgs, 
     750                               accOp, gens, body); 
     751    } 
     752 
    550753    /***************************************************************************************/ 
    551  
    552     public static Exit makeExit(Span span, Option<Type> typeOp, Option<Id> targetOp, Expr retExpr) { 
    553         return new Exit(span, typeOp, targetOp, Option.<Expr>some(retExpr)); 
    554     } 
    555754 
    556755    public static FloatLiteralExpr makeFloatLiteralExpr(Span span, String s) { 
    … …  
    650849    } 
    651850 
    652     /** Alternatively, you can invoke the FnExpr constructor with only these parameters */ 
    653     public static FnExpr makeFnExpr(Span span, List<Param> params, Expr body) { 
    654         return makeFnExpr(span, params, Option.<Type>none(), 
    655                 Option.<List<BaseType>>none(), body); 
    656     } 
    657  
    658     public static FnExpr makeFnExpr(Span span, List<Param> params, 
    659                                     Option<Type> returnType, Expr body) { 
    660         return new FnExpr(span, params, returnType, body); 
    661     } 
    662  
    663     public static FnExpr makeFnExpr(Span span, List<Param> params, 
    664             Option<Type> returnType, 
    665             Option<List<BaseType>> throwsClause, 
    666             Expr body) { 
    667         return new FnExpr(span, false, new AnonymousFnName(span), 
    668                           Collections.<StaticParam>emptyList(), params, 
    669                           returnType, Option.<WhereClause>none(), 
    670                           throwsClause, body); 
    671     } 
    672  
    673  
    674851    public static LetExpr makeLetExpr(final LetExpr let_expr, final List<Expr> body) { 
    675852        return let_expr.accept(new NodeAbstractVisitor<LetExpr>() { 
    … …  
    678855            } 
    679856            public LetExpr forLocalVarDecl(LocalVarDecl expr) { 
    680                 return new LocalVarDecl(expr.getSpan(), false, body, 
    681                                         expr.getLhs(), expr.getRhs()); 
     857                return makeLocalVarDecl(expr.getSpan(), false, Option.<Type>none(), 
     858                                        body, expr.getLhs(), expr.getRhs()); 
    682859            } 
    683860        }); 
    … …  
    724901    public static StringLiteralExpr makeStringLiteralExpr(Span span, String s) { 
    725902        return new StringLiteralExpr(span, s); 
    726     } 
    727  
    728     /** Alternatively, you can invoke the SubscriptExpr constructor without parenthesized or op */ 
    729     public static SubscriptExpr makeSubscriptExpr(Span span, Expr obj, 
    730             List<Expr> subs) { 
    731         return new SubscriptExpr(span, false, obj, subs, 
    732                                  Option.<Op>none(), 
    733                                  Collections.<StaticArg>emptyList()); 
    734     } 
    735  
    736     public static SubscriptExpr makeSubscriptExpr(Span span, Expr obj, 
    737                                                   List<Expr> subs, 
    738                                                   Option<Op> op, 
    739                                                   List<StaticArg> sargs) { 
    740         return new SubscriptExpr(span, false, obj, Useful.immutableTrimmedList(subs), op, sargs); 
    741     } 
    742  
    743     public static SubscriptExpr makeSubscriptExpr(Span span, Expr obj, 
    744                                                   List<Expr> subs, 
    745                                                   Option<Op> op) { 
    746         return new SubscriptExpr(span, false, obj, subs, op, 
    747                 Collections.<StaticArg>emptyList()); 
    748903    } 
    749904 
    … …  
    8481003        body.add(new Block(sp, t, false, true, exprs)); 
    8491004        return new Do(sp, t, body); 
    850     } 
    851  
    852     public static LocalVarDecl makeLocalVarDecl(Id p, Expr _r, Expr _body_expr) { 
    853         List<Expr> _body = new ArrayList<Expr>(1); 
    854         List<LValue> _lhs = new ArrayList<LValue>(1); 
    855         Option<Expr> _rhs = Option.some(_r); 
    856         _body.add(_body_expr); 
    857         _lhs.add(NodeFactory.makeLValue(p.getSpan(), p)); 
    858         return new LocalVarDecl(FortressUtil.spanTwo(p, _r), _body, _lhs, _rhs); 
    859     } 
    860  
    861     public static LocalVarDecl makeLocalVarDecl(Span sp, Id p, Expr _r, Expr _body_expr) { 
    862         List<Expr> _body = new ArrayList<Expr>(1); 
    863         List<LValue> _lhs = new ArrayList<LValue>(1); 
    864         Option<Expr> _rhs = Option.some(_r); 
    865         _body.add(_body_expr); 
    866         _lhs.add(NodeFactory.makeLValue(sp, p)); 
    867         return new LocalVarDecl(sp, _body, _lhs, _rhs); 
    868     } 
    869  
    870     public static LocalVarDecl makeLocalVarDecl(Span sp, List<LValue> lhs, Expr _r, Expr _body_expr) { 
    871         List<Expr> _body = new ArrayList<Expr>(1); 
    872         Option<Expr> _rhs = Option.some(_r); 
    873         _body.add(_body_expr); 
    874         return new LocalVarDecl(sp, _body, lhs, _rhs); 
    875     } 
    876  
    877     public static LocalVarDecl makeLocalVarDecl(Span sp, List<LValue> lhs, 
    878                                                 Expr _r, List<Expr> _body) { 
    879         Option<Expr> _rhs = Option.some(_r); 
    880         return new LocalVarDecl(sp, _body, lhs, _rhs); 
    8811005    } 
    8821006 
    … …  
    10181142        } 
    10191143        public Expr forAccumulator(Accumulator e) { 
    1020             return new Accumulator(e.getSpan(), true, e.getStaticArgs(), 
    1021                     e.getAccOp(), e.getGens(), e.getBody()); 
     1144            return makeAccumulator(e.getSpan(), true, e.getExprType(), 
     1145                                   e.getStaticArgs(), 
     1146                                   e.getAccOp(), e.getGens(), e.getBody()); 
    10221147        } 
    10231148        public Expr forAtomicExpr(AtomicExpr e) { 
    … …  
    10251150        } 
    10261151        public Expr forExit(Exit e) { 
    1027             return new Exit(e.getSpan(), true, e.getExprType() ,e.getTarget(), e.getReturnExpr()); 
     1152            return makeExit(e.getSpan(), true, e.getExprType(), 
     1153                            e.getTarget(), e.getReturnExpr()); 
    10281154        } 
    10291155 
    … …  
    10381164        } 
    10391165        public Expr forFnExpr(FnExpr e) { 
    1040             return new FnExpr(e.getSpan(), true, e.getName(), 
     1166            return makeFnExpr(e.getSpan(), true, e.getExprType(), e.getName(), 
    10411167                              e.getStaticParams(), e.getParams(), 
    10421168                              e.getReturnType(), e.getWhereClause(), 
    … …  
    10471173        } 
    10481174        public Expr forLocalVarDecl(LocalVarDecl e) { 
    1049             return new LocalVarDecl(e.getSpan(), true, e.getBody(), 
    1050                                     e.getLhs(), e.getRhs()); 
     1175            return makeLocalVarDecl(e.getSpan(), true, e.getExprType(), 
     1176                                    e.getBody(), e.getLhs(), e.getRhs()); 
    10511177        } 
    10521178        public Expr forOpExpr(OpExpr e) { 
    … …  
    10931219        } 
    10941220        public Expr forArrayComprehension(ArrayComprehension e) { 
    1095             return new ArrayComprehension(e.getSpan(), true, e.getClauses()); 
     1221            return makeArrayComprehension(e.getSpan(), true, e.getExprType(), 
     1222                                          e.getStaticArgs(), e.getClauses()); 
    10961223        } 
    10971224        public Expr forChainExpr(ChainExpr e) { 
    … …  
    11191246        } 
    11201247        public Expr forOpRef(OpRef e) { 
    1121             return ExprFactory.makeOpRef(e.getSpan(), true, e.getExprType(), 
     1248            return makeOpRef(e.getSpan(), true, e.getExprType(), 
    11221249                                         e.getStaticArgs(), e.getLexicalDepth(), 
    11231250                                         e.getOriginalName(), e.getNames(), 
    … …  
    11251252        } 
    11261253        public Expr forSubscriptExpr(SubscriptExpr e) { 
    1127             return new SubscriptExpr(e.getSpan(), true, e.getObj(), 
    1128                     e.getSubs(), e.getOp(), 
    1129                     e.getStaticArgs()); 
     1254            return makeSubscriptExpr(e.getSpan(), true, e.getExprType(), 
     1255                                     e.getObj(), e.getSubs(), e.getOp(), 
     1256                                     e.getStaticArgs()); 
    11301257        } 
    11311258        public Expr forTemplateGapExpr(TemplateGapExpr e) { 

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

    r3158 r3198  
    326326                                                                    a3s.list()); 
    327327       if (a1 == null) a1 = Collections.<StaticArg>emptyList(); 
    328        yyValue = new ArrayComprehension(createSpan(yyStart,yyCount),a1,clauses); 
     328       yyValue = ExprFactory.makeArrayComprehension(createSpan(yyStart,yyCount),a1,clauses); 
    329329     } 
    330330   / (BIG w)? opencurly a1:StaticArgs? w a2:Entry wr bar wr 
    … …  
    333333       Op opr = NodeFactory.makeEnclosing(span, "BIG {|->", "BIG }"); 
    334334       if (a1 == null) a1 = Collections.<StaticArg>emptyList(); 
    335        yyValue = new Accumulator(createSpan(yyStart,yyCount), a1, opr, a3, a2); 
     335       yyValue = ExprFactory.makeAccumulator(createSpan(yyStart,yyCount), a1, opr, a3, a2); 
    336336     } 
    337337   / (BIG w)? a1:LeftEncloser a2:StaticArgs? w a3:Expr wr bar wr 
    … …  
    341341                                          "BIG " + a5.getText()); 
    342342       if (a2 == null) a2 = Collections.<StaticArg>emptyList(); 
    343        yyValue = new Accumulator(createSpan(yyStart,yyCount), a2, opr, a4, a3); 
     343       yyValue = ExprFactory.makeAccumulator(createSpan(yyStart,yyCount), a2, opr, a4, a3); 
    344344     }; 
    345345 

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

    r3192 r3198  
    466466                   if (a2 == null) ss = Collections.<StaticArg>emptyList(); 
    467467                   else            ss = a2; 
    468                    return FortressUtil.makeSubscripting(span, 
     468                   return ExprFactory.makeSubscripting(span, 
    469469                                                        a1, a4, base, a3, ss); 
    470470               } else return syntaxError(span, 
    … …  
    485485               if (a2 == null) ss = Collections.<StaticArg>emptyList(); 
    486486               else            ss = a2; 
    487                return FortressUtil.makeSubscripting(span, base, a1.getText(), 
    488                                                     a4.getText(), a3, ss); 
     487               return ExprFactory.makeSubscripting(span, base, a1.getText(), 
     488                                                   a4.getText(), a3, ss); 
    489489           }}; 
    490490     }; 
    … …  
    655655     { Option<Id> name = (a1 == null) ? Option.<Id>none() : Option.some(a1); 
    656656       Option<Expr> expr = Option.wrap(a2); 
    657        yyValue = new Exit(createSpan(yyStart,yyCount), false, Option.<Type>none() ,name, expr); 
     657       yyValue = ExprFactory.makeExit(createSpan(yyStart,yyCount), Option.<Type>none(), name, expr); 
    658658     } 
    659659   / <ErrorProduction1> 
    … …  
    670670           yyValue = ExprFactory.makeOpExpr(span, a1, a4, a2); 
    671671       } else 
    672            yyValue = new Accumulator(span, a2, a1, a3, a4); 
     672           yyValue = ExprFactory.makeAccumulator(span, a2, a1, a3, a4); 
    673673     } 
    674674   / <ErrorProduction2> 

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

    r3186 r3198  
    116116           a2 = FortressUtil.setMutable(a2, createSpan(yyStart,3)); 
    117117       } 
    118        yyValue = FortressUtil.mkLocalVarDecl(createSpan(yyStart,yyCount), a2, a3); 
     118       yyValue = ExprFactory.makeLocalVarDecl(createSpan(yyStart,yyCount), a2, a3); 
    119119     } 
    120120   / a1:(var w)? a2:NoNewlineVarWTypes s colonequals w a3:NoNewlineExpr 
    121121     { a2 = FortressUtil.setMutable(a2, createSpan(yyStart,3)); 
    122        yyValue = FortressUtil.mkLocalVarDecl(createSpan(yyStart,yyCount), a2, a3); 
     122       yyValue = ExprFactory.makeLocalVarDecl(createSpan(yyStart,yyCount), a2, a3); 
    123123     } 
    124124   / a1:(var w)? a2:NoNewlineVarWTypes 
    125125     { if (a1 != null) a2 = FortressUtil.setMutable(a2, createSpan(yyStart,3)); 
    126        yyValue = FortressUtil.mkLocalVarDecl(createSpan(yyStart,yyCount), a2); 
     126       yyValue = ExprFactory.makeLocalVarDecl(createSpan(yyStart,yyCount), a2); 
    127127     } 
    128128   / a1:VarWoTypes s equals w a2:NoNewlineExpr 
    129      { yyValue = FortressUtil.mkLocalVarDecl(createSpan(yyStart,yyCount),a1,a2); } 
     129     { yyValue = ExprFactory.makeLocalVarDecl(createSpan(yyStart,yyCount),a1,a2); } 
    130130   / a1:(var w)? a2:VarWoTypes s colon s a3:NoNewlineType s ellipses a4:(s InitVal)? 
    131131     { Option<Expr> init; 
    … …  
    144144           } 
    145145       } 
    146        yyValue = FortressUtil.mkLocalVarDecl(createSpan(yyStart,yyCount), a2, 
     146       yyValue = ExprFactory.makeLocalVarDecl(createSpan(yyStart,yyCount), a2, 
    147147                                             init); 
    148148     } 
    … …  
    167167           } 
    168168       } 
    169        yyValue = FortressUtil.mkLocalVarDecl(span, a2, init); 
     169       yyValue = ExprFactory.makeLocalVarDecl(span, a2, init); 
    170170     } 
    171171   / <ErrorProduction> var w VarWoTypes s equals w NoNewlineExpr 

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

    r3193 r3198  
    149149            public Option<List<Type>> forNone() { return Option.<List<Type>>none(); } 
    150150        }); 
    151     } 
    152  
    153     public static Expr makeSubscripting(Span span, 
    154                                         String left, String right, 
    155                                         Expr base, List<Expr> args, 
    156                                         List<StaticArg> sargs) { 
    157         return makeSubscripting(span, base, left, right, args, sargs); 
    158     } 
    159  
    160     public static Expr makeSubscripting(Span span, Expr base, String open, 
    161                                         String close, List<Expr> args, 
    162                                         List<StaticArg> sargs) { 
    163         Op op = NodeFactory.makeEnclosing(span, open, close); 
    164         List<Expr> es; 
    165         if (args == null) es = FortressUtil.emptyExprs(); 
    166         else              es = args; 
    167         return new SubscriptExpr(span, false, base, es, Option.<Op>some(op), sargs); 
    168151    } 
    169152 
    … …  
    586569                                      throws_, where_, contract, 
    587570                                      Option.<Expr>some(expr)); 
    588     } 
    589  
    590     public static LocalVarDecl mkLocalVarDecl(Span span, List<LValue> lvs, 
    591                                               Option<Expr> expr) { 
    592         return new LocalVarDecl(span, false, emptyExprs(), lvs, expr); 
    593     } 
    594     public static LocalVarDecl mkLocalVarDecl(Span span, List<LValue> lvs, 
    595                                               Expr expr) { 
    596         return new LocalVarDecl(span, false, emptyExprs(), lvs, 
    597                                 Option.<Expr>some(expr)); 
    598     } 
    599     public static LocalVarDecl mkLocalVarDecl(Span span, List<LValue> lvs) { 
    600         return new LocalVarDecl(span, false, emptyExprs(), lvs, 
    601                                 Option.<Expr>none()); 
    602571    } 
    603572