Changeset 3101

Timestamp:

11/25/08 10:43:53 (12 months ago)

Author:

sukyoungryu

Message:

[ast refactoring] Eliminated nodes that extended concrete classes: _RewriteAssignment, _RewriteInstantiatedFnRefs, _RewriteInstantiatedOpRefs, and _RewriteCaseClause

Location:

trunk/ProjectFortress

Files:

• astgen/Fortress.ast (modified) (4 diffs)
• src/com/sun/fortress/compiler/OverloadRewriteVisitor.java (modified) (4 diffs)
• src/com/sun/fortress/compiler/desugarer/DesugaringVisitor.java (modified) (2 diffs)
• src/com/sun/fortress/compiler/typechecker/TypeChecker.java (modified) (27 diffs)
• src/com/sun/fortress/nodes_util/ExprFactory.java (modified) (1 diff)
• src/com/sun/fortress/tools/FortressAstToConcrete.java (modified) (6 diffs)

trunk/ProjectFortress/astgen/Fortress.ast

@@ -693 +693 @@
              * AssignOp ::= := | Op=
              * e.g.) x += 1
-             */
-            Assignment(List<Lhs> lhs, Option<OpRef> opr, Expr rhs);
-                /**
-                 * An assignment that has passed typechecking, and uses an operator.
-                 * Because different static args can be inferred for each Lhs assignment
-                 * opr, this node gives a separate OpRef for each Lhs.
-                 */
-                _RewriteAssignment(List<OpRef> opsForLhs);
+             *
+             * <opsForLhs>
+             * An assignment that has passed typechecking, and uses an operator.
+             * Because different static args can be inferred for each Lhs assignment
+             * opr, this node gives a separate OpRef for each Lhs.
+             */
+            Assignment(List<Lhs> lhs, Option<OpRef> opr, Expr rhs,
+                       Option<List<OpRef>> opsForLhs = Option.<List<OpRef>>none());
             /**
              * sequence of block elements implicitly enclosed by do/end
@@ -1087 +1087 @@
                          * Primary ::= Id[\StaticArgList\]
                          * e.g.) identity[\String\]
+                         *
+                         * <overloadings>
+                         * A list of FnRefs used for infering static arguments. Used only between the two
+                         * passes of the typechecker. Indicates that one of these FnRefs, which each have
+                         * different instantiations of static arguments, should be the correct instantiation.
                          */
                         FnRef(Id originalName,
-                              List<Id> fns = Collections.<Id>singletonList(in_originalName));
-                            /**
-                             * A list of FnRefs used for infering static arguments. Used only between the two
-                             * passes of the typechecker. Indicates that one of these FnRefs, which each have
-                             * different instantiations of static arguments, should be the correct instantiation.
-                             */
-                            _RewriteInstantiatedFnRefs(List<_RewriteFnRefOverloading> overloadings
-                                                           = Collections.<_RewriteFnRefOverloading>emptyList());
+                              List<Id> fns = Collections.<Id>singletonList(in_originalName),
+                              Option<List<_RewriteFnRefOverloading>> overloadings
+                                  = Option.<List<_RewriteFnRefOverloading>>none());
                         /**
                          * operator name with (inferred) static instantiations
@@ -1102 +1102 @@
                          * Primary ::= Op[\StaticArgList\]
                          * e.g.) +[\String\]
+                         *
+                         * <overloadings>
+                         * Similar to FnRef, this node is used for inferring static
+                         * arguments to an Op call. This node only exists between the first and second
+                         * passes of the typechecker. Holds several different instantiations of static args,
+                         * one of which may be the correct insantiation.
                          */
                         OpRef(OpName originalName,
-                              List<OpName> ops = Collections.<OpName>singletonList(in_originalName));
-                            /**
-                             * Similar to _RewriteInstantiatedFnRefs, this node is used for inferring static
-                             * arguments to an Op call. This node only exists between the first and second
-                             * passes of the typechecker. Holds several different instantiations of static args,
-                             * one of which may be the correct insantiation.
-                             */
-                            _RewriteInstantiatedOpRefs(List<_RewriteOpRefOverloading> overloadings = Collections.<_RewriteOpRefOverloading>emptyList());
+                              List<OpName> ops = Collections.<OpName>singletonList(in_originalName),
+                              Option<List<_RewriteOpRefOverloading>> overloadings
+                                  = Option.<List<_RewriteOpRefOverloading>>none());
                     /**
                      * juxtaposition of expressions
@@ -1978 +1979 @@
          * CaseClause ::= Expr => BlockElems
          * e.g.) { Jupiter, Saturn, Uranus, Neptune } => "outer"
-         */
-        CaseClause(Expr match, Block body);
-            /**
-             * A rewritten case clause that includes the operator that is used for this
-             * particular case. Created in typechecking, because different ops can be
-             * chosen for different clauses.
-             */
-            _RewriteCaseClause(OpRef op);
+         *
+         * <op>
+         * the operator that is used for this particular case.
+         * Created in typechecking,
+         * because different ops can be chosen for different clauses.
+         */
+        CaseClause(Expr match, Block body,
+                   Option<OpRef> op = Option.<OpRef>none());
         /**
          * catch clause used in try expressions

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

@@ -37 +37 @@
     @Override
     public Node forFnRefOnly(FnRef that, Option<Type> exprType_result,
-            List<StaticArg> staticArgs, Id originalName, List<Id> fns) {
+                             List<StaticArg> staticArgs, Id originalName, List<Id> fns,
+                             Option<List<_RewriteFnRefOverloading>> overloadings) {
         if (fns.size() > 1) {
             Collections.<Id>sort(fns, NodeComparator.idComparer);
@@ -57 +58 @@
             fns = Collections.unmodifiableList(Collections.singletonList(overloadingId));
         }
-        return super.forFnRefOnly(that, exprType_result, staticArgs , originalName, fns);
+        return super.forFnRefOnly(that, exprType_result, staticArgs , originalName, fns,
+                                  overloadings);
     }
 
@@ -63 +65 @@
     @Override
     public Node forOpRefOnly(OpRef that, Option<Type> exprType_result,
-            List<StaticArg> staticArgs, OpName originalName, List<OpName> ops) {
+                             List<StaticArg> staticArgs, OpName originalName, List<OpName> ops,
+                             Option<List<_RewriteOpRefOverloading>> overloadings) {
         if (ops.size() > 1) {
             Collections.<OpName>sort(ops, NodeComparator.opNameComparer);
@@ -83 +86 @@
             ops = Collections.unmodifiableList(Collections.singletonList(overloadingOpName));
         }
-        return super.forOpRefOnly(that, exprType_result, staticArgs, originalName, ops);
+        return super.forOpRefOnly(that, exprType_result, staticArgs, originalName, ops,
+                                  overloadings);
     }
 

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

@@ -518 +518 @@
     public Node forFnRefOnly(FnRef that, Option<Type> exprType_result,
                              List<StaticArg> staticArgs_result,
-                             Id fnResult, List<Id> fns_result) {
+                             Id fnResult, List<Id> fns_result,
+                             Option<List<_RewriteFnRefOverloading>> overloadings_result) {
         // After disambiguation, the Id in a FnRef should have an empty API.
         assert(fnResult.getApi().isNone());
@@ -530 +531 @@
             return ExprFactory.makeFnRef(that, exprType_result,
                                          mangleName(fnResult), newFns,
-                                         staticArgs_result);
+                                         staticArgs_result, overloadings_result);
         } else {
             return that;

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

@@ -861 +861 @@
                 TypeCheckerResult arg_result = recur(that.getArgument());
 
-                if( postInference && that.getFunction() instanceof _RewriteInstantiatedFnRefs ) {
+                if( postInference && that.getFunction() instanceof FnRef &&
+                    ((FnRef)that.getFunction()).getOverloadings().isSome() ) {
+                    FnRef fns = (FnRef)that.getFunction();
                         // if we have finished typechecking, and we have encountered a reference to an overloaded function
-                        _RewriteInstantiatedFnRefs fns = (_RewriteInstantiatedFnRefs)that.getFunction();
 
                         if( !arg_result.isSuccessful() ) {
@@ -870 +871 @@
 
                         Type arg_type = arg_result.type().unwrap();
-                        TypeCheckerResult fn_result = findStaticallyMostApplicableFn(destructFnOverloadings(fns.getOverloadings()), arg_type, fns, fns.getOriginalName());
+                        TypeCheckerResult fn_result = findStaticallyMostApplicableFn(destructFnOverloadings(fns.getOverloadings().unwrap()),
+                                                                                     arg_type, fns, fns.getOriginalName());
                         // Now just check the rewritten expression by the normal means
                         return for_RewriteFnAppOnly(that,Option.<TypeCheckerResult>none(), fn_result, arg_result);
@@ -876 +878 @@
                 else {
                         // Add constraints from the arguments, since they may affect overloading choice
-                        TypeCheckerResult fn_result = recur(that.getFunction());
+                    TypeCheckerResult fn_result = recur(that.getFunction());
                         Iterable<ConstraintFormula> arg_constraint = Collections.singletonList(arg_result.getNodeConstraints());
                         //debugging
@@ -1276 +1278 @@
         @Override
         public TypeCheckerResult forAssignment(Assignment that) {
+            if ( that.getOpsForLhs().isSome() ) // postInference pass
+                return for_Assignment( that );
+
                 Pair<List<Type>, TypeCheckerResult> tuple_types_ = requireTupleType(that.getRhs(), that.getLhs().size());
 
@@ -1303 +1308 @@
                 Assignment new_node;
                 if( that.getOpr().isSome() ) {
-                        // Create a _RewriteAssignment, with an OpRef for each LHS
-                        new_node = new _RewriteAssignment(that.getSpan(),
-                                        that.isParenthesized(),
-                                        Option.<Type>some(Types.VOID),
-                                        (List<Lhs>)TypeCheckerResult.astFromResults(lhs_results),
-                                        that.getOpr(),
-                                        (Expr)rhs_result.ast(),
-                                        op_refs);
+                        // Create a new Assignment, with an OpRef for each LHS
+                        new_node = new Assignment(that.getSpan(),
+                                                  that.isParenthesized(),
+                                                  Option.<Type>some(Types.VOID),
+                                                  (List<Lhs>)TypeCheckerResult.astFromResults(lhs_results),
+                                                  that.getOpr(),
+                                                  (Expr)rhs_result.ast(),
+                                                  Option.<List<OpRef>>some(op_refs));
                 }
                 else {
@@ -1322 +1327 @@
                 }
                 // This case could not result in open constraints: If there is an OpRef, this must not be
-                // the postInference pass, because _RewriteAssignmentNodes should exist instead. If there is
+                // the postInference pass, because AssignmentNodes should exist instead. If there is
                 // no OpRef, then no open constraints can be created.
                 return TypeCheckerResult.compose(new_node, Types.VOID, subtypeChecker, rhs_result,
@@ -1328 +1333 @@
         }
 
-
-        @Override
-        public TypeCheckerResult for_RewriteAssignment(_RewriteAssignment that) {
+        private TypeCheckerResult for_Assignment(Assignment that) {
                 Pair<List<Type>, TypeCheckerResult> tuple_types_ = requireTupleType(that.getRhs(), that.getLhs().size());
 
@@ -1356 +1359 @@
                 };
 
-                // Create a _RewriteAssignment, with an OpRef for each LHS
-                Assignment new_node = new _RewriteAssignment(that.getSpan(),
-                                that.isParenthesized(),
-                                Option.<Type>some(Types.VOID),
-                                (List<Lhs>)TypeCheckerResult.astFromResults(lhs_results),
-                                that.getOpr(),
-                                (Expr)rhs_result.ast(),
-                                op_refs);
+                // Create a Assignment, with an OpRef for each LHS
+                Assignment new_node = new Assignment(that.getSpan(),
+                                                     that.isParenthesized(),
+                                                     Option.<Type>some(Types.VOID),
+                                                     (List<Lhs>)TypeCheckerResult.astFromResults(lhs_results),
+                                                     that.getOpr(),
+                                                     (Expr)rhs_result.ast(),
+                                                     Option.<List<OpRef>>some(op_refs));
 
                 TypeCheckerResult result = TypeCheckerResult.compose(new_node, Types.VOID, subtypeChecker, rhs_result,
@@ -1372 +1375 @@
                 if( postInference && TypesUtil.containsInferenceVarTypes(new_node) ) {
                         Pair<Boolean,Node> temp = TypesUtil.closeConstraints(new_node, result);
-                        new_node = (_RewriteAssignment)temp.second();
+                        new_node = (Assignment)temp.second();
                         if(!temp.first()){
                                 String err = "No overloading for " + that.getOpr().unwrap();
@@ -1515 +1518 @@
                 // Find the arrow type of the opr, if it is some
                 Option<TypeCheckerResult> opr_type = (new NodeDepthFirstVisitor<TypeCheckerResult>() {
-                        @Override public TypeCheckerResult for_RewriteInstantiatedOpRefs(_RewriteInstantiatedOpRefs that) {
+                        @Override public TypeCheckerResult forOpRef(OpRef that) {
+                            if ( that.getOverloadings().isSome() ) {
                                 Type args_type = NodeFactory.makeTupleType(Useful.list(arg_type, rhs_type));
-                                return findStaticallyMostApplicableFn(TypeChecker.destructOpOverLoading(that.getOverloadings()), args_type, that, that.getOriginalName());
-                        }
-                        @Override public TypeCheckerResult forOpRef(OpRef that) {
+                                return findStaticallyMostApplicableFn(TypeChecker.destructOpOverLoading(that.getOverloadings().unwrap()), args_type, that, that.getOriginalName());
+                            }
+
                                 TypeCheckerResult op_result = TypeChecker.this.recur(that);
                                 if( !op_result.isSuccessful() ) return op_result;
@@ -1648 +1652 @@
                                 TypeCheckerResult match_result = that.getMatch().accept(TypeChecker.this);
                                 TypeCheckerResult body_result = that.getBody().accept(TypeChecker.this);
-                                CaseClause new_node = new CaseClause(that.getSpan(), (Expr)match_result.ast(), (Block)body_result.ast());
-                                return Triple.make(new_node, match_result, body_result);
-                        }
-
-                        @Override
-                        public Triple<CaseClause, TypeCheckerResult, TypeCheckerResult> for_RewriteCaseClause(_RewriteCaseClause that) {
-                                TypeCheckerResult match_result = that.getMatch().accept(TypeChecker.this);
-                                TypeCheckerResult body_result = that.getBody().accept(TypeChecker.this);
-                                _RewriteCaseClause new_node = new _RewriteCaseClause(that.getSpan(), (Expr)match_result.ast(), (Block)body_result.ast(), that.getOp());
+                                CaseClause new_node = new CaseClause(that.getSpan(), (Expr)match_result.ast(), (Block)body_result.ast(),
+                                                                     that.getOp());
                                 return Triple.<CaseClause,TypeCheckerResult,TypeCheckerResult>make(new_node, match_result, body_result);
                         }
@@ -1722 +1719 @@
 
                         if( postInference ) {
-                                // after inference, the case clause had better be a _RewriteCaseClause.
-                                if( !(clause instanceof _RewriteCaseClause) ) return bug("All case clauses should be rewritten to reflect the chosen compare op.");
-
-                                _RewriteCaseClause rclause = (_RewriteCaseClause)clause;
-                                Pair<Type, TypeCheckerResult> p = for_RewriteCaseClauseGetType(rclause, param_result_);
+                                // after inference, the case clause had better have the op field set
+                            if( clause.getOp().isNone() )
+                                    return bug("All case clauses should be rewritten to reflect the chosen compare op.");
+
+                                Pair<Type, TypeCheckerResult> p = for_CaseClauseGetType(clause, param_result_);
                                 clause_results.add(p.second());
                                 clause_types.add(p.first());
@@ -1732 +1729 @@
                         else {
                                 // during inference, we'll try to apply the given compare op (if there is one) and otherwise try
-                                // equals and in. We will remake the CaseClasue as a _RewriteCaseClause, with a chosen opr.
+                                // equals and in. We will set the op field with a chosen opr.
                                 Pair<Type, TypeCheckerResult> p = forCaseClauseRewriteAndGetType(clause, param_result_, compare_result_, equals_result, in_result);
                                 clause_results.add(p.second());
@@ -1775 +1772 @@
         /**
          * Typecheck the clause, using one of the ops (compare, equals, or in), return the type of the right-hand side block, and
-         * rewrite the CaseClause as a _RewriteCaseClause. All TypeCheckerResults must contain types, and must contain the AST type
+         * rewrite the CaseClause to set the op field. All TypeCheckerResults must contain types, and must contain the AST type
          * that is reflected by their name.
          */
@@ -1831 +1828 @@
                 }
                 else {
-                        _RewriteCaseClause new_node = new _RewriteCaseClause(clause.getSpan(),
-                                        (Expr)match_result.ast(),
-                                        (Block)block_result.ast(),
-                                        chosen_op);
+                        CaseClause new_node = new CaseClause(clause.getSpan(),
+                                                             (Expr)match_result.ast(),
+                                                             (Block)block_result.ast(),
+                                                             Option.<OpRef>some(chosen_op));
                         TypeCheckerResult app_result = new TypeCheckerResult(new_node, application_result.unwrap().second());
                         Type app_type = application_result.unwrap().first();
@@ -1844 +1841 @@
         }
         /**
+         * pointInference pass
          * Typecheck the clause AND return the type of the right-hand side.
          */
-        private Pair<Type, TypeCheckerResult> for_RewriteCaseClauseGetType(_RewriteCaseClause clause, Option<TypeCheckerResult> param_result_) {
+        private Pair<Type, TypeCheckerResult> for_CaseClauseGetType(CaseClause clause, Option<TypeCheckerResult> param_result_) {
+            // after inference, the case clause had better have the op field set
+            if( clause.getOp().isNone() )
+                return bug("All case clauses should be rewritten to reflect the chosen compare op.");
+
+            OpRef op = clause.getOp().unwrap();
+
                 TypeCheckerResult match_result = recur(clause.getMatch());
                 TypeCheckerResult block_result = recur(clause.getBody());
@@ -1858 +1862 @@
                 Type param_type = param_result_.unwrap().type().unwrap();
 
-                if( clause.getOp() instanceof _RewriteInstantiatedOpRefs ) {
+                if( op.getOverloadings().isSome() ) {
                         // Our operator is an overloading, so we should find the statically most applicable one and rewrite
-                        _RewriteInstantiatedOpRefs overloadings = (_RewriteInstantiatedOpRefs)clause.getOp();
                         Type arg_type = NodeFactory.makeTupleType(Useful.list(param_type, match_type));
                         TypeCheckerResult app_result_1 =
-                                findStaticallyMostApplicableFn(destructOpOverLoading(overloadings.getOverloadings()), arg_type, overloadings, overloadings.getOriginalName());
+                            findStaticallyMostApplicableFn(destructOpOverLoading(op.getOverloadings().unwrap()),
+                                                           arg_type, op, op.getOriginalName());
 
                         if( app_result_1.isSuccessful() ) {
@@ -1871 +1875 @@
 
                                 if( app_result_2.isSome() ) {
-                                        _RewriteCaseClause new_node = new _RewriteCaseClause(clause.getSpan(),
-                                                        (Expr)match_result.ast(),
-                                                        (Block)block_result.ast(),
-                                                        (OpRef)app_result_1.ast());
+                                        CaseClause new_node = new CaseClause(clause.getSpan(),
+                                                                             (Expr)match_result.ast(),
+                                                                             (Block)block_result.ast(),
+                                                                             Option.<OpRef>some((OpRef)app_result_1.ast()));
                                         TypeCheckerResult app_result_3 = new TypeCheckerResult(new_node, app_result_2.unwrap().second());
                                         Type app_type = app_result_2.unwrap().first();
                                         // We still must ensure the type of the application is a Boolean
                                         TypeCheckerResult bool_result = checkSubtype(app_type, Types.BOOLEAN, new_node,
-                                                        "Result of application of " + clause.getOp() + " to param and match expression must have type boolean, but had type " + app_type + ".");
+                                                                                     "Result of application of " + op + " to param and match expression must have type boolean, but had type " + app_type + ".");
                                         return Pair.make(block_type, TypeCheckerResult.compose(new_node, subtypeChecker, bool_result, app_result_3, match_result, block_result));
                                 }
@@ -1893 +1897 @@
                 else {
                         // no overloading, so just do the normal thing
-                        TypeCheckerResult op_result = recur(clause.getOp());
+                    TypeCheckerResult op_result = recur(op);
                         if( !op_result.isSuccessful() ) return Pair.make(block_type, TypeCheckerResult.compose(clause, subtypeChecker, op_result));
                         Option<Pair<Type, ConstraintFormula>> app_result_1 =
                                 TypesUtil.applicationType(subtypeChecker, op_result.type().unwrap(), new ArgList(param_type, match_type), downwardConstraint);
                         if( app_result_1.isSome() ) {
-                                _RewriteCaseClause new_node = new _RewriteCaseClause(clause.getSpan(),
-                                                (Expr)match_result.ast(),
-                                                (Block)block_result.ast(),
-                                                (OpRef)op_result.ast());
+                                CaseClause new_node = new CaseClause(clause.getSpan(),
+                                                                     (Expr)match_result.ast(),
+                                                                     (Block)block_result.ast(),
+                                                                     Option.<OpRef>some((OpRef)op_result.ast()));
                                 TypeCheckerResult app_result_2 = new TypeCheckerResult(new_node, app_result_1.unwrap().second());
                                 Type app_type = app_result_1.unwrap().first();
                                 // We still must ensure the type of the application is a Boolean
                                 TypeCheckerResult bool_result = checkSubtype(app_type, Types.BOOLEAN, new_node,
-                                                "Result of application of " + clause.getOp() + " to param and match expression must have type boolean, but had type " + app_type + ".");
+                                                                             "Result of application of " + op + " to param and match expression must have type boolean, but had type " + app_type + ".");
                                 return Pair.make(block_type, TypeCheckerResult.compose(new_node, subtypeChecker, bool_result, app_result_2, match_result, block_result));
                         }
                         else {
                                 // error
-                                String err = "No overloading of the operator " + clause.getOp() + " could be found for arguments of type " +
+                            String err = "No overloading of the operator " + op + " could be found for arguments of type " +
                                 param_type + " (Param Type)  and " + match_type + " (Match Type).";
                                 TypeCheckerResult e_r = new TypeCheckerResult(clause, TypeError.make(err, clause));
@@ -2445 +2449 @@
         @Override
         public TypeCheckerResult forFnRefOnly(final FnRef that, Option<TypeCheckerResult> exprType_result,
-                List<TypeCheckerResult> staticArgs_result,
-                        TypeCheckerResult originalName_result,
-                        List<TypeCheckerResult> fns_result) {
+                                              List<TypeCheckerResult> staticArgs_result,
+                                              TypeCheckerResult originalName_result,
+                                              List<TypeCheckerResult> fns_result,
+                                              Option<List<TypeCheckerResult>> overloadings_result) {
 
                 // Could we give a type to each of our fns?
@@ -2464 +2469 @@
 
                 // if no static args are provided, and we have several overloadings, we
-                // will create a _RewriteInstantiatedFnRef
+                // will create a FnRef with the overloadings field set
                 if( that.getStaticArgs().isEmpty()  && TypesUtil.overloadingRequiresStaticArgs(overloaded_types) ) {
                         // if there is an overloading that requires static args, and we don't have any, we'll
@@ -2519 +2524 @@
                                                 Option.<Type>some(new IntersectionType(NodeFactory.makeSetSpan("impossible", arrow_types), arrow_types));
                                         constraints = accumulated_constraints;
-                                        new_node = new _RewriteInstantiatedFnRefs(that.getSpan(),
-                                                        that.isParenthesized(),
-                                                        type,
-                                                         that.getStaticArgs(),
-                                                         that.getLexicalDepth(),
-                                                         that.getOriginalName(),
-                                                         that.getFns(),
-                                                         fn_overloadings);
+                                        new_node = new FnRef(that.getSpan(),
+                                                             that.isParenthesized(),
+                                                             type,
+                                                             that.getStaticArgs(),
+                                                             that.getLexicalDepth(),
+                                                             that.getOriginalName(),
+                                                             that.getFns(),
+                                                             Option.<List<_RewriteFnRefOverloading>>some(fn_overloadings));
                 }
                 else {
@@ -3562 +3567 @@
                 List<TypeCheckerResult> args_result = recurOnListOfExpr(that.getArgs());
 
-                if( postInference && that.getOp() instanceof _RewriteInstantiatedOpRefs ) {
+                OpRef ops = that.getOp();
+
+                if( postInference && ops.getOverloadings().isSome() ) {
                         // if we have finished typechecking, and we have encountered a reference to an overloaded op
-                        _RewriteInstantiatedOpRefs ops = (_RewriteInstantiatedOpRefs)that.getOp();
-
 
                         for( TypeCheckerResult r : args_result ) {
@@ -3576 +3581 @@
                         }));
                         Type arg_type = NodeFactory.makeTupleType(that.getSpan(), arg_types);
-                        TypeCheckerResult op_result = findStaticallyMostApplicableFn(destructOpOverLoading(ops.getOverloadings()), arg_type,ops, ops.getOriginalName());
+                        TypeCheckerResult op_result = findStaticallyMostApplicableFn(destructOpOverLoading(ops.getOverloadings().unwrap()),
+                                                                                     arg_type,ops, ops.getOriginalName());
 
                         // Now just check the rewritten expression by the normal means
@@ -3659 +3665 @@
         @Override
         public TypeCheckerResult forOpRefOnly(final OpRef that, Option<TypeCheckerResult> exprType_result,
-                List<TypeCheckerResult> staticArgs_result,
-                        TypeCheckerResult originalName_result,
-                        List<TypeCheckerResult> ops_result) {
+                                              List<TypeCheckerResult> staticArgs_result,
+                                              TypeCheckerResult originalName_result,
+                                              List<TypeCheckerResult> ops_result,
+                                              Option<List<TypeCheckerResult>> overloadings_result) {
                 // Did all ops typecheck?
                 for( TypeCheckerResult o_r : ops_result ) {
@@ -3677 +3684 @@
 
                 // If no static args are given, but overloadings require them, we'll create a
-                // _RewriteInstantiatedOpRef.
+                // OpRef with the overloading field set.
                 if( that.getStaticArgs().isEmpty() && TypesUtil.overloadingRequiresStaticArgs(overloaded_types) ) {
                         List<_RewriteOpRefOverloading> overloadings = new ArrayList<_RewriteOpRefOverloading>();
@@ -3730 +3737 @@
                                         Option.<Type>none() :
                                                 Option.<Type>some(new IntersectionType(NodeFactory.makeSetSpan("impossible", arrow_types), arrow_types));
-                                        new_node = new _RewriteInstantiatedOpRefs(that.getSpan(),
-                                                        that.isParenthesized(),
-                                                        type,
-                                                        that.getStaticArgs(),
-                                                        that.getLexicalDepth(),
-                                                        that.getOriginalName(),
-                                                        that.getOps(),
-                                                        overloadings);
+                                        new_node = new OpRef(that.getSpan(),
+                                                             that.isParenthesized(),
+                                                             type,
+                                                             that.getStaticArgs(),
+                                                             that.getLexicalDepth(),
+                                                             that.getOriginalName(),
+                                                             that.getOps(),
+                                                             Option.<List<_RewriteOpRefOverloading>>some(overloadings));
                                         constraints = accumulated_constraints;
                 }

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

@@ -319 +319 @@
 
     public static FnRef makeFnRef(FnRef that, Option<Type> ty, Id name,
-                                  List<Id> ids, List<StaticArg> sargs) {
+                                  List<Id> ids, List<StaticArg> sargs,
+                                  Option<List<_RewriteFnRefOverloading>> overloadings) {
         return new FnRef(that.getSpan(), that.isParenthesized(), ty,
-                sargs, name, ids);
+                         sargs, name, ids, overloadings);
     }
 

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

@@ -1104 +1104 @@
                                               List<String> lhs_result,
                                               Option<String> opr_result,
-                                              String rhs_result) {
+                                              String rhs_result,
+                                              Option<List<String>> opsForLhs_result) {
         StringBuilder s = new StringBuilder();
 
@@ -1117 +1118 @@
         return handleParen( s.toString(),
                             that.isParenthesized() );
-    }
-
-    @Override public String for_RewriteAssignmentOnly(_RewriteAssignment that,
-                                                      Option<String> exprType_result,
-                                                      List<String> lhs_result,
-                                                      Option<String> opr_result,
-                                                      String rhs_result,
-                                                      List<String> opsForLhs_result) {
-        return forAssignmentOnly(that, exprType_result, lhs_result,
-                                  opr_result, rhs_result);
     }
 
@@ -1697 +1688 @@
                                          List<String> staticArgs_result,
                                          String originalName_result,
-                                         List<String> fns_result) {
+                                         List<String> fns_result,
+                                         Option<List<String>> overloadings_result) {
         StringBuilder s = new StringBuilder();
 
@@ -1722 +1714 @@
                                          List<String> staticArgs_result,
                                          String originalName_result,
-                                         List<String> ops_result) {
+                                         List<String> ops_result,
+                                         Option<List<String>> overloadings_result) {
         return handleParen( canonicalOp(originalName_result),
                             that.isParenthesized() );
@@ -1733 +1726 @@
             _RewriteFnRefOverloading that, String fn_result, String ty_result) {
         return "(* _RewriteFnRefOverloading *)";
-    }
-
-    @Override
-    public String for_RewriteInstantiatedFnRefsOnly(
-            _RewriteInstantiatedFnRefs that, Option<String> exprType_result,
-            List<String> staticArgs_result,
-            String originalName_result, List<String> fns_result, List<String> overloadings_result) {
-        return "(* _RewriteInstantiatedFnRefs *)";
-    }
-
-    @Override
-    public String for_RewriteInstantiatedOpRefsOnly(
-            _RewriteInstantiatedOpRefs that, Option<String> exprType_result,
-            List<String> staticArgs_result,
-            String originalName_result, List<String> ops_result, List<String> overloadings_result) {
-        return "(* _RewriteInstantiatedOpRefs *)";
     }
 
@@ -2845 +2822 @@
     @Override public String forCaseClauseOnly(CaseClause that,
                                               String match_result,
-                                              String body_result) {
+                                              String body_result,
+                                              Option<String> op_result) {
         return match_result + " => " + body_result;
-    }
-
-    @Override public String for_RewriteCaseClauseOnly(_RewriteCaseClause that,
-                                                      String match_result,
-                                                      String body_result,
-                                                      String op_result) {
-        return forCaseClauseOnly(that, match_result, body_result);
     }