Changeset 3092

Timestamp:

11/24/08 12:05:37 (12 months ago)

Author:

dr2chase

Message:

[astgen] Reshuffled some node fields; added a foreign language fields to imports

Location:

trunk/ProjectFortress

Files:

• astgen/Fortress.ast (modified) (3 diffs)
• src/com/sun/fortress/compiler/OverloadRewriteVisitor.java (modified) (3 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) (8 diffs)
• 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) (1 diff)
• src/com/sun/fortress/parser_util/precedence_resolver/ASTUtil.java (modified) (1 diff)
• src/com/sun/fortress/tools/FortressAstToConcrete.java (modified) (4 diffs)

trunk/ProjectFortress/astgen/Fortress.ast

@@ -188 +188 @@
          * Import ::= import ImportedNames | import api AliasedAPINames
          */
-        abstract Import();
+        abstract Import(Option<String> foreignLanguage = Option.<String>none());
             /**
              * ImportedNames ::= APIName . {...} (except SimpleNames)?
@@ -1127 +1127 @@
                          */
                         FnRef(Id originalName,
-                              List<Id> fns = Collections.<Id>singletonList(in_originalName),
-                              List<StaticArg> staticArgs
-                                  = Collections.<StaticArg>emptyList());
+                              List<Id> fns = Collections.<Id>singletonList(in_originalName));
                             /**
                              * A list of FnRefs used for infering static arguments. Used only between the two
@@ -1144 +1142 @@
                          */
                         OpRef(OpName originalName,
-                              List<OpName> ops = Collections.<OpName>singletonList(in_originalName),
-                              List<StaticArg> staticArgs
-                                  = Collections.<StaticArg>emptyList());
+                              List<OpName> ops = Collections.<OpName>singletonList(in_originalName));
                             /**
                              * Similar to _RewriteInstantiatedFnRefs, this node is used for inferring static

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

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

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

@@ -524 +524 @@
     @Override
     public Node forFnRefOnly(FnRef that, Option<Type> exprType_result,
-                             Id fnResult, List<Id> fns_result,
-                             List<StaticArg> staticArgs_result) {
+                             List<StaticArg> staticArgs_result,
+                             Id fnResult, List<Id> fns_result) {
         // After disambiguation, the Id in a FnRef should have an empty API.
         assert(fnResult.getApi().isNone());

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

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

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

@@ -2442 +2442 @@
         @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) {
+                        List<TypeCheckerResult> fns_result) {
 
                 // Could we give a type to each of our fns?
@@ -2502 +2502 @@
                                                         that.isParenthesized(),
                                                         some(new_type),
+                                                        new_args,
                                                         that.getLexicalDepth(),
                                                         that.getOriginalName(),
-                                                        that.getFns(),
-                                                        new_args);
+                                                        that.getFns());
                                         fn_overloadings.add(new _RewriteFnRefOverloading(that.getSpan(), fn_ref, new_type));
                                         arrow_types.add(new_type);
@@ -2519 +2519 @@
                                                         that.isParenthesized(),
                                                         type,
-                                                        that.getLexicalDepth(),
-                                                        that.getOriginalName(),
-                                                        that.getFns(),
-                                                        that.getStaticArgs(),
-                                                        fn_overloadings);
+                                                         that.getStaticArgs(),
+                                                         that.getLexicalDepth(),
+                                                         that.getOriginalName(),
+                                                         that.getFns(),
+                                                         fn_overloadings);
                 }
                 else {
@@ -2551 +2551 @@
                                                         that.isParenthesized(),
                                                         type,
+                                                        that.getStaticArgs(),
                                                         that.getLexicalDepth(),
                                                         that.getOriginalName(),
-                                                        that.getFns(),
-                                                        that.getStaticArgs());
+                                                        that.getFns());
                 }
 
@@ -3656 +3656 @@
         @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) {
+                        List<TypeCheckerResult> ops_result) {
                 // Did all ops typecheck?
                 for( TypeCheckerResult o_r : ops_result ) {
@@ -3714 +3714 @@
                                         OpRef new_op_ref = new OpRef(that.getSpan(),
                                                         that.isParenthesized(),
+                                                        new_args,
                                                         that.getLexicalDepth(),
                                                         that.getOriginalName(),
-                                                        that.getOps(),
-                                                        new_args);
+                                                        that.getOps());
 
                                         overloadings.add(new _RewriteOpRefOverloading(that.getSpan(), new_op_ref, new_type));
@@ -3730 +3730 @@
                                                         that.isParenthesized(),
                                                         type,
+                                                        that.getStaticArgs(),
                                                         that.getLexicalDepth(),
                                                         that.getOriginalName(),
                                                         that.getOps(),
-                                                        that.getStaticArgs(),
                                                         overloadings);
                                         constraints = accumulated_constraints;
@@ -3757 +3757 @@
                                                         that.isParenthesized(),
                                                         type,
+                                                        (List<StaticArg>)TypeCheckerResult.astFromResults(staticArgs_result),
                                                         that.getLexicalDepth(),
                                                         that.getOriginalName(),
-                                                        (List<OpName>)TypeCheckerResult.astFromResults(ops_result),
-                                                        (List<StaticArg>)TypeCheckerResult.astFromResults(staticArgs_result));
+                                                        (List<OpName>)TypeCheckerResult.astFromResults(ops_result));
                 }
 

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), Environment.TOP_LEVEL,
-                    n_originalName, n_ops, n_args);
+            return new OpRef(op.getSpan(), op.isParenthesized(), Option.wrap(n_type), n_args, Environment.TOP_LEVEL,
+                    n_originalName, n_ops);
         }
         

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

@@ -265 +265 @@
 
     public static OpRef makeOpRef(OpName op, List<StaticArg> staticArgs) {
-        return new OpRef(op.getSpan(), op, Collections.singletonList(op), staticArgs);
+        return new OpRef(op.getSpan(), staticArgs, op, Collections.singletonList(op));
     }
 
@@ -315 +315 @@
 
     public static FnRef makeFnRef(FnRef original, int lexicalNestedness) {
-        return new FnRef(original.getSpan(), original.isParenthesized(), original.getLexicalDepth(), original.getOriginalName(), original.getFns(), original.getStaticArgs());
+        return new FnRef(original.getSpan(), original.isParenthesized(), original.getStaticArgs(), original.getLexicalDepth(), original.getOriginalName(), original.getFns());
     }
 
     public static FnRef makeFnRef(FnRef that, Option<Type> ty, Id name,
                                   List<Id> ids, List<StaticArg> sargs) {
-        return new FnRef(that.getSpan(), that.isParenthesized(), ty, name, ids,
-                         sargs);
+        return new FnRef(that.getSpan(), that.isParenthesized(), ty,
+                sargs, name, ids);
     }
 
@@ -331 +331 @@
     public static FnRef makeFnRef(Span span, Id name, List<StaticArg> sargs) {
         List<Id> names = Collections.singletonList(name);
-        return new FnRef(span, false, name, names, sargs);
+        return new FnRef(span, false, sargs, name, names);
     }
 
@@ -337 +337 @@
         List<Id> names =
             Collections.singletonList(name);
-        return new FnRef(name.getSpan(), false, name, names, Collections.<StaticArg>emptyList());
+        return new FnRef(name.getSpan(), false, Collections.<StaticArg>emptyList(), name, names);
     }
 
     public static FnRef makeFnRef(Id name, Id orig){
-     return new FnRef(name.getSpan(),false, orig, Collections.singletonList(name),Collections.<StaticArg>emptyList());
+     return new FnRef(name.getSpan(),false,Collections.<StaticArg>emptyList(), orig, Collections.singletonList(name));
     }
 
     public static FnRef makeFnRef(Id orig, List<Id> names){
-     return new FnRef(orig.getSpan(),false, orig, names,Collections.<StaticArg>emptyList());
+     return new FnRef(orig.getSpan(),false,Collections.<StaticArg>emptyList(), orig, names);
     }
 
@@ -351 +351 @@
         Id qName = NodeFactory.makeId(apiIds, name);
         List<Id> qNames = Collections.singletonList(qName);
-        return new FnRef(qName.getSpan(), false, qName, qNames,
-                Collections.<StaticArg>emptyList());
+        return new FnRef(qName.getSpan(), false,
+                Collections.<StaticArg>emptyList(), qName, qNames);
     }
 
@@ -358 +358 @@
         Id qName = NodeFactory.makeId(api, name);
         List<Id> qNames = Collections.singletonList(qName);
-        return new FnRef(qName.getSpan(), false, qName, qNames,
-                Collections.<StaticArg>emptyList());
+        return new FnRef(qName.getSpan(), false,
+                Collections.<StaticArg>emptyList(), qName, qNames);
     }
 
     public static FnRef makeFnRef(Span span, boolean paren, Id original_fn, List<Id> fns, List<StaticArg> sargs) {
-     return new FnRef(span, paren, original_fn, fns, sargs);
+     return new FnRef(span, paren, sargs, original_fn, fns);
     }
 
@@ -873 +873 @@
         }
         public Expr forFnRef(FnRef e) {
-            return new FnRef(e.getSpan(), true, e.getOriginalName(), e.getFns(),
-                    e.getStaticArgs());
+            return new FnRef(e.getSpan(), true,
+                    e.getStaticArgs(), e.getOriginalName(), e.getFns());
         }
         public Expr forOpRef(OpRef e) {
-            return new OpRef(e.getSpan(), true, e.getOriginalName(), e.getOps(),
-                    e.getStaticArgs());
+            return new OpRef(e.getSpan(), true,
+                    e.getStaticArgs(), e.getOriginalName(), e.getOps());
         }
         public Expr forSubscriptExpr(SubscriptExpr e) {
@@ -920 +920 @@
       new_original_name = NodeFactory.makeOpInfix((Op)op.getOriginalName());
 
-     OpRef new_op = new OpRef(op.getSpan(),op.isParenthesized(),op.getLexicalDepth(),new_original_name,new_ops,op.getStaticArgs());
+     OpRef new_op = new OpRef(op.getSpan(),op.isParenthesized(),op.getStaticArgs(),op.getLexicalDepth(),new_original_name,new_ops);
      return ExprFactory.makeOpExpr(new_op, lhs, rhs);
     }
@@ -939 +939 @@
       new_original_name = NodeFactory.makeOpPostfix((Op)op.getOriginalName());
 
-     OpRef new_op = new OpRef(op.getSpan(),op.isParenthesized(),op.getLexicalDepth(),new_original_name,new_ops,op.getStaticArgs());
+     OpRef new_op = new OpRef(op.getSpan(),op.isParenthesized(),op.getStaticArgs(),op.getLexicalDepth(),new_original_name,new_ops);
      return ExprFactory.makeOpExpr(e, new_op);
     }

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

@@ -1291 +1291 @@
 
     public static Expr makeOpRef(OpRef original, int lexicalNestedness) {
-            return new OpRef(original.getSpan(), original.isParenthesized(), lexicalNestedness, original.getOriginalName(), original.getOps(), original.getStaticArgs());
+            return new OpRef(original.getSpan(), original.isParenthesized(), original.getStaticArgs(), lexicalNestedness, original.getOriginalName(), original.getOps());
 
     }

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

@@ -109 +109 @@
             Enclosing en = new Enclosing(s, left, right);
             OpRef ref = new OpRef(s,
+                    sargs,
                     en,
-                                  Collections.<OpName>singletonList(en),
-                                  sargs);
+                                  Collections.<OpName>singletonList(en));
             return new OpExpr(span, false, ref, args);
         } else {

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

@@ -1833 +1833 @@
 
     @Override public String forFnRefOnly(FnRef that, Option<String> exprType_result,
+                                         List<String> staticArgs_result,
                                          String originalName_result,
-                                         List<String> fns_result,
-                                         List<String> staticArgs_result) {
+                                         List<String> fns_result) {
         StringBuilder s = new StringBuilder();
 
@@ -1858 +1858 @@
 
     @Override public String forOpRefOnly(OpRef that, Option<String> exprType_result,
+                                         List<String> staticArgs_result,
                                          String originalName_result,
-                                         List<String> ops_result,
-                                         List<String> staticArgs_result) {
+                                         List<String> ops_result) {
         return handleParen( canonicalOp(originalName_result),
                             that.isParenthesized() );
@@ -1876 +1876 @@
     public String for_RewriteInstantiatedFnRefsOnly(
             _RewriteInstantiatedFnRefs that, Option<String> exprType_result,
-            String originalName_result, List<String> fns_result,
-            List<String> staticArgs_result, List<String> overloadings_result) {
+            List<String> staticArgs_result,
+            String originalName_result, List<String> fns_result, List<String> overloadings_result) {
         return "(* _RewriteInstantiatedFnRefs *)";
     }
@@ -1884 +1884 @@
     public String for_RewriteInstantiatedOpRefsOnly(
             _RewriteInstantiatedOpRefs that, Option<String> exprType_result,
-            String originalName_result, List<String> ops_result,
-            List<String> staticArgs_result, List<String> overloadings_result) {
+            List<String> staticArgs_result,
+            String originalName_result, List<String> ops_result, List<String> overloadings_result) {
         return "(* _RewriteInstantiatedOpRefs *)";
     }