Changeset 3291 for trunk/ProjectFortress/src/com/sun/fortress/repository/ForeignJava.java

Timestamp:

01/06/09 11:28:57 (11 months ago)

Author:

dr2chase

Message:

[repository, ffi] Generated APIs now use proper import syntax, seem to pass static checking

Files:

• trunk/ProjectFortress/src/com/sun/fortress/repository/ForeignJava.java (modified) (12 diffs)

trunk/ProjectFortress/src/com/sun/fortress/repository/ForeignJava.java

@@ -36 +36 @@
 import com.sun.fortress.nodes.Api;
 import com.sun.fortress.nodes.BaseType;
+import com.sun.fortress.nodes.CompilationUnit;
 import com.sun.fortress.nodes.Decl;
 import com.sun.fortress.nodes.Expr;
@@ -56 +57 @@
 import com.sun.fortress.nodes_util.Span;
 import com.sun.fortress.useful.Bijection;
+import com.sun.fortress.useful.F;
 import com.sun.fortress.useful.HashBijection;
+import com.sun.fortress.useful.IMultiMap;
+import com.sun.fortress.useful.MapOfMapOfSet;
 import com.sun.fortress.useful.MultiMap;
 import com.sun.fortress.useful.Useful;
@@ -72 +76 @@
      * Given a foreign API Name, what other (foreign) APIs does it import?
      */
-    MultiMap<APIName, APIName> generatedImports = new MultiMap<APIName, APIName>();
+    MapOfMapOfSet<APIName, APIName, Id> generatedImports = new MapOfMapOfSet<APIName, APIName, Id>();
     
     /**
@@ -126 +130 @@
     
     static void s(Class cl, APIName api, String str) {
-        specialCases.put(cl, NodeFactory.makeTraitType(span, false, NodeFactory.makeId(span, api, str)));
+        specialCases.put(cl, NodeFactory.makeTraitType(span, false, NodeFactory.makeId(span, str)));
     }
     
@@ -140 +144 @@
         s(Double.class, fortLib, "RR64");
         s(Double.TYPE, fortLib, "RR64");
-        s(String.class, fortLib, "String");
+        s(Object.class, fortLib, "Any");
+        s(String.class, fortLib, "FlatString");
         s(BigInteger.class, fortLib, "ZZ");
         specialCases.put(Void.TYPE, NodeFactory.makeVoidType(span));
@@ -256 +261 @@
         Package p = imported_class.getPackage();
         APIName api_name = packageToAPIName(p);
-        
+        Id name = NodeFactory.makeId(span, imported_class.getSimpleName());
+
         /* Though the class may have been previously referenced, the import
          * may still need to be recorded.  Re-recording an existing import
          * is harmless.
          */
-        generatedImports.putItem(importing_package, api_name);
+        generatedImports.putItem(importing_package, api_name, name);
         
         /*
@@ -268 +274 @@
         javaImplementedAPIs.putItem(api_name,imported_class);
         
-        Id name = NodeFactory.makeId(span, imported_class.getSimpleName());
         
         /*
@@ -282 +287 @@
         };
         
-        name = NodeFactory.makeId(api_name, name);
+        // LOSE THE DOTTED REFERENCE, at least for now.
+        // name = NodeFactory.makeId(api_name, name);
         // Note: a TraitType is a reference to a trait.
         return NodeFactory.makeTraitType(span, false, name);
@@ -365 +371 @@
         for (Class pt : pts) {
             Type type = recurOnOpaqueClass(importing_package, pt);
-            Id id = NodeFactory.makeId(span, "p"+(i++));
+            Span param_span = NodeFactory.makeSpan(m.toString() + " p#" + i);
+            Id id = NodeFactory.makeId(param_span, "p"+(i++));
             Param p = NodeFactory.makeParam(id, type);
             params.add(p);
         }
+        
+        Span fn_span = NodeFactory.makeSpan(m.toString());
         Id id = is_static ?
-                NodeFactory.makeId(span, cl.getSimpleName()+"."+ m.getName()) :
-            NodeFactory.makeId(span, m.getName());
-        FnDecl fndecl = NodeFactory.makeFnDecl(span, Modifiers.None,
+                NodeFactory.makeId(fn_span, cl.getSimpleName()+"."+ m.getName()) :
+            NodeFactory.makeId(fn_span, m.getName());
+        FnDecl fndecl = NodeFactory.makeFnDecl(fn_span, Modifiers.None,
                 id, params,Option.some(return_type), Option.<Expr>none());
         methodToDecl.put(m, fndecl);
@@ -399 +408 @@
 
             List<Import> imports = new ArrayList<Import>();
-            Set<APIName> gi = generatedImports.get(name);
+            IMultiMap<APIName, Id> gi = generatedImports.get(name);
             if (gi != null)
-                for (APIName a : gi) {
-                    importAnApi(imports, a);
+                for (APIName a : gi.keySet()) {
+                    importAnApi(imports, a, gi.get(a));
                 }
-            // Implicitly import.
-            importAnApi(imports, NodeFactory.makeAPIName(span, "FortressLibrary"));
             
             List<Decl> decls = new ArrayList<Decl>();
@@ -420 +427 @@
     }
 
-    private void importAnApi(List<Import> imports, APIName a) {
-        AliasedAPIName aan = NodeFactory.makeAliasedAPIName(a);
-        /*
-         * Hoping to lie, slightly, to static analysis. This is
-         * technically speaking a "foreign" import, but the import
-         * is already known to the ForeignJava data structures, and
-         * this allows use of fully qualified (hence unambiguous)
-         * references to classes from other packages in the
-         * generated API.
-         * 
-         * So, one lie -- no foreign annotation.
-         */
-        ImportApi iapi = NodeFactory.makeImportApi(span, Option
-                .<String> none(), Useful.list(aan));
-        imports.add(iapi);
+    private void importAnApi(List<Import> imports, APIName a, Set<Id> items) {
+        
+        List<AliasedSimpleName> lasn = new ArrayList<AliasedSimpleName>();
+        lasn = Useful.applyToAllAppending(items, new F<Id, AliasedSimpleName>() {
+            @Override
+            public AliasedSimpleName apply(Id x) {
+                return NodeFactory.makeAliasedSimpleName(x);
+            } }, lasn);
+        
+        ImportNames imp_names = NodeFactory.makeImportNames(span, Option.some("java"), a, lasn);
+       
+        imports.add(imp_names);
     }
     
@@ -441 +445 @@
             map.put(a, fakeApi(a));
         }
+        
+        dumpGenerated();
+        
         return map;
     }
+    
+    public void dumpGenerated() {
+        for (APIName a : javaImplementedAPIs.keySet()) {
+            System.out.println(a);
+            CompilationUnit cu = fakeApi(a).ast();
+            System.out.println(cu.toStringVerbose());
+        }
+    }
 
 }