Changeset 3132

Show
Ignore:
Timestamp:
12/02/08 09:23:26 (12 months ago)
Author:
sukyoungryu
Message:

[ast refactoring] Merged OpName?, Op, and Enclosing

Location:
trunk/ProjectFortress
Files:
43 modified

Legend:

Unmodified
Added
Removed

  • trunk/ProjectFortress/astgen/Fortress.ast

    r3125 r3132  
    349349                 * Overloading specification 
    350350                 */ 
    351                 _RewriteFnOverloadDecl(IdOrOpName name, List<IdOrOpName> fns); 
     351                _RewriteFnOverloadDecl(IdOrOp name, List<IdOrOp> fns); 
    352352                /* the list of object expressions is a temporary hack to allow 
    353353                   progress towards earlier rewriting and caching of ASTs. -- DRC */ 
    … …  
    841841                     * e.g.) PROD[i <- 1:n] i 
    842842                     */ 
    843                     Accumulator(OpName accOp, List<GeneratorClause> gens, Expr body); 
     843                    Accumulator(Op accOp, List<GeneratorClause> gens, Expr body); 
    844844                    /** 
    845845                     * array comprehension 
    … …  
    952952                     */ 
    953953                    SubscriptExpr(Expr obj, List<Expr> subs, 
    954                                   Option<Enclosing> op = Option.<Enclosing>none(), 
     954                                  Option<Op> op = Option.<Op>none(), 
    955955                                  List<StaticArg> staticArgs 
    956956                                      = Collections.<StaticArg>emptyList()) 
    … …  
    10841084                             * one of which may be the correct insantiation. 
    10851085                             */ 
    1086                             OpRef(OpName originalName, 
    1087                                   List<OpName> ops = Collections.<OpName>singletonList(in_originalName), 
     1086                            OpRef(Op originalName, 
     1087                                  List<Op> ops = Collections.<Op>singletonList(in_originalName), 
    10881088                                  Option<List<_RewriteOpRefOverloading>> overloadings 
    10891089                                      = Option.<List<_RewriteOpRefOverloading>>none()); 
    … …  
    18811881                     * identifier or operator name 
    18821882                     */ 
    1883                     abstract IdOrOpName(); 
     1883                    abstract IdOrOp(String text); 
    18841884                        /** 
    18851885                         * identifier name 
    18861886                         * e.g.) hashCode 
    18871887                         */ 
    1888                         Id(String text); 
     1888                        Id(); 
    18891889                        /** 
    18901890                         * operator name 
    1891                          */ 
    1892                         abstract OpName(); 
    1893                             /** 
    1894                              * non-enclosing operator 
    1895                              * e.g.) COMPOSE 
    1896                              * e.g.) === 
    1897                              */ 
    1898                             Op(String text, Fixity fixity); 
    1899                             /** 
    1900                              * pair of enclosing operators 
    1901                              * Opening and closing Ops must be unqualified. 
    1902                              * EncloserPair ::= (LeftEncloser | Encloser) 
    1903                              *                    (RightEncloser | Encloser) 
    1904                              * e.g.) </ /> 
    1905                              */ 
    1906                             Enclosing(Op open, Op close); 
     1891                         * 
     1892                         * Opening and closing Ops must be unqualified. 
     1893                         * EncloserPair ::= (LeftEncloser | Encloser) 
     1894                         *                    (RightEncloser | Encloser) 
     1895                         * e.g.) COMPOSE 
     1896                         * e.g.) === 
     1897                         * e.g.) </ /> 
     1898                         */ 
     1899                        Op(Fixity fixity, boolean enclosing); 
    19071900                    /** 
    19081901                     * anonymous name; used internally 
    … …  
    20652058                     * e.g.) [3, 4] 
    20662059                     */ 
    2067                     SubscriptingMI(Enclosing op, List<Expr> exprs, 
     2060                    SubscriptingMI(Op op, List<Expr> exprs, 
    20682061                                   List<StaticArg> staticArgs); 
    20692062            /** 

  • trunk/ProjectFortress/src/com/sun/fortress/compiler/OverloadRewriteVisitor.java

    r3101 r3132  
    3333 
    3434    final private Map<String, List<Id>> overloadedFunctions = new HashMap<String, List<Id>>(); 
    35     final private Map<String, List<OpName>> overloadedOperators = new HashMap<String, List<OpName>>(); 
     35    final private Map<String, List<Op>> overloadedOperators = new HashMap<String, List<Op>>(); 
    3636 
    3737    @Override 
    … …  
    6565    @Override 
    6666    public Node forOpRefOnly(OpRef that, Option<Type> exprType_result, 
    67                              List<StaticArg> staticArgs, OpName originalName, List<OpName> ops, 
     67                             List<StaticArg> staticArgs, Op originalName, List<Op> ops, 
    6868                             Option<List<_RewriteOpRefOverloading>> overloadings) { 
    6969        if (ops.size() > 1) { 
    70             Collections.<OpName>sort(ops, NodeComparator.opNameComparer); 
     70            Collections.<Op>sort(ops, NodeComparator.opNameComparer); 
    7171            StringBuffer buffer = new StringBuffer(); 
    7272            buffer.append(NodeUtil.nameString(originalName)); 
    … …  
    8383                overloadedOperators.put(overloadingName, ops); 
    8484            } 
    85             OpName overloadingOpName = NodeFactory.makeOp(NodeFactory.makeSpan(that), overloadingName); 
    86             ops = Collections.unmodifiableList(Collections.singletonList(overloadingOpName)); 
     85            Op overloadingOp = NodeFactory.makeOp(NodeFactory.makeSpan(that), overloadingName); 
     86            ops = Collections.unmodifiableList(Collections.singletonList(overloadingOp)); 
    8787        } 
    8888        return super.forOpRefOnly(that, exprType_result, staticArgs, originalName, ops, 
    … …  
    9595    } 
    9696 
    97     public Map<String, List<OpName>> getOverloadedOperators() { 
     97    public Map<String, List<Op>> getOverloadedOperators() { 
    9898        return overloadedOperators; 
    9999    } 

  • trunk/ProjectFortress/src/com/sun/fortress/compiler/OverloadRewriter.java

    r3071 r3132  
    2929import com.sun.fortress.nodes.Decl; 
    3030import com.sun.fortress.nodes.Id; 
    31 import com.sun.fortress.nodes.IdOrOpName; 
    32 import com.sun.fortress.nodes.OpName; 
     31import com.sun.fortress.nodes.IdOrOp; 
     32import com.sun.fortress.nodes.Op; 
    3333import com.sun.fortress.nodes._RewriteFnOverloadDecl; 
    3434import com.sun.fortress.nodes_util.NodeFactory; 
    … …  
    7777        Map<String, List<Id>> overloadedFunctions = visitor.getOverloadedFunctions(); 
    7878        for (Map.Entry<String, List<Id>> overload : overloadedFunctions.entrySet()) { 
    79             List<IdOrOpName> overloadings = new ArrayList<IdOrOpName>(overload.getValue()); 
     79            List<IdOrOp> overloadings = new ArrayList<IdOrOp>(overload.getValue()); 
    8080            Id overloadingId = NodeFactory.makeId(overload.getKey()); 
    8181            _RewriteFnOverloadDecl newDecl = new _RewriteFnOverloadDecl(span, overloadingId, overloadings); 
    … …  
    8484 
    8585        // Add rewritten overloaded operators 
    86         Map<String, List<OpName>> overloadedOperators = visitor.getOverloadedOperators(); 
    87         for (Map.Entry<String, List<OpName>> overload : overloadedOperators.entrySet()) { 
    88             List<IdOrOpName> overloadings = new ArrayList<IdOrOpName>(overload.getValue()); 
    89             OpName overloadingOpName = NodeFactory.makeOp(NodeFactory.makeSpan("impossible", overload.getValue()), overload.getKey()); 
    90             _RewriteFnOverloadDecl newDecl = new _RewriteFnOverloadDecl(span, overloadingOpName, overloadings); 
     86        Map<String, List<Op>> overloadedOperators = visitor.getOverloadedOperators(); 
     87        for (Map.Entry<String, List<Op>> overload : overloadedOperators.entrySet()) { 
     88            List<IdOrOp> overloadings = new ArrayList<IdOrOp>(overload.getValue()); 
     89            Op overloadingOp = NodeFactory.makeOp(NodeFactory.makeSpan("impossible", overload.getValue()), overload.getKey()); 
     90            _RewriteFnOverloadDecl newDecl = new _RewriteFnOverloadDecl(span, overloadingOp, overloadings); 
    9191            decls.add(newDecl); 
    9292        } 

  • trunk/ProjectFortress/src/com/sun/fortress/compiler/Types.java

    r3123 r3132  
    325325     * TotalOperatorOrder[\A,<,<=,>=,>,Op] 
    326326     */ 
    327  public static Type makeTotalOperatorOrder(Type A, OpName op) { 
     327 public static Type makeTotalOperatorOrder(Type A, Op op) { 
    328328//  NodeFactory.makeTraitType(makeId("TotalOperater"), sargs) 
    329329//  NodeFactory.makeOpArg("whoa"); 

  • trunk/ProjectFortress/src/com/sun/fortress/compiler/desugarer/FreeNameCollector.java

    r3123 r3132  
    490490        recurOnOptionOfType(that.getExprType()); 
    491491        recur(that.getOriginalName()); 
    492         recurOnListOfOpName(that.getOps()); 
     492        recurOnListOfOp(that.getOps()); 
    493493        recurOnListOfStaticArg(that.getStaticArgs()); 
    494494 
    495         OpName op = that.getOriginalName(); 
     495        Op op = that.getOriginalName(); 
    496496        // Not handling 
    497497        if( (op instanceof Op) == false && 
    … …  
    698698    } 
    699699 
    700         private boolean isDeclaredInObjExpr(IdOrOpName name) { 
     700        private boolean isDeclaredInObjExpr(IdOrOp name) { 
    701701        ObjectExpr innerMostObjExpr = objExprStack.peek(); 
    702702        Span objExprSpan = innerMostObjExpr.getSpan(); 
    … …  
    713713                if(name instanceof Id) { 
    714714                    bindingOutside = objExprTypeEnv.binding((Id) name); 
    715                 } else if(name instanceof OpName) { 
    716                     bindingOutside = objExprTypeEnv.binding((OpName)name); 
     715                } else if(name instanceof Op) { 
     716                    bindingOutside = objExprTypeEnv.binding((Op)name); 
    717717                } else { 
    718718                    throw new DesugarerError("Querying binding from TypeEnv with" + 
    … …  
    791791        } */ 
    792792 
    793         private boolean isDeclaredAtTopLevel(IdOrOpName idOrOpName) { 
     793        private boolean isDeclaredAtTopLevel(IdOrOp idOrOp) { 
    794794                // The first node in this stack must be declared at a top level 
    795795                // Its corresponding environment must be the top level environment 
    … …  
    804804                    throw new DesugarerError("TypeEnv associated with " 
    805805                            + topLevelNode + " is not found when querying for " + 
    806                     "type info for " + idOrOpName); 
     806                    "type info for " + idOrOp); 
    807807                } 
    808808 
    … …  
    810810            Option<StaticParam> staticParam = Option.<StaticParam>none(); 
    811811 
    812             if(idOrOpName instanceof Id) { 
    813                 binding = topLevelEnv.binding( (Id)idOrOpName ); 
    814                 staticParam = topLevelEnv.staticParam( (Id)idOrOpName ); 
    815             } else if(idOrOpName instanceof OpName) { 
    816                 binding = topLevelEnv.binding( (OpName)idOrOpName ); 
     812            if(idOrOp instanceof Id) { 
     813                binding = topLevelEnv.binding( (Id)idOrOp ); 
     814                staticParam = topLevelEnv.staticParam( (Id)idOrOp ); 
     815            } else if(idOrOp instanceof Op) { 
     816                binding = topLevelEnv.binding( (Op)idOrOp ); 
    817817            } else { 
    818818                throw new DesugarerError("Querying binding from TypeEnv with" + 
    819                             " type " + idOrOpName.getClass().toString() + 
     819                            " type " + idOrOp.getClass().toString() + 
    820820                            " is not supported."); 
    821821            } 
    … …  
    823823                if( binding.isNone() && staticParam.isNone() ) { 
    824824                        Debug.debug(Debug.Type.COMPILER, DEBUG_LEVEL, 
    825                                 idOrOpName, " is NOT declared in top level env."); 
     825                                idOrOp, " is NOT declared in top level env."); 
    826826                        return false; 
    827827                } 
    828828 
    829829                Debug.debug(Debug.Type.COMPILER, DEBUG_LEVEL, 
    830                             idOrOpName, " is declared in top level env."); 
     830                            idOrOp, " is declared in top level env."); 
    831831 
    832832                return true; 
    833833        } 
    834834 
    835     private boolean isShadowedInNode(Node enclosing, IdOrOpName idOrOpName) { 
     835    private boolean isShadowedInNode(Node enclosing, IdOrOp idOrOp) { 
    836836        Id name = null; 
    837         if(idOrOpName instanceof Id) { 
    838             name = (Id) idOrOpName; 
     837        if(idOrOp instanceof Id) { 
     838            name = (Id) idOrOp; 
    839839        } else { // FIXME: Need to support Op name later ... 
    840840            throw new DesugarerError("isShadowedInNode does not support " + 
    841841                "checking name shadowing where the name is not an Id type: " + 
    842                 idOrOpName); 
     842                idOrOp); 
    843843        } 
    844844 

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

    r3123 r3132  
    113113        // If there is a colon at all, the operator is no longer ambiguous: 
    114114        // It must be infix. 
    115         OpName op_name = IterUtil.first(that.getInfix_op().getOps()); 
     115        Op op_name = IterUtil.first(that.getInfix_op().getOps()); 
    116116        boolean prefix = OprUtil.hasPrefixColon(op_name); 
    117117        boolean suffix = OprUtil.hasSuffixColon(op_name); 
    … …  
    152152 
    153153        if (args.size() <= 1) return opExp; 
    154         OpName qop = IterUtil.first(ref.getOps()); 
     154        Op qop = IterUtil.first(ref.getOps()); 
    155155 
    156156        if (OprUtil.isEnclosing(qop)) return opExp; 
    … …  
    186186 
    187187    private Expr visitAccumulator(Span span, List<GeneratorClause> gens, 
    188                                   OpName op, Expr body, 
     188                                  Op op, Expr body, 
    189189                                  List<StaticArg> staticArgs) { 
    190190        body = visitGenerators(span, gens, body); 

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

    r2503 r3132  
    2323 
    2424import com.sun.fortress.nodes.Id; 
    25 import com.sun.fortress.nodes.IdOrOpName; 
    26 import com.sun.fortress.nodes.OpName; 
     25import com.sun.fortress.nodes.IdOrOp; 
     26import com.sun.fortress.nodes.Op; 
    2727import com.sun.fortress.nodes.APIName; 
    2828import com.sun.fortress.nodes.StaticParam; 
    … …  
    4040    } 
    4141 
    42     public Option<StaticParam> hasTypeParam(IdOrOpName name) { 
     42    public Option<StaticParam> hasTypeParam(IdOrOp name) { 
    4343        return _parent.hasTypeParam(name); 
    4444    } 
    … …  
    5151    } 
    5252    public List<Id> explicitVariableNames() { 
    53         return _parent.explicitVariableNames();  
     53        return _parent.explicitVariableNames(); 
    5454    } 
    5555    public Set<Id> explicitFunctionNames(Id name) { 
    5656        return _parent.explicitFunctionNames(name); 
    5757    } 
    58     public Set<OpName> explicitFunctionNames(OpName name) { 
     58    public Set<Op> explicitFunctionNames(Op name) { 
    5959        return _parent.explicitFunctionNames(name); 
    6060    } 
    … …  
    6969        return _parent.onDemandFunctionNames(name); 
    7070    } 
    71     public Set<OpName> onDemandFunctionNames(OpName name) { 
     71    public Set<Op> onDemandFunctionNames(Op name) { 
    7272        return _parent.onDemandFunctionNames(name); 
    7373    } 

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

    r2277 r3132  
    2222 
    2323import com.sun.fortress.nodes.Id; 
    24 import com.sun.fortress.nodes.IdOrOpName; 
    25 import com.sun.fortress.nodes.OpName; 
     24import com.sun.fortress.nodes.IdOrOp; 
     25import com.sun.fortress.nodes.Op; 
    2626import com.sun.fortress.nodes.APIName; 
    2727import com.sun.fortress.nodes.StaticParam; 
    … …  
    3939    } 
    4040 
    41     public Option<StaticParam> hasTypeParam(IdOrOpName name) { 
     41    public Option<StaticParam> hasTypeParam(IdOrOp name) { 
    4242        return _parent.hasTypeParam(name); 
    4343    } 

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

    r3123 r3132  
    7171import com.sun.fortress.nodes.ObjectExpr; 
    7272import com.sun.fortress.nodes.OpExpr; 
    73 import com.sun.fortress.nodes.OpName; 
     73import com.sun.fortress.nodes.Op; 
    7474import com.sun.fortress.nodes.OpRef; 
    7575import com.sun.fortress.nodes.Param; 
    … …  
    850850        return forAccumulatorOnly(that, type_result, 
    851851                                  recurOnListOfStaticArg(that.getStaticArgs()), 
    852                                   (OpName)that.getAccOp().accept(this), 
     852                                  (Op)that.getAccOp().accept(this), 
    853853                                  pair.first(), 
    854854                                  (Expr)that.getBody().accept(extended_d)); 
    … …  
    11181118     */ 
    11191119    private Option<OpRef> opRefHelper(OpRef that) { 
    1120         OpName op_name = IterUtil.first(that.getOps()); 
    1121         Set<OpName> ops = _env.explicitFunctionNames(op_name); 
     1120        Op op_name = IterUtil.first(that.getOps()); 
     1121        Set<Op> ops = _env.explicitFunctionNames(op_name); 
    11221122        if (ops.isEmpty()) { 
    11231123            ops = _env.onDemandFunctionNames(op_name); 

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

    r1598 r3132  
    2424import com.sun.fortress.nodes.IdOrOpOrAnonymousName; 
    2525import com.sun.fortress.nodes.Id; 
    26 import com.sun.fortress.nodes.OpName; 
     26import com.sun.fortress.nodes.Op; 
    2727import com.sun.fortress.nodes_util.NodeFactory; 
    2828 
    … …  
    4444    } 
    4545 
    46     @Override public Set<OpName> explicitFunctionNames(OpName name) { 
     46    @Override public Set<Op> explicitFunctionNames(Op name) { 
    4747        if (_fns.contains(name)) { 
    4848            return Collections.singleton(name); 

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

    r2277 r3132  
    3737    } 
    3838 
    39     public Option<StaticParam> hasTypeParam(IdOrOpName name) { 
     39    public Option<StaticParam> hasTypeParam(IdOrOp name) { 
    4040        for (StaticParam typeVar : _staticParams) { 
    4141                if (typeVar instanceof IdStaticParam && 

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

    r2609 r3132  
    2222 
    2323import com.sun.fortress.nodes.Id; 
    24 import com.sun.fortress.nodes.OpName; 
     24import com.sun.fortress.nodes.Op; 
    2525 
    2626public abstract class NameEnv extends TypeNameEnv { 
    … …  
    3333     */ 
    3434    public abstract Set<Id> explicitVariableNames(Id name); 
    35     /**  
     35    /** 
    3636     * Produce the set of all unaliased expilcit variable names in this environment. 
    3737     */ 
    … …  
    4848     * produces an empty set. 
    4949     */ 
    50     public abstract Set<OpName> explicitFunctionNames(OpName name); 
     50    public abstract Set<Op> explicitFunctionNames(Op name); 
    5151 
    5252    /** 
    … …  
    6868     * produces an empty set. 
    6969     */ 
    70     public abstract Set<OpName> onDemandFunctionNames(OpName name); 
     70    public abstract Set<Op> onDemandFunctionNames(Op name); 
    7171 
    7272    /** 

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

    r3123 r3132  
    4545import com.sun.fortress.nodes.Api; 
    4646import com.sun.fortress.nodes.Component; 
    47 import com.sun.fortress.nodes.Enclosing; 
    4847import com.sun.fortress.nodes.Id; 
    49 import com.sun.fortress.nodes.IdOrOpName; 
     48import com.sun.fortress.nodes.IdOrOp; 
    5049import com.sun.fortress.nodes.IdOrOpOrAnonymousName; 
    5150import com.sun.fortress.nodes.Import; 
    … …  
    5655import com.sun.fortress.nodes.NodeDepthFirstVisitor; 
    5756import com.sun.fortress.nodes.Op; 
    58 import com.sun.fortress.nodes.OpName; 
     57import com.sun.fortress.nodes.Op; 
    5958import com.sun.fortress.nodes.StaticParam; 
    6059import com.sun.fortress.nodes_util.NodeFactory; 
    … …  
    8786    private final Map<Id, Set<Id>> _onDemandVariableNames; 
    8887    private final Map<Id, Set<Id>> _onDemandFunctionIdNames; 
    89     private final Map<OpName, Set<OpName>> _onDemandFunctionOpNames; 
     88    private final Map<Op, Set<Op>> _onDemandFunctionOps; 
    9089    private final Map<String, Set<Id>> _onDemandGrammarNames; 
    9190 
    … …  
    114113        _onDemandTypeConsNames = Collections.unmodifiableMap(initializeOnDemandTypeConsNames(_onDemandImportedApis)); 
    115114        _onDemandVariableNames = Collections.unmodifiableMap(initializeOnDemandVariableNames(_onDemandImportedApis)); 
    116         Pair<Map<Id, Set<Id>>, Map<OpName, Set<OpName>>> functions_and_ops = 
     115        Pair<Map<Id, Set<Id>>, Map<Op, Set<Op>>> functions_and_ops = 
    117116            initializeOnDemandFunctionNames(_onDemandImportedApis); 
    118117        _onDemandFunctionIdNames = functions_and_ops.first(); 
    119         _onDemandFunctionOpNames = functions_and_ops.second(); 
     118        _onDemandFunctionOps = functions_and_ops.second(); 
    120119        _onDemandGrammarNames = Collections.unmodifiableMap(initializeOnDemandGrammarNames(_onDemandImportedApis)); 
    121120    } 
    … …  
    214213    } 
    215214 
    216     private static OpName copyOpNameWithNewAPIName(OpName op, final APIName api) { 
    217         OpName result = 
    218                 op.accept(new NodeDepthFirstVisitor<OpName>(){ 
     215    private static Op copyOpWithNewAPIName(Op op, final APIName api) { 
     216        Op result = 
     217                op.accept(new NodeDepthFirstVisitor<Op>(){ 
    219218                        @Override 
    220                         public OpName defaultCase(Node that) { 
    221                                 return bug("Unexpected sub-type of OpName."); 
     219                        public Op defaultCase(Node that) { 
     220                                return bug("Unexpected sub-type of Op."); 
    222221                        } 
    223222                        @Override 
    224                         public OpName forEnclosing(Enclosing that) { 
    225                                 return new Enclosing(that.getSpan(),Option.some(api),that.getOpen(),that.getClose()); 
    226                         } 
    227                         @Override 
    228                         public OpName forOp(Op that) { 
    229                                 return new Op(that.getSpan(),Option.some(api),that.getText(),that.getFixity()); 
     223                        public Op forOp(Op that) { 
     224                            return new Op(that.getSpan(),Option.some(api),that.getText(),that.getFixity(), that.isEnclosing()); 
    230225                        }}); 
    231226        return result; 
    232227    } 
    233228 
    234     private static Pair<Map<Id, Set<Id>>, Map<OpName, Set<OpName>>> initializeOnDemandFunctionNames(Map<APIName, ApiIndex> imported_apis) { 
     229    private static Pair<Map<Id, Set<Id>>, Map<Op, Set<Op>>> initializeOnDemandFunctionNames(Map<APIName, ApiIndex> imported_apis) { 
    235230        Map<Id, Set<Id>> fun_result = new HashMap<Id, Set<Id>>(); 
    236         Map<OpName, Set<OpName>> ops_result =  new HashMap<OpName, Set<OpName>>(); 
     231        Map<Op, Set<Op>> ops_result =  new HashMap<Op, Set<Op>>(); 
    237232 
    238233        for (Map.Entry<APIName, ApiIndex> apiEntry: imported_apis.entrySet()) { 
    … …  
    253248                    } 
    254249                } 
    255                 else { // fnName instanceof OpName 
    256                     OpName _opName = (OpName)fnName; 
    257                     OpName name = copyOpNameWithNewAPIName(_opName, apiEntry.getKey()); 
    258                     // NEB: I put this code here because I don't see why we shouldn't qualify OpNames as well... 
     250                else { // fnName instanceof Op 
     251                    Op _opName = (Op)fnName; 
     252                    Op name = copyOpWithNewAPIName(_opName, apiEntry.getKey()); 
     253                    // NEB: I put this code here because I don't see why we shouldn't qualify Ops as well... 
    259254 
    260255                    if (ops_result.containsKey(_opName)) { 
    261256                        ops_result.get(_opName).add(name); 
    262257                    } else { 
    263                         Set<OpName> matches = new HashSet<OpName>(); 
     258                        Set<Op> matches = new HashSet<Op>(); 
    264259                        matches.add(name); 
    265260                        ops_result.put(_opName, matches); 
    … …  
    300295 
    301296    @Override 
    302     public Option<StaticParam> hasTypeParam(IdOrOpName name) { 
     297    public Option<StaticParam> hasTypeParam(IdOrOp name) { 
    303298        return Option.none(); 
    304299    } 
    … …  
    412407    } 
    413408 
    414     public Set<OpName> explicitFunctionNames(OpName name) { 
    415         Set<OpName> result = Collections.emptySet(); 
     409    public Set<Op> explicitFunctionNames(Op name) { 
     410        Set<Op> result = Collections.emptySet(); 
    416411 
    417412        // Add ops in this component 
    418413        if( _current.functions().containsFirst(name)) { 
    419414            // Only qualify name with an API if we are inside of an API 
    420             OpName result_id; 
     415            Op result_id; 
    421416            if( _current instanceof ApiIndex ) 
    422                 result_id = NodeFactory.makeOpName(_current.ast().getName(), name); 
     417                result_id = NodeFactory.makeOp(_current.ast().getName(), name); 
    423418            else 
    424419                result_id = name; 
    … …  
    474469    } 
    475470 
    476     public Set<OpName> onDemandFunctionNames(OpName name) { 
    477         if (_onDemandFunctionOpNames.containsKey(name)) { 
    478             return _onDemandFunctionOpNames.get(name); 
     471    public Set<Op> onDemandFunctionNames(Op name) { 
     472        if (_onDemandFunctionOps.containsKey(name)) { 
     473            return _onDemandFunctionOps.get(name); 
    479474        } else { 
    480             return new HashSet<OpName>(); 
     475            return new HashSet<Op>(); 
    481476        } 
    482477    } 

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

    r2593 r3132  
    2525import com.sun.fortress.nodes.Id; 
    2626import com.sun.fortress.nodes.APIName; 
    27 import com.sun.fortress.nodes.IdOrOpName; 
     27import com.sun.fortress.nodes.IdOrOp; 
    2828import com.sun.fortress.nodes.StaticParam; 
    2929import com.sun.fortress.nodes_util.NodeFactory; 
    … …  
    4141 
    4242    /** Determine whether a type parameter with the given name is defined. */ 
    43     public abstract Option<StaticParam> hasTypeParam(IdOrOpName name); 
     43    public abstract Option<StaticParam> hasTypeParam(IdOrOp name); 
    4444 
    4545    /** 

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

    r2466 r3132  
    2626import com.sun.fortress.nodes.BoolParam; 
    2727import com.sun.fortress.nodes.Id; 
    28 import com.sun.fortress.nodes.IdOrOpName; 
     28import com.sun.fortress.nodes.IdOrOp; 
    2929import com.sun.fortress.nodes.IdOrOpOrAnonymousName; 
    3030import com.sun.fortress.nodes.IdStaticParam; 
    … …  
    4848 */ 
    4949public class StaticParamTypeEnv extends TypeEnv { 
    50          
     50 
    5151        final static Type STATIC_INT_TYPE = Types.INT_LITERAL; 
    5252        final static Type STATIC_NAT_TYPE = Types.INT_LITERAL; 
    5353        final static Type STATIC_BOOL_TYPE = Types.BOOLEAN; 
    54          
     54 
    5555        final List<StaticParam> entries; 
    5656        final private TypeEnv parent; 
    57          
     57 
    5858        public StaticParamTypeEnv(List<StaticParam> _static, TypeEnv _parent) { 
    5959                entries=Collections.unmodifiableList(new ArrayList<StaticParam>(_static)); 
    … …  
    6363        private Option<Pair<StaticParam,Type>> findParam(Id _var) { 
    6464        Id no_api_var = removeApi(_var); 
    65         for (StaticParam param : entries) {              
    66                 IdOrOpName name = nameFromStaticParam(param); 
     65        for (StaticParam param : entries) { 
     66                IdOrOp name = nameFromStaticParam(param); 
    6767                if(name.equals(no_api_var) || name.equals(_var) ){ 
    6868                        Option<Type> type_ = typeOfStaticParam(param); 
    69                          
     69 
    7070                        if( type_.isSome() ) 
    7171                                return Option.some(Pair.make(param, type_.unwrap())); 
    … …  
    7474        return Option.none(); 
    7575    } 
    76          
     76 
    7777        @Override 
    7878        public Option<BindingLookup> binding(IdOrOpOrAnonymousName var) { 
    7979        if (!(var instanceof Id)) { return parent.binding(var); } 
    8080        Id _var = (Id)var; 
    81         
     81 
    8282        Option<Pair<StaticParam,Type>> p = findParam(_var); 
    83          
     83 
    8484        if( p.isSome() ) { 
    8585                Type type_ = p.unwrap().second(); 
    … …  
    9696 
    9797                Id no_api_var = removeApi(_var); 
    98                 for (StaticParam param : entries) {              
    99                         IdOrOpName name = nameFromStaticParam(param); 
     98                for (StaticParam param : entries) { 
     99                        IdOrOp name = nameFromStaticParam(param); 
    100100 
    101101                        if(name.equals(no_api_var) || name.equals(_var) ){ 
    … …  
    105105                return parent.staticParam(id); 
    106106        } 
    107          
    108         private static IdOrOpName nameFromStaticParam(StaticParam param) { 
    109                 NodeAbstractVisitor<IdOrOpName> get_name = new NodeAbstractVisitor<IdOrOpName>(){ 
    110                         @Override public IdOrOpName forIdStaticParam(IdStaticParam that) { return that.getName(); } 
    111                         @Override public IdOrOpName forOpParam(OpParam that) { return that.getName(); } 
     107 
     108        private static IdOrOp nameFromStaticParam(StaticParam param) { 
     109                NodeAbstractVisitor<IdOrOp> get_name = new NodeAbstractVisitor<IdOrOp>(){ 
     110                        @Override public IdOrOp forIdStaticParam(IdStaticParam that) { return that.getName(); } 
     111                        @Override public IdOrOp forOpParam(OpParam that) { return that.getName(); } 
    112112                }; 
    113                  
    114                 IdOrOpName name = param.accept(get_name); 
     113 
     114                IdOrOp name = param.accept(get_name); 
    115115                return name; 
    116116        } 
    … …  
    119119                NodeAbstractVisitor<Option<Type>> get_type = new NodeAbstractVisitor<Option<Type>>(){ 
    120120 
    121                         @Override  
     121                        @Override 
    122122                        public Option<Type> defaultCase(Node node) { 
    123123                                return Option.none(); 
    124124                        } 
    125                          
     125 
    126126                        @Override 
    127127                        public Option<Type> forBoolParam(BoolParam that) { 
    … …  
    147147        public List<BindingLookup> contents() { 
    148148                List<BindingLookup> result = new ArrayList<BindingLookup>(); 
    149                  
     149 
    150150                for( StaticParam param : entries ) { 
    151151                        Option<Type> type_ = typeOfStaticParam(param); 
    … …  
    160160        if (!(var instanceof Id)) { return parent.declarationSite(var); } 
    161161        Id _var = (Id)var; 
    162         
     162 
    163163        Option<Pair<StaticParam,Type>> p = findParam(_var); 
    164164        if( p.isSome() ) 
    … …  
    172172                List<StaticParam> new_entries = new ArrayList<StaticParam>(entries.size()); 
    173173                InferenceVarReplacer rep = new InferenceVarReplacer(ivars); 
    174                  
     174 
    175175                for( StaticParam entry : entries ) { 
    176176                        new_entries.add((StaticParam)entry.accept(rep)); 
    177177                } 
    178                  
     178 
    179179                return new StaticParamTypeEnv(new_entries, parent.replaceAllIVars(ivars)); 
    180180        } 

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

    r3123 r3132  
    794794         * whose type is the statically most applicable to the given arg. 
    795795         */ 
    796         private TypeCheckerResult findStaticallyMostApplicableFn(List<? extends Pair<? extends FunctionalRef, Type>> fns, Type arg_type, FunctionalRef ref, IdOrOpName name) { 
     796        private TypeCheckerResult findStaticallyMostApplicableFn(List<? extends Pair<? extends FunctionalRef, Type>> fns, Type arg_type, FunctionalRef ref, IdOrOp name) { 
    797797                final List<Pair<FunctionalRef, Type>> pruned_fns = new ArrayList<Pair<FunctionalRef, Type>>(fns.size()); 
    798798                // prune down the list of fns to just the ones that apply 
    … …  
    21222122 
    21232123        @Override 
    2124         public TypeCheckerResult forEnclosing(Enclosing that) { 
    2125                 Option<APIName> api = that.getApiName(); 
    2126                 TypeEnv env = api.isSome() ? returnTypeEnvForApi(api.unwrap()) : this.typeEnv; 
    2127  
    2128                 Option<BindingLookup> binding = env.binding(that); 
    2129                 if( binding.isSome() ) { 
    2130                         return new TypeCheckerResult(that, binding.unwrap().getType()); 
    2131                 } else { 
    2132                         return new TypeCheckerResult(that, 
    2133                                         TypeError.make(errorMsg("Enclosing operator not found: ", 
    2134                                                         that), 
    2135                                                         that)); 
    2136                 } 
    2137         } 
    2138  
    2139         @Override 
    21402124        public TypeCheckerResult forEnclosingFixity(EnclosingFixity that) { 
    21412125                return new TypeCheckerResult(that); 
    … …  
    27292713                        } else { 
    27302714                                // Operators are never qualified in source code, so if 'name' is qualified and not 
    2731                                 // found, it must be a Id, not a OpName. 
     2715                                // found, it must be a Id, not a Op. 
    27322716                                StaticError error = TypeError.make(errorMsg("Attempt to reference unbound variable: ", name), 
    27332717                                                name); 
    … …  
    35133497                Option<APIName> api = that.getApiName(); 
    35143498 
     3499                if ( that.isEnclosing() ) { 
     3500                    TypeEnv env = api.isSome() ? returnTypeEnvForApi(api.unwrap()) : this.typeEnv; 
     3501 
     3502                    Option<BindingLookup> binding = env.binding(that); 
     3503                    if( binding.isSome() ) { 
     3504                        return new TypeCheckerResult(that, binding.unwrap().getType()); 
     3505                    } else { 
     3506                        return new TypeCheckerResult(that, 
     3507                                                     TypeError.make(errorMsg("Enclosing operator not found: ", 
     3508                                                                             that), 
     3509                                                                    that)); 
     3510                    } 
     3511                } 
     3512 
    35153513                Option<BindingLookup> binding; 
    35163514 
    … …  
    36053603                        // Guaranteed at least one operator because all the overloaded operators 
    36063604                        // are created by disambiguation, not by the user. 
    3607                         OpName opName = IterUtil.first(that.getOp().getOps()); 
     3605                        Op opName = IterUtil.first(that.getOp().getOps()); 
    36083606                        return TypeCheckerResult.compose(that, subtypeChecker, 
    36093607                                        op_result, 
    … …  
    37503748                                                        that.getLexicalDepth(), 
    37513749                                                        that.getOriginalName(), 
    3752                                                         (List<OpName>)TypeCheckerResult.astFromResults(ops_result)); 
     3750                                                        (List<Op>)TypeCheckerResult.astFromResults(ops_result)); 
    37533751                } 
    37543752 
    … …  
    38083806                TypeCheckerResult obj_result = recur(that.getObj()); 
    38093807                List<TypeCheckerResult> subs_result = recurOnListOfExpr(that.getSubs()); 
    3810                 Option<TypeCheckerResult> op_result = recurOnOptionOfEnclosing(that.getOp()); 
     3808                Option<TypeCheckerResult> op_result = recurOnOptionOfOp(that.getOp()); 
    38113809                List<TypeCheckerResult> staticArgs_result = recurOnListOfStaticArg(that.getStaticArgs()); 
    38123810 
    … …  
    46564654        } 
    46574655 
    4658         private TypeCheckerResult subscriptHelper(Node that, Option<Enclosing> op, 
     4656        private TypeCheckerResult subscriptHelper(Node that, Option<Op> op, 
    46594657                        Type obj_type, List<Type> subs_types, List<StaticArg> static_args) { 
    46604658                List<TraitType> traits = traitTypesCallable(obj_type); 

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

    r3122 r3132  
    4747import com.sun.fortress.nodes.DimParam; 
    4848import com.sun.fortress.nodes.DimRef; 
    49 import com.sun.fortress.nodes.Enclosing; 
    5049import com.sun.fortress.nodes.FnDecl; 
    5150import com.sun.fortress.nodes.Id; 
    … …  
    221220    } 
    222221 
    223     static Enclosing removeApi(Enclosing id) { 
    224         return NodeFactory.makeEnclosing(id.getSpan(), id.getOpen(), id.getClose()); 
    225     } 
    226  
    227222    static Op removeApi(Op id) { 
    228         return NodeFactory.makeOp(id.getSpan(), id.getText(), id.getFixity()); 
     223        return new Op(id.getSpan(), id.getText(), id.getFixity(), id.isEnclosing()); 
    229224    } 
    230225 
    231226    static IdOrOpOrAnonymousName removeApi(IdOrOpOrAnonymousName id) { 
    232227        return id.accept(new NodeDepthFirstVisitor<IdOrOpOrAnonymousName>(){ 
    233                         @Override 
    234                         public IdOrOpOrAnonymousName forEnclosing(Enclosing that) { 
    235                                 return NodeFactory.makeEnclosing(that.getSpan(), that.getOpen(), that.getClose()); 
    236                         } 
    237228                        @Override public IdOrOpOrAnonymousName forId(Id that) { return removeApi(that); } 
    238229                        @Override 
    239230                        public IdOrOpOrAnonymousName forOp(Op that) { 
    240                                 return NodeFactory.makeOp(that.getSpan(), that.getText(), that.getFixity()); 
     231                            return new Op(that.getSpan(), that.getText(), that.getFixity(), that.isEnclosing()); 
    241232                        } 
    242233                        @Override 

  • trunk/ProjectFortress/src/com/sun/fortress/interpreter/env/IndexedEnv.java

    r3060 r3132  
    2929import com.sun.fortress.nodes.IdOrOpOrAnonymousName; 
    3030import com.sun.fortress.nodes.NamedType; 
    31 import com.sun.fortress.nodes.OpName; 
     31import com.sun.fortress.nodes.Op; 
    3232import com.sun.fortress.nodes.OpRef; 
    3333import com.sun.fortress.nodes.TraitType; 
    … …  
    4646    public void assignValue(HasAt loc, String str, FValue f2) { 
    4747        // TODO Auto-generated method stub 
    48          
     48 
    4949    } 
    5050 
    5151    public void bless() { 
    5252        // TODO Auto-generated method stub 
    53          
     53 
    5454    } 
    5555 
    5656    public void debugPrint(String debugString) { 
    5757        // TODO Auto-generated method stub 
    58          
     58 
    5959    } 
    6060 
    … …  
    234234    } 
    235235 
    236     public FValue getValue(OpName name, int l) { 
     236    public FValue getValue(Op name, int l) { 
    237237        // TODO Auto-generated method stub 
    238238        return null; 
    … …  
    254254    } 
    255255 
    256     public FValue getValueNull(OpName name, int l) { 
     256    public FValue getValueNull(Op name, int l) { 
    257257        // TODO Auto-generated method stub 
    258258        return null; 
    … …  
    296296    public void noteName(String s) { 
    297297        // TODO Auto-generated method stub 
    298          
     298 
    299299    } 
    300300 
    301301    public void putApi(String apiName, Environment env) { 
    302302        // TODO Auto-generated method stub 
    303          
     303 
    304304    } 
    305305 
    306306    public void putBool(String str, Boolean f2) { 
    307307        // TODO Auto-generated method stub 
    308          
     308 
    309309    } 
    310310 
    311311    public void putBoolRaw(String str, Boolean f2) { 
    312312        // TODO Auto-generated method stub 
    313          
     313 
    314314    } 
    315315 
    316316    public void putFunctionalMethodInstance(String fndodname, FValue cl) { 
    317317        // TODO Auto-generated method stub 
    318          
     318 
    319319    } 
    320320 
    321321    public void putInt(String add_as, Number cnnf) { 
    322322        // TODO Auto-generated method stub 
    323          
     323 
    324324    } 
    325325 
    326326    public void putIntRaw(String str, Number f2) { 
    327327        // TODO Auto-generated method stub 
    328          
     328 
    329329    } 
    330330 
    331331    public void putNat(String str, Number f2) { 
    332332        // TODO Auto-generated method stub 
    333          
     333 
    334334    } 
    335335 
    336336    public void putNatRaw(String str, Number f2) { 
    337337        // TODO Auto-generated method stub 
    338          
     338 
    339339    } 
    340340 
    341341    public void putType(Id d, FType x) { 
    342342        // TODO Auto-generated method stub 
    343          
     343 
    344344    } 
    345345 
    346346    public void putType(String str, FType f2) { 
    347347        // TODO Auto-generated method stub 
    348          
     348 
    349349    } 
    350350 
    351351    public void putTypeRaw(String str, FType f2) { 
    352352        // TODO Auto-generated method stub 
    353          
     353 
    354354    } 
    355355 
    356356    public void putValue(FValue f1, FValue f2) { 
    357357        // TODO Auto-generated method stub 
    358          
     358 
    359359    } 
    360360 
    361361    public void putValue(Id d, FValue x) { 
    362362        // TODO Auto-generated method stub 
    363          
     363 
    364364    } 
    365365 
    366366    public void putValue(String str, FValue f2) { 
    367367        // TODO Auto-generated method stub 
    368          
     368 
    369369    } 
    370370 
    371371    public void putValueNoShadowFn(String fndodname, FValue cl) { 
    372372        // TODO Auto-generated method stub 
    373          
     373 
    374374    } 
    375375 
    376376    public void putValueRaw(String str, FValue f2) { 
    377377        // TODO Auto-generated method stub 
    378          
     378 
    379379    } 
    380380 
    381381    public void putValueRaw(String name, FValue value, FType ft) { 
    382382        // TODO Auto-generated method stub 
    383          
     383 
    384384    } 
    385385 
    386386    public void putVariable(String string, FType fvt) { 
    387387        // TODO Auto-generated method stub 
    388          
     388 
    389389    } 
    390390 
    391391    public void putVariable(String s, FValue value) { 
    392392        // TODO Auto-generated method stub 
    393          
     393 
    394394    } 
    395395 
    396396    public void putVariable(String str, FValue f2, FType ft) { 
    397397        // TODO Auto-generated method stub 
    398          
     398 
    399399    } 
    400400 
    401401    public void putVariablePlaceholder(String sname) { 
    402402        // TODO Auto-generated method stub 
    403          
     403 
    404404    } 
    405405 
    406406    public void removeType(String s) { 
    407407        // TODO Auto-generated method stub 
    408          
     408 
    409409    } 
    410410 
    411411    public void removeVar(String name) { 
    412412        // TODO Auto-generated method stub 
    413          
     413 
    414414    } 
    415415 
    416416    public void setTopLevel() { 
    417417        // TODO Auto-generated method stub 
    418          
     418 
    419419    } 
    420420 
    421421    public void storeType(HasAt x, String sname, FType ft) { 
    422422        // TODO Auto-generated method stub 
    423          
     423 
    424424    } 
    425425 
    … …  
    428428            Visitor2<String, Boolean> vb) { 
    429429        // TODO Auto-generated method stub 
    430          
     430 
    431431    } 
    432432 
    433433    public void visit(Visitor2<String, Object> nameCollector) { 
    434434        // TODO Auto-generated method stub 
    435          
     435 
    436436    } 
    437437 
    … …  
    441441    } 
    442442 
    443    
     443 
    444444} 

  • trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/BaseEnv.java

    r3123 r3132  
    4242import com.sun.fortress.nodes.APIName; 
    4343import com.sun.fortress.nodes.Id; 
    44 import com.sun.fortress.nodes.IdOrOpName; 
     44import com.sun.fortress.nodes.IdOrOp; 
    4545import com.sun.fortress.nodes.IdOrOpOrAnonymousName; 
    4646import com.sun.fortress.nodes.NamedType; 
    47 import com.sun.fortress.nodes.OpName; 
     47import com.sun.fortress.nodes.Op; 
    4848import com.sun.fortress.nodes.OpRef; 
    4949import com.sun.fortress.nodes.TraitType; 
    … …  
    520520 
    521521    final public  FValue getValueNull(OpRef vr) { 
    522         OpName name = vr.getOps().get(0); 
     522        Op name = vr.getOps().get(0); 
    523523        int l = vr.getLexicalDepth(); 
    524524        return getValueNull(name, l); 
    … …  
    532532    } 
    533533 
    534       final public FValue getValueNull(OpName name, int l) 
     534      final public FValue getValueNull(Op name, int l) 
    535535            throws CircularDependenceError { 
    536536        // String s = NodeUtil.nameString(name); 
    … …  
    547547      } 
    548548 
    549         final public FValue getValue(OpName name, int l) 
     549        final public FValue getValue(Op name, int l) 
    550550              throws CircularDependenceError { 
    551551          // String s = NodeUtil.nameString(name); 
    … …  
    555555 
    556556      } 
    557         private FValue getValueTail(IdOrOpName name, int l, String local, 
     557        private FValue getValueTail(IdOrOp name, int l, String local, 
    558558              Option<APIName> opt_api) throws OptionUnwrapException, 
    559559              CircularDependenceError { 
    … …  
    566566    } 
    567567 
    568       private FValue getValueNullTail(IdOrOpName name, int l, String local, 
     568      private FValue getValueNullTail(IdOrOp name, int l, String local, 
    569569              Option<APIName> opt_api) throws OptionUnwrapException, 
    570570              CircularDependenceError { 

  • trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/BuildTopLevelEnvironments.java

    r3123 r3132  
    3535import com.sun.fortress.nodes.Component; 
    3636import com.sun.fortress.nodes.Id; 
    37 import com.sun.fortress.nodes.IdOrOpName; 
     37import com.sun.fortress.nodes.IdOrOp; 
    3838import com.sun.fortress.nodes.Import; 
    3939import com.sun.fortress.nodes.ImportApi; 
    … …  
    4242import com.sun.fortress.nodes.Node; 
    4343import com.sun.fortress.nodes.NodeAbstractVisitor; 
    44 import com.sun.fortress.nodes.OpName; 
     44import com.sun.fortress.nodes.Op; 
    4545import com.sun.fortress.nodes.StaticParam; 
    4646import com.sun.fortress.nodes.TraitDecl; 
    … …  
    163163            String s = x.getName().stringName(); 
    164164            OverloadedFunction of = (OverloadedFunction) bindInto.getRootValue(s); 
    165             for (IdOrOpName fn : x.getFns()) { 
     165            for (IdOrOp fn : x.getFns()) { 
    166166                Option<APIName> oapi = fn.getApiName(); 
    167167                FValue oapi_val = null; 
    … …  
    169169                if (fn instanceof Id) { 
    170170                    oapi_val = bindInto.getValueNull((Id) fn, Environment.TOP_LEVEL); // top-level reference 
    171                 } else if (fn instanceof OpName) { 
    172                     oapi_val = bindInto.getValueNull((OpName) fn, Environment.TOP_LEVEL); // top-level reference 
     171                } else if (fn instanceof Op) { 
     172                    oapi_val = bindInto.getValueNull((Op) fn, Environment.TOP_LEVEL); // top-level reference 
    173173                } else { 
    174174                    bug("Unexpected change to AST node hierarchy"); 

  • trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/Environment.java

    r3060 r3132  
    2828import com.sun.fortress.nodes.IdOrOpOrAnonymousName; 
    2929import com.sun.fortress.nodes.NamedType; 
    30 import com.sun.fortress.nodes.OpName; 
     30import com.sun.fortress.nodes.Op; 
    3131import com.sun.fortress.nodes.OpRef; 
    3232import com.sun.fortress.nodes.TraitType; 
    … …  
    9292    public abstract FType getType(Id d); // 3 
    9393    // BoolRef, IntRef, and the TL name of a (generic) trait. 
    94      
     94 
    9595    public abstract FType getTypeNull(VarType q); // 2 
    9696    public abstract FType getType(VarType q); // 2 
    9797    // forTraitType, forVarType (these have lexical depth) 
    9898    public abstract FType getType(TraitType q); // toplevel, possible api 
    99      
     99 
    100100    public abstract FType getRootType(String str); // 10 refs 
    101101    public abstract FType getLeafType(String str); // 4 refs 
    … …  
    107107    public abstract FType getRootTypeNull(String name); // 4 refs 
    108108    public FType getTypeNull(String name); // 3 refs -- keep this name because of compiled code. 
    109      
     109 
    110110    /** 
    111111     * Level-tagged version of getTypeNull 
    112      *  
     112     * 
    113113     * @param name 
    114114     * @param level 
    … …  
    116116     */ 
    117117    public FType getTypeNull(String name, int level); 
    118      
     118 
    119119    //public abstract FValue getValue(FValue f1); 
    120120 
    … …  
    134134     */ 
    135135    public abstract FValue getLeafValue(String str); // 25 refs 
    136      
     136 
    137137    /** 
    138138     * Get a value from top-level environment. 
    … …  
    148148    public abstract FValue getLeafValueNull(String s); // 6 refs 
    149149    public abstract FValue getRootValueNull(String s); // 5 refs 
    150      
     150 
    151151    /** 
    152152     * Similar to the string version, but able to deal with 
    153153     * depth information on the VarRef. 
    154      *  
     154     * 
    155155     * @param vr 
    156156     * @return 
    157157     */ 
    158158    public abstract FValue getValueNull(VarRef vr); // 2 refs 
    159      
     159 
    160160    public abstract FValue getValueNull(OpRef vr); // 2 refs 
    161161 
    162162    public abstract FValue getValueNull(Id name, int l); // 3 refs 
    163          
    164     public abstract FValue getValueNull(OpName name, int l); // 2 refs 
    165      
     163 
     164    public abstract FValue getValueNull(Op name, int l); // 2 refs 
     165 
    166166    public abstract FValue getValue(Id name, int l); // 0 refs 
    167      
    168     public abstract FValue getValue(OpName name, int l); // 1 ref 
    169      
     167 
     168    public abstract FValue getValue(Op name, int l); // 1 ref 
     169 
    170170    public abstract FValue getValue(VarRef vr); // 0 refs 
    171      
     171 
    172172    public abstract FValue getValue(OpRef vr); // 2 refs 
    173173 
    … …  
    177177 
    178178    public abstract FType getVarTypeNull(String str); // 2 refs 
    179     // Leaf in baseenv,  
     179    // Leaf in baseenv, 
    180180    // Can be level-indexed in LHSEvaluator 
    181      
     181 
    182182    public abstract Environment installPrimitives(); 
    183183 
    184184    public boolean isTopLevel(); 
    185      
     185 
    186186    // A notable name -- for overloading later, I think. 
    187187    public abstract void noteName(String s); 
    … …  
    190190 
    191191    public void putBoolRaw(String str, Boolean f2) ; 
    192      
     192 
    193193    public abstract void putFunctionalMethodInstance(String fndodname, FValue cl); // Fcn? 
    194194 
    … …  
    214214 
    215215    public abstract void putTypeRaw(String str, FType f2); 
    216      
     216 
    217217    /** 
    218218     * Put a value in the top-most scope. 
    … …  
    252252 
    253253    public abstract void removeType(String s); 
    254      
     254 
    255255    public abstract void removeVar(String name); 
    256256 
    257257    public abstract void setTopLevel(); 
    258      
     258 
    259259    // Fix the untyped variable 
    260260    public abstract void storeType(HasAt x, String sname, FType ft); 
    … …  
    266266    public abstract void visit(Visitor2<String, Object> nameCollector); 
    267267    /** 
    268      * Returns the names of vars in the most recently added frame (everything  
     268     * Returns the names of vars in the most recently added frame (everything 
    269269     * added since this environment was created with a call to "extend()" ). 
    270270     */ 
    271      
     271 
    272272    public Iterable<String> youngestFrame() ; 
    273    
     273 
    274274    /** 
    275275     * Level-tagged version of getValueRaw 
    276      *  
     276     * 
    277277     * @param s 
    278278     * @param level 
    … …  
    280280     */ 
    281281    public FValue getValueRaw(String s, int level); 
    282      
     282 
    283283    public Environment getApi(String s); 
    284284    public Environment getApi(APIName s); 
    285     public Environment getApi(List<Id> s);     
     285    public Environment getApi(List<Id> s); 
    286286    public Environment getApiNull(String apiName); 
    287287    public void putApi(String apiName, Environment env); 
    288      
     288 
    289289    public Environment getHomeEnvironment(IdOrOpOrAnonymousName ioooan); 
    290      
     290 
    291291    public Environment getTopLevel(); 
    292292} 

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

    r3123 r3132  
    8989import com.sun.fortress.nodes.Do; 
    9090import com.sun.fortress.nodes.DoFront; 
    91 import com.sun.fortress.nodes.Enclosing; 
    9291import com.sun.fortress.nodes.Exit; 
    9392import com.sun.fortress.nodes.ExponentiationMI; 
    … …  
    121120import com.sun.fortress.nodes.Op; 
    122121import com.sun.fortress.nodes.OpExpr; 
    123 import com.sun.fortress.nodes.OpName; 
    124122import com.sun.fortress.nodes.OpRef; 
    125123import com.sun.fortress.nodes.Param; 
    … …  
    252250            // be no fear of duplicate evaluation. 
    253251            OpRef opr_ = possOp.unwrap(); 
    254             //OpName opr = opr_.getOriginalName(); 
     252            //Op opr = opr_.getOriginalName(); 
    255253            Fcn fcn = (Fcn) getOp(opr_);// opr.accept(this); 
    256254            FValue lhsValue; 
    … …  
    10591057        OpRef ref = expr.getOp(); 
    10601058 
    1061             OpName name = ref.getOriginalName(); 
     1059            Op name = ref.getOriginalName(); 
    10621060            if (!(name instanceof Op)) return false; 
    10631061            else return (((Op)name).getText().equals("^") || 
    … …  
    10851083        OpRef ref = x.getOp(); 
    10861084 
    1087         OpName op = ref.getOriginalName(); 
     1085        Op op = ref.getOriginalName(); 
    10881086        List<Expr> args = x.getArgs(); 
    10891087        FValue fvalue = getOp(ref); //op.accept(this); 
    … …  
    11331131        } 
    11341132        Fcn fcn = (Fcn) fvalue; 
    1135         if (s <= 2 || (op instanceof Enclosing)) { 
     1133        if (s <= 2 || op.isEnclosing()) { 
    11361134            res = functionInvocation(vargs, fcn, x); 
    11371135        } else { 
    … …  
    11711169        FValue arr = obj.accept(this); 
    11721170        List<FValue> subs = evalExprListParallel(x.getSubs()); 
    1173         Option<Enclosing> op = x.getOp(); 
     1171        Option<Op> op = x.getOp(); 
    11741172        // Should evaluate obj.[](subs, getText) 
    11751173        String opString = "[]"; 
    … …  
    12721270        if (opr instanceof ExponentiationMI) { 
    12731271            ExponentiationMI expo = (ExponentiationMI)opr; 
    1274             OpName op = expo.getOp().getOriginalName(); 
     1272            Op op = expo.getOp().getOriginalName(); 
    12751273            FValue fvalue = getOp(expo.getOp()); //op.accept(this); 
    12761274            if (!isFunction(fvalue)) 

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

    r3123 r3132  
    4444import com.sun.fortress.nodes.AbstractFieldRef; 
    4545import com.sun.fortress.nodes.Name; 
     46import com.sun.fortress.nodes.Op; 
    4647import com.sun.fortress.nodes.NodeAbstractVisitor; 
    4748import com.sun.fortress.nodes.Expr; 
    … …  
    5152import com.sun.fortress.nodes.LValue; 
    5253import com.sun.fortress.nodes.SubscriptExpr; 
    53 import com.sun.fortress.nodes.Enclosing; 
    5454import com.sun.fortress.nodes.TupleExpr; 
    5555import com.sun.fortress.nodes.Type; 
    … …  
    7777        args.add(value); 
    7878        args.addAll(indices); 
    79         Option<Enclosing> op = x.getOp(); 
     79        Option<Op> op = x.getOp(); 
    8080        // Should evaluate obj.[](subs, value) 
    8181        String opString = "[]="; 

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

    r3096 r3132  
    2626import com.sun.fortress.nodes.NodeUpdateVisitor; 
    2727import com.sun.fortress.nodes.Op; 
    28 import com.sun.fortress.nodes.OpName; 
    2928import com.sun.fortress.nodes.OpParam; 
    3029import com.sun.fortress.nodes.OpRef; 
    … …  
    6362    @Override 
    6463    public Node forOpRef(OpRef op) { 
    65         final OpName originalName = op.getOriginalName(); 
    66         final List<OpName> ops = op.getOps(); 
     64        final Op originalName = op.getOriginalName(); 
     65        final List<Op> ops = op.getOps(); 
    6766        final List<StaticArg> args = op.getStaticArgs(); 
    6867        final Option<Type> otype = op.getExprType(); 
    6968        final Type type = otype.isNone() ? null : otype.unwrap(); 
    7069 
    71         OpName n_originalName = (OpName) recur(originalName); 
    72         List<OpName> n_ops = recurOnListOfOpName(ops); 
     70        Op n_originalName = (Op) recur(originalName); 
     71        List<Op> n_ops = recurOnListOfOp(ops); 
    7372        List<StaticArg> n_args = recurOnListOfStaticArg(args); 
    7473        Type n_type = type == null ? (Type) null : (Type) recur(type); 

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

    r3123 r3132  
    159159    public String forOp(Op node) { 
    160160        return node.getText(); 
    161     } 
    162  
    163      public String forEnclosing(Enclosing node) { 
    164         return node.getOpen().getText() + node.getClose().getText(); 
    165161    } 
    166162 

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

    r3123 r3132  
    256256 
    257257    public static OpRef makeOpRef(Span span, String name) { 
    258         OpName op = NodeFactory.makeOpInfix(span, name); 
     258        Op op = NodeFactory.makeOpInfix(span, name); 
    259259        return new OpRef(span, op, Collections.singletonList(op)); 
    260260    } 
    261261 
    262     public static OpRef makeOpRef(OpName op) { 
     262    public static OpRef makeOpRef(Op op) { 
    263263        return new OpRef(op.getSpan(), op, Collections.singletonList(op)); 
    264264    } 
    265265 
    266     public static OpRef makeOpRef(OpName op, List<StaticArg> staticArgs) { 
     266    public static OpRef makeOpRef(Op op, List<StaticArg> staticArgs) { 
    267267        return new OpRef(op.getSpan(), staticArgs, op, Collections.singletonList(op)); 
    268268    } 
    … …  
    273273    } 
    274274 
    275     public static OpExpr makeOpExpr(Span span, OpName op) { 
     275    public static OpExpr makeOpExpr(Span span, Op op) { 
    276276        return new OpExpr(span, false, makeOpRef(op)); 
    277277    } 
    278278 
    279     public static OpExpr makeOpExpr(Span span, OpName op, Expr arg) { 
     279    public static OpExpr makeOpExpr(Span span, Op op, Expr arg) { 
    280280        return new OpExpr(span, false, makeOpRef(op), 
    281281                Collections.singletonList(arg)); 
    282282    } 
    283283 
    284     public static OpExpr makeOpExpr(Span span, OpName op, Expr first, 
     284    public static OpExpr makeOpExpr(Span span, Op op, Expr first, 
    285285                                    Expr second) { 
    286286        return new OpExpr(span, false, makeOpRef(op), 
    … …  
    288288    } 
    289289 
    290     public static OpExpr makeOpExpr(Span span, OpName op, List<StaticArg> staticArgs) { 
     290    public static OpExpr makeOpExpr(Span span, Op op, List<StaticArg> staticArgs) { 
    291291        return new OpExpr(span, false, makeOpRef(op, staticArgs)); 
    292292    } 
    293293 
    294     public static OpExpr makeOpExpr(Span span, OpName op, Expr arg, 
     294    public static OpExpr makeOpExpr(Span span, Op op, Expr arg, 
    295295            List<StaticArg> staticArgs) { 
    296296        return new OpExpr(span, false, makeOpRef(op, staticArgs), 
    … …  
    375375            List<Expr> subs) { 
    376376        return new SubscriptExpr(span, false, obj, subs, 
    377                 Option.<Enclosing>none(), 
    378                 Collections.<StaticArg>emptyList()); 
     377                                 Option.<Op>none(), 
     378                                 Collections.<StaticArg>emptyList()); 
    379379    } 
    380380 
    381381    public static SubscriptExpr makeSubscriptExpr(Span span, Expr obj, 
    382             List<Expr> subs, 
    383             Option<Enclosing> op, 
    384             List<StaticArg> sargs) { 
     382                                                  List<Expr> subs, 
     383                                                  Option<Op> op, 
     384                                                  List<StaticArg> sargs) { 
    385385        return new SubscriptExpr(span, false, obj, Useful.immutableTrimmedList(subs), op, sargs); 
    386386    } 
    387387 
    388388    public static SubscriptExpr makeSubscriptExpr(Span span, Expr obj, 
    389             List<Expr> subs, 
    390             Option<Enclosing> op) { 
     389                                                  List<Expr> subs, 
     390                                                  Option<Op> op) { 
    391391        return new SubscriptExpr(span, false, obj, subs, op, 
    392392                Collections.<StaticArg>emptyList()); 
    … …  
    904904     */ 
    905905    private static Expr makeInfixOpExpr(Span s, Expr lhs, OpRef op, Expr rhs) { 
    906      List<OpName> new_ops = CollectUtil.makeList(IterUtil.map(op.getOps(), new Lambda<OpName,OpName>(){ 
    907    public Op value(OpName arg0) { 
    908     if( arg0 instanceof Enclosing ) 
     906     List<Op> new_ops = CollectUtil.makeList(IterUtil.map(op.getOps(), new Lambda<Op,Op>(){ 
     907   public Op value(Op arg0) { 
     908       if( arg0.isEnclosing() ) 
    909909     return bug("Can't make an infix operator out of an enclosing operator."); 
    910910    else 
    … …  
    913913     // We are remaking this because we think that the Interpreter expects originalName to be infix 
    914914     Op new_original_name; 
    915      if( op.getOriginalName() instanceof Enclosing ) 
     915     if( op.getOriginalName().isEnclosing() ) 
    916916      return bug("Can't make an infix operator out of an enclosing operator."); 
    917917     else 
    … …  
    923923 
    924924    private static Expr makePostfixOpExpr(Span s, Expr e, OpRef op) { 
    925      List<OpName> new_ops = CollectUtil.makeList(IterUtil.map(op.getOps(), new Lambda<OpName,OpName>(){ 
    926    public Op value(OpName arg0) { 
    927     if( arg0 instanceof Enclosing ) 
     925     List<Op> new_ops = CollectUtil.makeList(IterUtil.map(op.getOps(), new Lambda<Op,Op>(){ 
     926   public Op value(Op arg0) { 
     927       if( arg0.isEnclosing() ) 
    928928     return bug("Can't make an postfix operator out of an enclosing operator."); 
    929929    else 
    … …  
    932932     // We are remaking this because we think that the Interpreter expects originalName to be postfix 
    933933     Op new_original_name; 
    934      if( op.getOriginalName() instanceof Enclosing ) 
     934     if( op.getOriginalName().isEnclosing() ) 
    935935      return bug("Can't make an postfix operator out of an enclosing operator."); 
    936936     else 

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

    r3123 r3132  
    137137    public final static IdComparer idComparer = new IdComparer(); 
    138138 
    139     static class OpNameComparer implements Comparator<OpName> { 
    140         public int compare(OpName left, OpName right) { 
    141             return NodeComparator.compare(left, right); 
    142         } 
    143     } 
    144  
    145     public final static OpNameComparer opNameComparer = new OpNameComparer(); 
     139    static class OpComparer implements Comparator<Op> { 
     140        public int compare(Op left, Op right) { 
     141            return NodeComparator.compare(left, right); 
     142        } 
     143    } 
     144 
     145    public final static OpComparer opNameComparer = new OpComparer(); 
    146146 
    147147    /* comparing lists ***************************************************/ 

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

    r3123 r3132  
    173173    } 
    174174 
    175     public static OpName makeTemporaryOpName() { 
     175    public static Op makeTemporaryOp() { 
    176176        return makeOp("$$bogus_name$$"); 
    177177    } 
    … …  
    222222 
    223223    public static AliasedSimpleName makeAliasedSimpleName(Span span, 
    224             IdOrOpOrAnonymousName name) { 
     224                                                          IdOrOpOrAnonymousName name) { 
    225225        return new AliasedSimpleName(span, name, Option.<IdOrOpOrAnonymousName>none()); 
    226226    } 
    227227 
    228228    public static AliasedSimpleName makeAliasedSimpleName(Span span, 
    229             IdOrOpOrAnonymousName name, 
    230             Id alias) { 
     229                                                          IdOrOpOrAnonymousName name, 
     230                                                          Id alias) { 
    231231        return new AliasedSimpleName(span, name, 
    232                 Option.<IdOrOpOrAnonymousName>some(alias)); 
     232                                     Option.<IdOrOpOrAnonymousName>some(alias)); 
    233233    } 
    234234 
    … …  
    238238 
    239239    public static AliasedSimpleName makeAliasedSimpleName(Span span, Id id, 
    240             Id alias) { 
     240                                                          Id alias) { 
    241241        return new AliasedSimpleName(span, id, Option.<IdOrOpOrAnonymousName>some(alias)); 
    242242    } 
    243243 
    244244    /** Alternatively, you can invoke the FnDecl constructor without an alias */ 
    245     public static AliasedSimpleName makeAliasedSimpleName(Span span, OpName op) { 
     245    public static AliasedSimpleName makeAliasedSimpleName(Span span, Op op) { 
    246246        return new AliasedSimpleName(span, op, Option.<IdOrOpOrAnonymousName>none()); 
    247247    } 
    248248 
    249     public static AliasedSimpleName makeAliasedSimpleName(Span span, OpName op, 
    250             OpName alias) { 
     249    public static AliasedSimpleName makeAliasedSimpleName(Span span, Op op, 
     250                                                          Op alias) { 
    251251        return new AliasedSimpleName(span, op, Option.<IdOrOpOrAnonymousName>some(alias)); 
    252252    } 
    … …  
    840840    } 
    841841 
    842     public static Enclosing makeEnclosing(Span in_span, Op in_open, Op in_close) { 
    843         return new Enclosing(in_span, in_open, in_close); 
     842    public static Op makeEnclosing(Span in_span, String in_open, String in_close) { 
     843        return new Op(in_span, PrecedenceMap.ONLY.canon(in_open + " " + in_close), 
     844                      enclosing, true); 
    844845    } 
    845846 
    … …  
    855856 
    856857    public static Op makeOp(String name) { 
    857         return new Op(new Span(), PrecedenceMap.ONLY.canon(name), unknownFix); 
     858        return new Op(new Span(), PrecedenceMap.ONLY.canon(name), unknownFix, false); 
    858859    } 
    859860 
    860861    public static Op makeOp(Span span, String name) { 
    861         return new Op(span, PrecedenceMap.ONLY.canon(name), unknownFix); 
     862        return new Op(span, PrecedenceMap.ONLY.canon(name), unknownFix, false); 
    862863    } 
    863864 
    864865    public static Op makeOp(Span span, String name, Fixity fixity) { 
    865         return new Op(span, PrecedenceMap.ONLY.canon(name), fixity); 
     866        return new Op(span, PrecedenceMap.ONLY.canon(name), fixity, false); 
    866867    } 
    867868 
    868869    public static Op makeOp(Op op, String name) { 
    869870        return new Op(op.getSpan(), PrecedenceMap.ONLY.canon(name), 
    870                 op.getFixity()); 
     871                      op.getFixity(), op.isEnclosing()); 
    871872    } 
    872873 
    873874    public static Op makeOpInfix(Span span, String name) { 
    874         return new Op(span, PrecedenceMap.ONLY.canon(name), infix); 
     875        return new Op(span, PrecedenceMap.ONLY.canon(name), infix, false); 
    875876    } 
    876877 
    877878    public static Op makeOpInfix(Span span, String apiName, String name) { 
    878         Op op =  new Op(span, Option.some(NodeFactory.makeAPIName(apiName)), PrecedenceMap.ONLY.canon(name), infix); 
     879        Op op =  new Op(span, Option.some(NodeFactory.makeAPIName(apiName)), 
     880                        PrecedenceMap.ONLY.canon(name), infix, false); 
    879881        return op; 
    880882 
    … …  
    882884 
    883885    public static Op makeOpInfix(Op op) { 
    884         return new Op(op.getSpan(), op.getApiName(), op.getText(), infix); 
     886        return new Op(op.getSpan(), op.getApiName(), op.getText(), infix, op.isEnclosing()); 
    885887    } 
    886888 
    887889    public static Op makeOpPrefix(Span span, String name) { 
    888         return new Op(span, PrecedenceMap.ONLY.canon(name), prefix); 
     890        return new Op(span, PrecedenceMap.ONLY.canon(name), prefix, false); 
    889891    } 
    890892 
    891893    public static Op makeOpPrefix(Op op) { 
    892         return new Op(op.getSpan(), op.getApiName(), op.getText(), prefix); 
     894        return new Op(op.getSpan(), op.getApiName(), op.getText(), prefix, op.isEnclosing()); 
    893895    } 
    894896 
    895897    public static Op makeOpPostfix(Span span, String name) { 
    896         return new Op(span, PrecedenceMap.ONLY.canon(name), postfix); 
     898        return new Op(span, PrecedenceMap.ONLY.canon(name), postfix, false); 
    897899    } 
    898900 
    899901    public static Op makeOpPostfix(Op op) { 
    900         return new Op(op.getSpan(), op.getApiName(), op.getText(), postfix); 
     902        return new Op(op.getSpan(), op.getApiName(), op.getText(), postfix, op.isEnclosing()); 
    901903    } 
    902904 
    903905    /** 
    904      * Rewrites the given OpName with the given api. Dispatches on the 
    905      * type of op, so that the same subtype of OpName is created. 
     906     * Rewrites the given Op with the given api. Dispatches on the 
     907     * type of op, so that the same subtype of Op is created. 
    906908     */ 
    907     public static OpName makeOpName(final APIName api, OpName op) { 
    908         return op.accept(new NodeAbstractVisitor<OpName>(){ 
    909             @Override 
    910             public OpName forEnclosing(Enclosing that) { return new Enclosing(that.getSpan(), Option.some(api), that.getOpen(), that.getClose()); } 
    911             @Override 
    912             public OpName forOp(Op that) { return new Op(that.getSpan(), Option.some(api), that.getText(), that.getFixity() ); } 
    913             @Override 
    914             public OpName forOpName(OpName that) { return bug("A case was missed in the implementation of makeOpName."); } 
    915  
    916         }); 
     909    public static Op makeOp(final APIName api, Op op) { 
     910        return new Op(op.getSpan(), Option.some(api), 
     911                      op.getText(), op.getFixity(), op.isEnclosing() ); 
    917912    } 
    918913 
    919914    public static Op makeOpNofix(Op op) { 
    920         return new Op(op.getSpan(), op.getText(), nofix); 
     915        return new Op(op.getSpan(), op.getText(), nofix, op.isEnclosing()); 
    921916    } 
    922917 
    923918    public static Op makeOpMultifix(Op op) { 
    924         return new Op(op.getSpan(), op.getText(), multifix); 
     919        return new Op(op.getSpan(), op.getText(), multifix, op.isEnclosing()); 
    925920    } 
    926921 
    927922    public static Op makeOpEnclosing(Span span, String name) { 
    928         return new Op(span, PrecedenceMap.ONLY.canon(name), enclosing); 
     923        return new Op(span, PrecedenceMap.ONLY.canon(name), enclosing, false); 
    929924    } 
    930925 
    931926    public static Op makeOpBig(Span span, String name) { 
    932         return new Op(span, PrecedenceMap.ONLY.canon(name), big); 
     927        return new Op(span, PrecedenceMap.ONLY.canon(name), big, false); 
    933928    } 
    934929 
    935930    public static Op makeOpUnknown(Span span, String name) { 
    936         return new Op(span, PrecedenceMap.ONLY.canon(name), unknownFix); 
    937     } 
    938  
    939         public static Op makeBig(Op op) { 
    940             return new Op(op.getSpan(), PrecedenceMap.ONLY.canon("BIG " + op.getText()), big); 
    941         } 
    942  
    943         public static Enclosing makeBig(Enclosing op) { 
    944             return new Enclosing(op.getSpan(), makeBig(op.getOpen()), makeBig(op.getClose())); 
    945         } 
     931        return new Op(span, PrecedenceMap.ONLY.canon(name), unknownFix, false); 
     932    } 
     933 
     934    public static Op makeBig(Op op) { 
     935        if ( op.isEnclosing() ) { 
     936            String _op = op.getText(); 
     937            String left  = _op.split(" ")[0]; 
     938            String right = "BIG " + _op.substring(left.length()+1); 
     939            left  = "BIG " + left; 
     940            return makeEnclosing(op.getSpan(), left, right); 
     941        } else 
     942            return new Op(op.getSpan(), PrecedenceMap.ONLY.canon("BIG " + op.getText()), big, op.isEnclosing() ); 
     943    } 
    946944 
    947945    public static Param makeVarargsParam(Id name, Type type) { 
    … …  
    13231321    } 
    13241322 
    1325     public static OpName makeListOpName(Span span) { 
    1326         Op open = NodeFactory.makeOpEnclosing(span, "<|"); 
    1327         Op close = NodeFactory.makeOpEnclosing(span, "|>"); 
    1328         return new Enclosing(FortressUtil.spanTwo(open,close), open,close); 
     1323    public static Op makeListOp(Span span) { 
     1324        return makeEnclosing(span, "<|", "|>"); 
    13291325    } 
    13301326 

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

    r3123 r3132  
    216216        } 
    217217        public String forOp(Op n) { 
    218             return OprUtil.fixityDecorator(n.getFixity(), n.getText()); 
    219         } 
    220         public String forEnclosing(Enclosing n) { 
    221             // Interior space is REQUIRED 
    222             return n.getOpen().getText() + " " + n.getClose().getText(); 
     218            if ( n.isEnclosing() ) 
     219                return n.getText(); 
     220            else return OprUtil.fixityDecorator(n.getFixity(), n.getText()); 
    223221        } 
    224222        public String forAnonymousFnName(AnonymousFnName n) { 
    … …  
    246244        } 
    247245        public String forOp(Op n) { 
    248             Option<APIName> odn = n.getApiName(); 
    249             String last = OprUtil.fixityDecorator(n.getFixity(), n.getText()); 
    250             return odn.isSome() ? nameString(odn.unwrap()) + "." + last : last; 
    251         } 
    252         public String forEnclosing(Enclosing n) { 
    253             Option<APIName> odn = n.getApiName(); 
    254             // Interior space is REQUIRED 
    255             String last = n.getOpen().getText() + " " + n.getClose().getText(); 
    256             return odn.isSome() ? nameString(odn.unwrap()) + "." + last : last; 
    257  
     246            if ( n.isEnclosing() ) { 
     247                Option<APIName> odn = n.getApiName(); 
     248                String last = n.getText(); 
     249                return odn.isSome() ? nameString(odn.unwrap()) + "." + last : last; 
     250            } else { 
     251                Option<APIName> odn = n.getApiName(); 
     252                String last = OprUtil.fixityDecorator(n.getFixity(), n.getText()); 
     253                return odn.isSome() ? nameString(odn.unwrap()) + "." + last : last; 
     254            } 
    258255        } 
    259256        public String forAnonymousFnName(AnonymousFnName n) { 
    … …  
    310307 
    311308    public static String nameString(Op n) { 
    312         return OprUtil.fixityDecorator(n.getFixity(), n.getText()); 
    313     } 
    314  
    315     public static String nameString(Enclosing n) { 
    316         // Interior space is REQUIRED 
    317         return n.getOpen().getText() + " " + n.getClose().getText(); 
     309        if ( n.isEnclosing() ) 
     310            return n.getText(); 
     311        else return OprUtil.fixityDecorator(n.getFixity(), n.getText()); 
    318312    } 
    319313    public static String nameString(AnonymousFnName n) { 
    … …  
    373367            @Override 
    374368            public String forOp(Op that) { 
    375                return OprUtil.fixityDecorator(that.getFixity(), that.getText()); 
    376             } 
    377             @Override 
    378             public String forEnclosing(Enclosing that) { 
    379                 String o = that.getOpen().accept(this); 
    380                 String c = that.getClose().accept(this); 
    381                 return o + " " + c; 
     369                if ( that.isEnclosing() ) 
     370                    return that.getText(); 
     371                else return OprUtil.fixityDecorator(that.getFixity(), that.getText()); 
    382372            } 
    383373            @Override 

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

    r3120 r3132  
    1818package com.sun.fortress.nodes_util; 
    1919 
    20 import com.sun.fortress.nodes.Enclosing; 
    2120import com.sun.fortress.nodes.Fixity; 
    2221import com.sun.fortress.nodes.Node; 
    2322import com.sun.fortress.nodes.NodeAbstractVisitor; 
    2423import com.sun.fortress.nodes.Op; 
    25 import com.sun.fortress.nodes.OpName; 
    2624import com.sun.fortress.nodes.UnknownFixity; 
    2725import com.sun.fortress.nodes.PostFixity; 
    … …  
    3028 
    3129public final class OprUtil { 
    32     public static boolean isEnclosing(OpName op) { 
    33         return (op instanceof Enclosing); 
     30    public static boolean isEnclosing(Op op) { 
     31        return op.isEnclosing(); 
    3432    } 
    3533 
    36     private static boolean isNotEnclosing(OpName op) { 
     34    private static boolean isNotEnclosing(Op op) { 
    3735        return !(isEnclosing(op)); 
    3836    } 
    3937 
    4038    public static boolean isUnknownFixity(Op name) { 
     39        if (name.isEnclosing()) 
     40            return false; 
    4141        return name.getFixity() instanceof UnknownFixity; 
    4242    } 
    4343 
    44     public static boolean isUnknownFixity(OpName name) { 
    45         if (name instanceof Enclosing) 
     44    public static boolean isPostfix(Op name) { 
     45        if (name.isEnclosing()) 
    4646            return false; 
    47         return isUnknownFixity((Op)name); 
    48     } 
    49  
    50     private static boolean isPostfix(Op name) { 
    5147        return name.getFixity() instanceof PostFixity; 
    5248    } 
    5349 
    54     public static boolean isPostfix(OpName name) { 
    55         if (name instanceof Enclosing) 
    56             return false; 
    57         return isPostfix((Op)name); 
    58     } 
    59  
    60     public static Op getOp(OpName op) { 
     50    public static Op getOp(Op op) { 
    6151        if (isEnclosing(op)) { 
    62             return ((Enclosing)op).getOpen(); 
     52            String open  = op.getText().split(" ")[0]; 
     53            return NodeFactory.makeOpInfix(op.getSpan(), open); 
    6354        } else { // op instanceof Op 
    6455            return (Op)op; 
    … …  
    6657    } 
    6758 
    68     public static boolean hasPrefixColon(Op op) { 
    69         String opName = op.getText(); 
    70         return (opName.length()>1 && opName.charAt(0)==':' && !opName.equals("::")); 
    71     } 
    72  
    73     public static boolean hasPrefixColon(OpName n) { 
     59    public static boolean hasPrefixColon(Op n) { 
    7460        if (isNotEnclosing(n)) { 
    75             return hasPrefixColon((Op)n); 
     61            String opName = n.getText(); 
     62            return (opName.length()>1 && opName.charAt(0)==':' && !opName.equals("::")); 
    7663        } else { 
    7764            return false; 
    … …  
    7966    } 
    8067 
    81     public static boolean hasSuffixColon(Op op) { 
    82         String opName = op.getText(); 
    83         int l = opName.length(); 
    84         return (l>1 && opName.charAt(l-1)==':' && !opName.equals("::")); 
    85     } 
    86  
    87     public static boolean hasSuffixColon(OpName n) { 
     68    public static boolean hasSuffixColon(Op n) { 
    8869        if (isNotEnclosing(n)) { 
    89             return hasSuffixColon((Op)n); 
     70            String opName = n.getText(); 
     71            int l = opName.length(); 
     72            return (l>1 && opName.charAt(l-1)==':' && !opName.equals("::")); 
    9073        } else { 
    9174            return false; 
    … …  
    9376    } 
    9477 
    95     public static String noColonText(Op op) { 
    96         String opName = op.getText(); 
    97         int l = opName.length(); 
    98         int i = 0; 
    99         if (hasSuffixColon(op)) { 
    100             l--; 
    101         } 
    102         if (hasPrefixColon(op)) { 
    103             i++; 
    104         } 
    105         if (l < opName.length()) { 
    106             opName = opName.substring(i,l); 
    107         } 
    108         return opName; 
    109     } 
    110  
    111     public static String noColonText(OpName n) { 
     78    public static String noColonText(Op n) { 
    11279        if (isNotEnclosing(n)) { 
    113             return noColonText((Op)n); 
     80            String opName = n.getText(); 
     81            int l = opName.length(); 
     82            int i = 0; 
     83            if (hasSuffixColon(n)) { 
     84                l--; 
     85            } 
     86            if (hasPrefixColon(n)) { 
     87                i++; 
     88            } 
     89            if (l < opName.length()) { 
     90                opName = opName.substring(i,l); 
     91            } 
     92            return opName; 
    11493        } else { 
    11594            return getOp(n).getText(); 
    … …  
    11796    } 
    11897 
    119     public static Op noColon(Op op) { 
    120         if (hasSuffixColon(op) || hasPrefixColon(op)) { 
    121             return NodeFactory.makeOp(op.getSpan(),noColonText(op), 
    122                                       op.getFixity()); 
    123         } 
    124         return op; 
    125     } 
    126  
    127     public static OpName noColon(OpName n) { 
     98    public static Op noColon(Op n) { 
    12899        if (isNotEnclosing(n)) { 
    129             Op op = noColon((Op)n); 
     100            Op op = n; 
     101            if (hasSuffixColon(op) || hasPrefixColon(op)) { 
     102                op = NodeFactory.makeOp(op.getSpan(),noColonText(op), 
     103                                        op.getFixity()); 
     104            } 
    130105            if (op != n) return op; 
    131106        } 
    … …  
    164139    /** Return a new operator with the fixity prepended to the text. */ 
    165140    public static Op decorateOperator(Op o) { 
    166         return new Op(o.getSpan(), fixityDecorator(o.getFixity(), o.getText()), o.getFixity()); 
     141        return new Op(o.getSpan(), fixityDecorator(o.getFixity(), o.getText()), o.getFixity(), o.isEnclosing()); 
    167142    } 
    168143 
    … …  
    173148            return o; 
    174149        } 
    175         return new Op(o.getSpan(), o.getText().substring(i+1), o.getFixity()); 
     150        return new Op(o.getSpan(), o.getText().substring(i+1), o.getFixity(), o.isEnclosing()); 
    176151    } 
    177152 

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

    r3111 r3132  
    329329     a3:GeneratorClauseList w closecurly 
    330330     { Span span = createSpan(yyStart,yyCount); 
    331        Op open  = NodeFactory.makeOpBig(span, "BIG {|->"); 
    332        Op close = NodeFactory.makeOpBig(span, "BIG }"); 
    333        OpName opr = new Enclosing(span, open, close); 
     331       Op opr = NodeFactory.makeEnclosing(span, "BIG {|->", "BIG }"); 
    334332       if (a1 == null) a1 = Collections.<StaticArg>emptyList(); 
    335333       yyValue = new Accumulator(createSpan(yyStart,yyCount), a1, opr, a3, a2); 
    … …  
    338336     a4:GeneratorClauseList w a5:RightEncloser 
    339337     { Span span = createSpan(yyStart,yyCount); 
    340        Op open  = NodeFactory.makeOpBig(span, "BIG " + a1.getText()); 
    341        Op close = NodeFactory.makeOpBig(span, "BIG " + a5.getText()); 
    342        OpName opr = new Enclosing(span, open, close); 
     338       Op opr = NodeFactory.makeEnclosing(span, "BIG " + a1.getText(), 
     339                                          "BIG " + a5.getText()); 
    343340       if (a2 == null) a2 = Collections.<StaticArg>emptyList(); 
    344341       yyValue = new Accumulator(createSpan(yyStart,yyCount), a2, opr, a4, a3); 

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

    r2840 r3132  
    133133             if (a3 == null) es = FortressUtil.emptyExprs(); 
    134134             else            es = a3; 
    135              Enclosing op = new Enclosing(FortressUtil.spanTwo(a1,a4),a1,a4); 
     135             Op op = NodeFactory.makeEnclosing(FortressUtil.spanTwo(a1,a4), 
     136                                               a1.getText(),a4.getText()); 
    136137             return ExprFactory.makeSubscriptExpr(span,base,es,Option.some(op), 
    137138                                                  sargs); 
    … …  
    465466                   if (a2 == null) ss = Collections.<StaticArg>emptyList(); 
    466467                   else            ss = a2; 
    467                    return FortressUtil.makeSubscripting(span,spanOpen,spanClose, 
     468                   return FortressUtil.makeSubscripting(span, 
    468469                                                        a1, a4, base, a3, ss); 
    469470               } else return syntaxError(span, 
    … …  
    484485               if (a2 == null) ss = Collections.<StaticArg>emptyList(); 
    485486               else            ss = a2; 
    486                return FortressUtil.makeSubscripting(span, base, a1, a4, a3, ss); 
     487               return FortressUtil.makeSubscripting(span, base, a1.getText(), 
     488                                                    a4.getText(), a3, ss); 
    487489           }}; 
    488490     }; 
    … …  
    587589     { Span span = createSpan(yyStart,yyCount); 
    588590       if (PrecedenceMap.ONLY.matchedBrackets(a1, a4)) { 
    589          Span spanOpen = createSpan(yyStart, yyStart+1); 
    590          Span spanClose = createSpan(yyCount-1,1); 
    591          Op open  = NodeFactory.makeOpEnclosing(spanOpen, a1); 
    592          Op close = NodeFactory.makeOpEnclosing(spanClose, a4); 
    593          Enclosing op = new Enclosing(FortressUtil.spanTwo(open,close), 
    594                                       open,close); 
    595          if (a2 == null) a2 = Collections.<StaticArg>emptyList(); 
    596          if (a3 == null) a3 = Collections.<Expr>emptyList(); 
    597          yyValue = new SubscriptingMI(span, op, a3, a2); 
     591           Op op = NodeFactory.makeEnclosing(span, a1, a4); 
     592           if (a2 == null) a2 = Collections.<StaticArg>emptyList(); 
     593           if (a3 == null) a3 = Collections.<Expr>emptyList(); 
     594           yyValue = new SubscriptingMI(span, op, a3, a2); 
    598595       } else return syntaxError(span, 
    599596                                 "Mismatched subscripting operator: " + a1 + 
    … …  
    607604   / a1:LeftEncloser a2:StaticArgs? a3:(w ExprList)? w a4:RightEncloser 
    608605     { Span span = createSpan(yyStart,yyCount); 
    609        Enclosing op = new Enclosing(FortressUtil.spanTwo(a1,a4),a1,a4); 
     606       Op op = NodeFactory.makeEnclosing(span, a1.getText(),a4.getText()); 
    610607       if (a2 == null) a2 = Collections.<StaticArg>emptyList(); 
    611608       if (a3 == null) a3 = Collections.<Expr>emptyList(); 
    … …  
    683680     { Span span = createSpan(yyStart,yyCount); 
    684681       if (a1 == null) a1 = Collections.<StaticArg>emptyList(); 
    685        Op open  = NodeFactory.makeOpBig(span, "BIG {|->"); 
    686        Op close = NodeFactory.makeOpBig(span, "BIG }"); 
    687        OpName opr = new Enclosing(span, open, close); 
     682       Op opr = NodeFactory.makeEnclosing(span, "BIG {|->", "BIG }"); 
    688683       yyValue = ExprFactory.makeOpExpr(span, opr, a2, a1); 
    689684     } 
    … …  
    691686     { Span span = createSpan(yyStart,yyCount); 
    692687       if (a2 == null) a2 = Collections.<StaticArg>emptyList(); 
    693        Op open  = NodeFactory.makeOpBig(span, "BIG " + a1.getText()); 
    694        Op close = NodeFactory.makeOpBig(span, "BIG " + a3.getText()); 
    695        OpName opr = new Enclosing(span, open, close); 
     688       Op opr = NodeFactory.makeEnclosing(span, "BIG " + a1.getText(), 
     689                                          "BIG " + a3.getText()); 
    696690       yyValue = ExprFactory.makeOpExpr(span, opr, a4, a2); 
    697691     } 

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

    r3034 r3132  
    5656 
    5757/* IdOrOpName ::= Id | OpName */ 
    58 IdOrOpName IdOrOpName = Id / OpName ; 
     58IdOrOp IdOrOpName = Id / OpName ; 
    5959 
    6060/* BindId ::= Id | _ */ 

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

    r3107 r3132  
    8585           (right.equals("}") || right.equals("\u007d"))) { 
    8686           if (big != null) { 
    87                leftOp = NodeFactory.makeOpBig(leftOp.getSpan(), "BIG " + left); 
    88                opa4 = NodeFactory.makeOpBig(opa4.getSpan(), "BIG " + right); 
     87               left  = "BIG " + left; 
     88               right = "BIG " + right; 
    8989           } 
    90            name = new Enclosing(span, leftOp, opa4); 
     90           name = NodeFactory.makeEnclosing(span, left, right); 
    9191       } else 
    9292           name = syntaxError(leftOp.getSpan(), 
    … …  
    123123           left.equals("{|->") && right.equals("}")) { 
    124124           if (big != null) { 
    125                leftOp = NodeFactory.makeOpBig(leftOp.getSpan(), "BIG " + left); 
    126                opa4 = NodeFactory.makeOpBig(opa4.getSpan(), "BIG " + right); 
     125               left  = "BIG " + left; 
     126               right = "BIG " + right; 
    127127           } 
    128            name = new Enclosing(span, leftOp, opa4); 
     128           name = NodeFactory.makeEnclosing(span, left, right); 
    129129       } else 
    130130           name = syntaxError(leftOp.getSpan(), 

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

    r3034 r3132  
    1  /******************************************************************************* 
     1/******************************************************************************* 
    22    Copyright 2008 Sun Microsystems, Inc., 
    33    4150 Network Circle, Santa Clara, California 95054, U.S.A. 

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

    r3107 r3132  
    165165           (right.equals("}") || right.equals("\u007d"))) { 
    166166           if (big != null) { 
    167                leftOp = NodeFactory.makeOpBig(leftOp.getSpan(), "BIG " + left); 
    168                opa4 = NodeFactory.makeOpBig(opa4.getSpan(), "BIG " + right); 
     167               left  = "BIG " + left; 
     168               right = "BIG " + right; 
    169169           } 
    170            name = new Enclosing(span, leftOp, opa4); 
     170           name = NodeFactory.makeEnclosing(span, left, right); 
    171171       } else 
    172172           name = syntaxError(leftOp.getSpan(), 
    … …  
    239239           left.equals("{|->") && right.equals("}")) { 
    240240           if (big != null) { 
    241                leftOp = NodeFactory.makeOpBig(leftOp.getSpan(), "BIG " + left); 
    242                opa4 = NodeFactory.makeOpBig(opa4.getSpan(), "BIG " + right); 
     241               left  = "BIG " + left; 
     242               right = "BIG " + right; 
    243243           } 
    244            name = new Enclosing(span, leftOp, opa4); 
     244           name = NodeFactory.makeEnclosing(span, left, right); 
    245245       } else 
    246246           name = syntaxError(leftOp.getSpan(), 

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

    r3032 r3132  
    4747     (LeftEncloser | Encloser) (w DOT)? w (RightEncloser | Encloser) 
    4848 */ 
    49 Enclosing EncloserPair = 
     49Op EncloserPair = 
    5050     a1:(LeftEncloser / Encloser) (w DOT)? w a2:(RightEncloser / Encloser) 
    5151     { if (PrecedenceMap.ONLY.matchedBrackets(a1.getText(), a2.getText())) 
    52            yyValue = new Enclosing(createSpan(yyStart,yyCount), a1, a2); 
     52