Changeset 3155

Timestamp:

12/06/08 06:17:14 (12 months ago)

Author:

sukyoungryu

Message:

[ast refactoring] Eliminated nodes: _RewriteFnRefOverloading and _RewriteOpRefOverloading

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) (1 diff)
• src/com/sun/fortress/compiler/disambiguator/ExprDisambiguator.java (modified) (2 diffs)
• src/com/sun/fortress/compiler/typechecker/TypeChecker.java (modified) (12 diffs)
• src/com/sun/fortress/interpreter/rewrite/DesugarerVisitor.java (modified) (1 diff)
• src/com/sun/fortress/interpreter/rewrite/OprInstantiaterVisitor.java (modified) (1 diff)
• src/com/sun/fortress/nodes_util/ExprFactory.java (modified) (9 diffs)
• src/com/sun/fortress/nodes_util/NodeFactory.java (modified) (2 diffs)
• src/com/sun/fortress/parser_util/precedence_resolver/ASTUtil.java (modified) (4 diffs)
• src/com/sun/fortress/tools/FortressAstToConcrete.java (modified) (2 diffs)

trunk/ProjectFortress/astgen/Fortress.ast

@@ -1032 +1032 @@
                          */
                         abstract FunctionalRef(List<StaticArg> staticArgs
-                                                 = Collections.<StaticArg>emptyList(), int lexicalDepth=-2147483648);
+                                                 = Collections.<StaticArg>emptyList(),
+                                               int lexicalDepth=-2147483648);
                             /**
                              * expression with static instantiations
@@ -1043 +1044 @@
                              * passes of the typechecker. Indicates that one of these FnRefs, which each have
                              * different instantiations of static arguments, should be the correct instantiation.
+                             *
+                             * <overloadingType>
+                             * type of a particular overloading
                              */
                             FnRef(Id originalName,
                                   List<Id> fns = Collections.<Id>singletonList(in_originalName),
-                                  Option<List<_RewriteFnRefOverloading>> overloadings
-                                      = Option.<List<_RewriteFnRefOverloading>>none());
+                                  Option<List<FnRef>> overloadings
+                                      = Option.<List<FnRef>>none(),
+                                  Option<Type> overloadingType);
                             /**
                              * operator name with (inferred) static instantiations
@@ -1059 +1064 @@
                              * passes of the typechecker. Holds several different instantiations of static args,
                              * one of which may be the correct insantiation.
+                             *
+                             * <overloadingType>
+                             * type of a particular overloading
                              */
                             OpRef(Op originalName,
                                   List<Op> ops = Collections.<Op>singletonList(in_originalName),
-                                  Option<List<_RewriteOpRefOverloading>> overloadings
-                                      = Option.<List<_RewriteOpRefOverloading>>none());
+                                  Option<List<OpRef>> overloadings
+                                      = Option.<List<OpRef>>none(),
+                                  Option<Type> overloadingType);
                         /**
                          * juxtaposition of expressions
@@ -2032 +2041 @@
              */
             Link(OpRef op, Expr expr);
-            /*
-             * An overloading, and the type of that particular overloading.
-             */
-            _RewriteFnRefOverloading(FnRef fnRef, Type ty);
-            /**
-             * An operator overloading, and the tpye of that overloading.
-             */
-            _RewriteOpRefOverloading(OpRef op, Type ty);
 
     /**

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

@@ -38 +38 @@
     public Node forFnRefOnly(FnRef that, Option<Type> exprType_result,
                              List<StaticArg> staticArgs, Id originalName, List<Id> fns,
-                             Option<List<_RewriteFnRefOverloading>> overloadings) {
+                             Option<List<FnRef>> overloadings,
+                             Option<Type> type_result) {
         if (fns.size() > 1) {
             Collections.<Id>sort(fns, NodeComparator.idComparer);
@@ -59 +60 @@
         }
         return super.forFnRefOnly(that, exprType_result, staticArgs , originalName, fns,
-                                  overloadings);
+                                  overloadings, type_result);
     }
 
@@ -66 +67 @@
     public Node forOpRefOnly(OpRef that, Option<Type> exprType_result,
                              List<StaticArg> staticArgs, Op originalName, List<Op> ops,
-                             Option<List<_RewriteOpRefOverloading>> overloadings) {
+                             Option<List<OpRef>> overloadings,
+                             Option<Type> type_result) {
         if (ops.size() > 1) {
             Collections.<Op>sort(ops, NodeComparator.opNameComparer);
@@ -87 +89 @@
         }
         return super.forOpRefOnly(that, exprType_result, staticArgs, originalName, ops,
-                                  overloadings);
+                                  overloadings, type_result);
     }
 

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

@@ -500 +500 @@
                              List<StaticArg> staticArgs_result,
                              Id fnResult, List<Id> fns_result,
-                             Option<List<_RewriteFnRefOverloading>> overloadings_result) {
+                             Option<List<FnRef>> overloadings_result,
+                             Option<Type> type_result) {
         // After disambiguation, the Id in a FnRef should have an empty API.
         assert(fnResult.getApiName().isNone());

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

@@ -1117 +1117 @@
         }
 
-        OpRef result = new OpRef(that.getSpan(),that.isParenthesized(),that.getStaticArgs(),op_name,CollectUtil.makeList(ops));
+        OpRef result = new OpRef(that.getSpan(),that.isParenthesized(),
+                                 that.getStaticArgs(),op_name,
+                                 CollectUtil.makeList(ops),
+                                 Option.<Type>none());
         return Option.<OpRef>some(result);
     }
@@ -1147 +1150 @@
         if ( result_.isNone() ) {
             // Make sure to populate the 'originalName' field.
-            return new OpRef(that.getSpan(),that.isParenthesized(),that.getStaticArgs(),IterUtil.first(that.getOps()), that.getOps());
+            return new OpRef(that.getSpan(),that.isParenthesized(),
+                             that.getStaticArgs(),IterUtil.first(that.getOps()),
+                             that.getOps(), Option.<Type>none());
         }
         else {

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

@@ -861 +861 @@
         }
 
-        private static List<Pair<FnRef, Type>> destructFnOverloadings(List<_RewriteFnRefOverloading> overloadings) {
+        private static List<Pair<FnRef, Type>> destructFnOverloadings(List<FnRef> overloadings) {
                 List<Pair<FnRef, Type>> result = new ArrayList<Pair<FnRef, Type>>(overloadings.size());
-                for( _RewriteFnRefOverloading overloading : overloadings ) {
-                        result.add(Pair.make(overloading.getFnRef(), overloading.getTy()));
+                for( FnRef overloading : overloadings ) {
+                    if ( overloading.getOverloadingType().isNone() )
+                        bug(overloading,
+                            "Type checker should have type for the overloading of "
+                            + overloading.getOriginalName());
+                    result.add(Pair.make(overloading, overloading.getOverloadingType().unwrap()));
                 }
                 return result;
@@ -2437 +2441 @@
                                               TypeCheckerResult originalName_result,
                                               List<TypeCheckerResult> fns_result,
-                                              Option<List<TypeCheckerResult>> overloadings_result) {
+                                              Option<List<TypeCheckerResult>> overloadings_result,
+                                              Option<TypeCheckerResult> type_result) {
 
                 // Could we give a type to each of our fns?
@@ -2458 +2463 @@
                         // if there is an overloading that requires static args, and we don't have any, we'll
                         // create a _FnInstantitedOverloading
-                        List<_RewriteFnRefOverloading> fn_overloadings = new ArrayList<_RewriteFnRefOverloading>();
+                        List<FnRef> fn_overloadings = new ArrayList<FnRef>();
                         List<Type> arrow_types = new ArrayList<Type>();
                         ConstraintFormula accumulated_constraints = ConstraintFormula.TRUE;
@@ -2498 +2503 @@
                                                         that.getLexicalDepth(),
                                                         that.getOriginalName(),
-                                                        that.getFns());
-                                        fn_overloadings.add(new _RewriteFnRefOverloading(that.getSpan(), fn_ref, new_type));
+                                                                 that.getFns(),
+                                                                 Option.<Type>none());
+                                        fn_overloadings.add(ExprFactory.make_RewriteFnRefOverloading(that.getSpan(), fn_ref, new_type));
                                         arrow_types.add(new_type);
                                         accumulated_constraints=accumulated_constraints.and(new_type_and_args_.unwrap().first().second(),this.subtypeChecker.new SubtypeHistory());
@@ -2516 +2522 @@
                                                              that.getOriginalName(),
                                                              that.getFns(),
-                                                             Option.<List<_RewriteFnRefOverloading>>some(fn_overloadings));
+                                                             Option.<List<FnRef>>some(fn_overloadings),
+                                                             Option.<Type>none());
                 }
                 else {
@@ -2547 +2554 @@
                                                         that.getLexicalDepth(),
                                                         that.getOriginalName(),
-                                                        that.getFns());
+                                                             that.getFns(),
+                                                             Option.<Type>none());
                 }
 
@@ -3536 +3544 @@
         }
 
-        private static List<Pair<OpRef, Type>> destructOpOverLoading(List<_RewriteOpRefOverloading> overloadings){
+        private static List<Pair<OpRef, Type>> destructOpOverLoading(List<OpRef> overloadings){
                 List<Pair<OpRef, Type>> result = new ArrayList<Pair<OpRef,Type>>(overloadings.size());
-                for(_RewriteOpRefOverloading o: overloadings){
-                        result.add(Pair.make(o.getOp(),o.getTy()));
+                for(OpRef o: overloadings){
+                    if ( o.getOverloadingType().isNone() )
+                        bug(o, "Type checker should have type for the overloading of "
+                            + o.getOriginalName());
+                    result.add(Pair.make(o, o.getOverloadingType().unwrap()));
                 }
                 return result;
@@ -3649 +3660 @@
                                               TypeCheckerResult originalName_result,
                                               List<TypeCheckerResult> ops_result,
-                                              Option<List<TypeCheckerResult>> overloadings_result) {
+                                              Option<List<TypeCheckerResult>> overloadings_result,
+                                              Option<TypeCheckerResult> type_result) {
                 // Did all ops typecheck?
                 for( TypeCheckerResult o_r : ops_result ) {
@@ -3667 +3679 @@
                 // OpRef with the overloading field set.
                 if( that.getStaticArgs().isEmpty() && TypesUtil.overloadingRequiresStaticArgs(overloaded_types) ) {
-                        List<_RewriteOpRefOverloading> overloadings = new ArrayList<_RewriteOpRefOverloading>();
+                        List<OpRef> overloadings = new ArrayList<OpRef>();
                         List<Type> arrow_types = new ArrayList<Type>();
                         ConstraintFormula accumulated_constraints = ConstraintFormula.TRUE;
@@ -3708 +3720 @@
                                                         that.getLexicalDepth(),
                                                         that.getOriginalName(),
-                                                        that.getOps());
-
-                                        overloadings.add(new _RewriteOpRefOverloading(that.getSpan(), new_op_ref, new_type));
+                                                                     that.getOps(),
+                                                                     Option.<Type>none());
+
+                                        overloadings.add(ExprFactory.make_RewriteOpRefOverloading(that.getSpan(), new_op_ref, new_type));
                                         arrow_types.add(new_type);
                                 }
@@ -3725 +3738 @@
                                                              that.getOriginalName(),
                                                              that.getOps(),
-                                                             Option.<List<_RewriteOpRefOverloading>>some(overloadings));
+                                                             Option.<List<OpRef>>some(overloadings),
+                                                             Option.<Type>none());
                                         constraints = accumulated_constraints;
                 }
@@ -3751 +3765 @@
                                                         that.getLexicalDepth(),
                                                         that.getOriginalName(),
-                                                        (List<Op>)TypeCheckerResult.astFromResults(ops_result));
+                                                             (List<Op>)TypeCheckerResult.astFromResults(ops_result),
+                                                             Option.<Type>none());
                 }
 

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

@@ -162 +162 @@
         }
         Expr replacement(OpRef original) {
-            return NodeFactory.makeOpRef(original, lexicalNestedness);
+            return ExprFactory.makeOpRef(original, lexicalNestedness);
         }
         VarType replacement(VarType original) {

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

@@ -75 +75 @@
         if (args != n_args || originalName != n_originalName || ops != n_ops || type != n_type) {
             return new OpRef(op.getSpan(), op.isParenthesized(), Option.wrap(n_type), n_args, Environment.TOP_LEVEL,
-                    n_originalName, n_ops);
+                             n_originalName, n_ops, Option.<Type>none());
         }
 

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

@@ -239 +239 @@
     }
 
+    public static OpRef make_RewriteOpRefOverloading(Span span, OpRef original, Type type) {
+        return new OpRef(span, original.isParenthesized(), original.getExprType(),
+                         original.getStaticArgs(), original.getLexicalDepth(),
+                         original.getOriginalName(), original.getOps(),
+                         original.getOverloadings(), Option.<Type>some(type));
+    }
+
     public static OpRef makeMultiJuxt() {
         return makeOpRef(NodeFactory.makeOpMultifix(NodeFactory.makeOp("juxtaposition")));
@@ -255 +262 @@
     }
 
+    public static Expr makeOpRef(OpRef original, int lexicalNestedness) {
+            return new OpRef(original.getSpan(), original.isParenthesized(),
+                             original.getStaticArgs(), lexicalNestedness,
+                             original.getOriginalName(), original.getOps(),
+                             Option.<Type>none());
+
+    }
+
     public static OpRef makeOpRef(Span span, String name) {
         Op op = NodeFactory.makeOpInfix(span, name);
-        return new OpRef(span, op, Collections.singletonList(op));
+        return new OpRef(span, op, Collections.singletonList(op), Option.<Type>none());
     }
 
     public static OpRef makeOpRef(Op op) {
-        return new OpRef(op.getSpan(), op, Collections.singletonList(op));
+        return new OpRef(op.getSpan(), op, Collections.singletonList(op), Option.<Type>none());
     }
 
     public static OpRef makeOpRef(Op op, List<StaticArg> staticArgs) {
-        return new OpRef(op.getSpan(), staticArgs, op, Collections.singletonList(op));
+        return new OpRef(op.getSpan(), staticArgs, op, Collections.singletonList(op), Option.<Type>none());
     }
 
@@ -309 +324 @@
     }
 
+    public static FnRef make_RewriteFnRefOverloading(Span span, FnRef original, Type type) {
+        return new FnRef(span, original.isParenthesized(), original.getExprType(),
+                         original.getStaticArgs(), original.getLexicalDepth(),
+                         original.getOriginalName(), original.getFns(),
+                         original.getOverloadings(), Option.<Type>some(type));
+    }
+
     public static FnRef makeFnRef(Span span, Id name) {
         List<Id> names = Collections.singletonList(name);
-        return new FnRef(span, name, names);
+        return new FnRef(span, name, names, Option.<Type>none());
     }
 
     public static FnRef makeFnRef(FnRef original, int lexicalNestedness) {
-        return new FnRef(original.getSpan(), original.isParenthesized(), original.getStaticArgs(), original.getLexicalDepth(), original.getOriginalName(), original.getFns());
+        return new FnRef(original.getSpan(), original.isParenthesized(),
+                         original.getStaticArgs(), original.getLexicalDepth(),
+                         original.getOriginalName(), original.getFns(),
+                         Option.<Type>none());
     }
 
     public static FnRef makeFnRef(FnRef that, Option<Type> ty, Id name,
                                   List<Id> ids, List<StaticArg> sargs,
-                                  Option<List<_RewriteFnRefOverloading>> overloadings) {
+                                  Option<List<FnRef>> overloadings) {
         return new FnRef(that.getSpan(), that.isParenthesized(), ty,
-                         sargs, name, ids, overloadings);
+                         sargs, name, ids, overloadings, Option.<Type>none());
     }
 
     public static FnRef makeFnRef(FnRef that, Option<Type> ty, Id name,
                                   List<Id> ids) {
-        return new FnRef(that.getSpan(), that.isParenthesized(), ty, name, ids);
+        return new FnRef(that.getSpan(), that.isParenthesized(), ty, name, ids,
+                         Option.<Type>none());
     }
 
     public static FnRef makeFnRef(Span span, Id name, List<StaticArg> sargs) {
         List<Id> names = Collections.singletonList(name);
-        return new FnRef(span, false, sargs, name, names);
+        return new FnRef(span, false, sargs, name, names, Option.<Type>none());
     }
 
@@ -338 +364 @@
         List<Id> names =
             Collections.singletonList(name);
-        return new FnRef(name.getSpan(), false, Collections.<StaticArg>emptyList(), name, names);
+        return new FnRef(name.getSpan(), false,
+                         Collections.<StaticArg>emptyList(), name, names,
+                         Option.<Type>none());
     }
 
     public static FnRef makeFnRef(Id name, Id orig){
-     return new FnRef(name.getSpan(),false,Collections.<StaticArg>emptyList(), orig, Collections.singletonList(name));
+     return new FnRef(name.getSpan(),false,Collections.<StaticArg>emptyList(),
+                      orig, Collections.singletonList(name), Option.<Type>none());
     }
 
     public static FnRef makeFnRef(Id orig, List<Id> names){
-     return new FnRef(orig.getSpan(),false,Collections.<StaticArg>emptyList(), orig, names);
+     return new FnRef(orig.getSpan(),false,
+                      Collections.<StaticArg>emptyList(), orig, names,
+                      Option.<Type>none());
     }
 
@@ -353 +384 @@
         List<Id> qNames = Collections.singletonList(qName);
         return new FnRef(qName.getSpan(), false,
-                Collections.<StaticArg>emptyList(), qName, qNames);
+                         Collections.<StaticArg>emptyList(), qName, qNames,
+                         Option.<Type>none());
     }
 
@@ -360 +392 @@
         List<Id> qNames = Collections.singletonList(qName);
         return new FnRef(qName.getSpan(), false,
-                Collections.<StaticArg>emptyList(), qName, qNames);
+                         Collections.<StaticArg>emptyList(), qName, qNames,
+                         Option.<Type>none());
     }
 
     public static FnRef makeFnRef(Span span, boolean paren, Id original_fn, List<Id> fns, List<StaticArg> sargs) {
-     return new FnRef(span, paren, sargs, original_fn, fns);
+     return new FnRef(span, paren, sargs, original_fn, fns,
+                      Option.<Type>none());
     }
 
@@ -870 +904 @@
         public Expr forFnRef(FnRef e) {
             return new FnRef(e.getSpan(), true,
-                    e.getStaticArgs(), e.getOriginalName(), e.getFns());
+                             e.getStaticArgs(), e.getOriginalName(), e.getFns(),
+                             Option.<Type>none());
         }
         public Expr forOpRef(OpRef e) {
             return new OpRef(e.getSpan(), true,
-                    e.getStaticArgs(), e.getOriginalName(), e.getOps());
+                             e.getStaticArgs(), e.getOriginalName(), e.getOps(),
+                             Option.<Type>none());
         }
         public Expr forSubscriptExpr(SubscriptExpr e) {
@@ -916 +952 @@
       new_original_name = NodeFactory.makeOpInfix((Op)op.getOriginalName());
 
-     OpRef new_op = new OpRef(op.getSpan(),op.isParenthesized(),op.getStaticArgs(),op.getLexicalDepth(),new_original_name,new_ops);
+     OpRef new_op = new OpRef(op.getSpan(),op.isParenthesized(),op.getStaticArgs(),
+                              op.getLexicalDepth(),new_original_name,new_ops,
+                              Option.<Type>none());
      return ExprFactory.makeOpExpr(new_op, lhs, rhs);
     }
@@ -935 +973 @@
       new_original_name = NodeFactory.makeOpPostfix((Op)op.getOriginalName());
 
-     OpRef new_op = new OpRef(op.getSpan(),op.isParenthesized(),op.getStaticArgs(),op.getLexicalDepth(),new_original_name,new_ops);
+     OpRef new_op = new OpRef(op.getSpan(),op.isParenthesized(),op.getStaticArgs(),
+                              op.getLexicalDepth(),new_original_name,new_ops,
+                              Option.<Type>none());
      return ExprFactory.makeOpExpr(e, new_op);
     }

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

@@ -1307 +1307 @@
     }
 
-    public static Expr makeOpRef(OpRef original, int lexicalNestedness) {
-            return new OpRef(original.getSpan(), original.isParenthesized(), original.getStaticArgs(), lexicalNestedness, original.getOriginalName(), original.getOps());
-
-    }
-
-    public static TightJuxt makeTightJuxt(Span span, List<Expr> exprs) {
-        return new TightJuxt(span, Useful.immutableTrimmedList(exprs));
-    }
-
     public static BoolRef makeBoolRef(BoolRef old, int depth) {
         return new BoolRef(old.getSpan(), old.isParenthesized(), old.getName(), depth);
@@ -1349 +1340 @@
     }
 
-    public static ChainExpr makeChainExpr(Expr lhs, Op op, Expr rhs) {
-        List<Link> links = new ArrayList<Link>(1);
-        links.add(new Link(new Span(op.getSpan(), rhs.getSpan()), ExprFactory.makeOpRef(NodeFactory.makeOpInfix(op)), rhs));
-        return new ChainExpr(new Span(lhs.getSpan(), rhs.getSpan()), lhs, links);
-    }
-
     public static VarType makeVarType(VarType original, int lexicalNestedness) {
         return new VarType(original.getSpan(), original.isParenthesized(), original.getName(), lexicalNestedness);

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

@@ -26 +26 @@
 import java.util.Collections;
 import java.util.List;
+import edu.rice.cs.plt.tuple.Option;
 
 import com.sun.fortress.nodes.AmbiguousMultifixOpExpr;
@@ -36 +37 @@
 import com.sun.fortress.nodes.OpRef;
 import com.sun.fortress.nodes.StaticArg;
+import com.sun.fortress.nodes.Type;
 import com.sun.fortress.nodes_util.ExprFactory;
 import com.sun.fortress.nodes_util.NodeFactory;
@@ -77 +79 @@
     static Expr multifix(Span span, Op op, List<Expr> args) {
         Op infix_op_ = NodeFactory.makeOpInfix(op);
-        OpRef infix_op = new OpRef(op.getSpan(), infix_op_,  Collections.<Op>singletonList(infix_op_));
+        OpRef infix_op = new OpRef(op.getSpan(), infix_op_,
+                                   Collections.<Op>singletonList(infix_op_),
+                                   Option.<Type>none());
 
         Op multifix_op_ = NodeFactory.makeOpMultifix(op);
-        OpRef multifix_op = new OpRef(op.getSpan(), multifix_op_,  Collections.<Op>singletonList(multifix_op_));
+        OpRef multifix_op = new OpRef(op.getSpan(), multifix_op_,
+                                      Collections.<Op>singletonList(multifix_op_),
+                                      Option.<Type>none());
 
         if (args.size() > 2) {
@@ -109 +115 @@
                                   sargs,
                                   en,
-                                  Collections.<Op>singletonList(en));
+                                  Collections.<Op>singletonList(en),
+                                  Option.<Type>none());
             return new OpExpr(span, false, ref, args);
         } else {

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

@@ -1671 +1671 @@
                                          String originalName_result,
                                          List<String> fns_result,
-                                         Option<List<String>> overloadings_result) {
+                                         Option<List<String>> overloadings_result,
+                                         Option<String> type_result) {
         StringBuilder s = new StringBuilder();
 
@@ -1697 +1698 @@
                                          String originalName_result,
                                          List<String> ops_result,
-                                         Option<List<String>> overloadings_result) {
+                                         Option<List<String>> overloadings_result,
+                                         Option<String> type_result) {
         return handleParen( canonicalOp(originalName_result),
                             that.isParenthesized() );
-    }
-
-
-
-    @Override
-    public String for_RewriteFnRefOverloadingOnly(
-            _RewriteFnRefOverloading that, String fn_result, String ty_result) {
-        return "(* _RewriteFnRefOverloading *)";
-    }
-
-    @Override
-    public String for_RewriteOpRefOverloadingOnly(
-            _RewriteOpRefOverloading that, String op_result, String ty_result) {
-        return "(* _RewriteOpRefOverloading *)";
     }