Changeset 4291

Timestamp:

10/26/09 20:28:38 (4 weeks ago)

Author:

dr2chase

Message:

Unambiguous names enabled -- stack traces may look vile.

Location:

trunk/ProjectFortress

Files:

• astgen/Fortress.ast (modified) (1 diff)
• other_compiler_tests/Funmet1.fsi (modified) (1 diff)
• src/com/sun/fortress/compiler/OverloadRewriteVisitor.java (modified) (2 diffs)
• src/com/sun/fortress/compiler/codegen/CodeGen.java (modified) (17 diffs)
• src/com/sun/fortress/compiler/disambiguator/NameEnv.java (modified) (1 diff)
• src/com/sun/fortress/compiler/disambiguator/TopLevelEnv.java (modified) (2 diffs)
• src/com/sun/fortress/compiler/index/Coercion.java (modified) (1 diff)
• src/com/sun/fortress/compiler/index/Constructor.java (modified) (1 diff)
• src/com/sun/fortress/compiler/index/DeclaredFunction.java (modified) (1 diff)
• src/com/sun/fortress/compiler/index/DeclaredMethod.java (modified) (1 diff)
• src/com/sun/fortress/compiler/index/FieldGetterOrSetterMethod.java (modified) (1 diff)
• src/com/sun/fortress/compiler/index/Functional.java (modified) (1 diff)
• src/com/sun/fortress/compiler/index/FunctionalMethod.java (modified) (1 diff)
• src/com/sun/fortress/compiler/nativeInterface/FortressMethodAdapter.java (modified) (4 diffs)
• src/com/sun/fortress/compiler/nativeInterface/FortressTransformer.java (modified) (2 diffs)
• src/com/sun/fortress/exceptions/InterpreterBug.java (modified) (1 diff)
• src/com/sun/fortress/nodes_util/NodeFactory.java (modified) (6 diffs)
• src/com/sun/fortress/repository/ForeignJava.java (modified) (7 diffs)
• src/com/sun/fortress/runtimeSystem/Naming.java (modified) (1 diff)
• src/com/sun/fortress/scala_src/disambiguator/ExprDisambiguator.scala (modified) (3 diffs)
• src/com/sun/fortress/scala_src/linker/HygienicRenamer.scala (modified) (1 diff)
• src/com/sun/fortress/scala_src/typechecker/STypeChecker.scala (modified) (1 diff)
• src/com/sun/fortress/scala_src/typechecker/impls/Functionals.scala (modified) (3 diffs)
• src/com/sun/fortress/scala_src/typechecker/staticenv/STypeEnv.scala (modified) (9 diffs)
• src/com/sun/fortress/scala_src/useful/STypesUtil.scala (modified) (1 diff)

trunk/ProjectFortress/astgen/Fortress.ast

@@ -1673 +1673 @@
              */
             Overloading(IdOrOp unambiguousName,
-                        Option<Type> type);
+                        Option<ArrowType> type);
 
             /** syntactic abstraction nodes ************************************/

trunk/ProjectFortress/other_compiler_tests/Funmet1.fsi

@@ -19 +19 @@
 
 trait T
-  me(self, x:ZZ32):ZZ32
+   me(self, x:ZZ32):ZZ32
 end
 

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

@@ -69 +69 @@
             if (rc != 0)
                 return rc;
-            Option<Type> ot1 = o1.getType();
-            Option<Type> ot2 = o2.getType();
+            Option<ArrowType> ot1 = o1.getType();
+            Option<ArrowType> ot2 = o2.getType();
             if (ot1.isNone()) {
                 if (ot2.isNone()) {
@@ -80 +80 @@
                 return 1;
             } else {
-                Type t1 = ot1.unwrap();
-                Type t2 = ot2.unwrap();
+                ArrowType t1 = ot1.unwrap();
+                ArrowType t2 = ot2.unwrap();
                 return NodeComparator.typeComparer.compare(t1, t2);
             }

trunk/ProjectFortress/src/com/sun/fortress/compiler/codegen/CodeGen.java

@@ -62 +62 @@
 import com.sun.fortress.useful.Useful;
 
+import edu.rice.cs.plt.collect.CollectUtil;
+import edu.rice.cs.plt.collect.Relation;
+
 // Note we have a name clash with org.objectweb.asm.Type
 // and com.sun.fortress.nodes.Type.  If anyone has a better
@@ -80 +83 @@
     private final FreeVariables fv;
     private final Map<IdOrOpOrAnonymousName, MultiMap<Integer, Function>> topLevelOverloads;
+    private final MultiMap<String, Function> exportedToUnambiguous;
     private Set<String> overloadedNamesAndSigs;
 
@@ -116 +120 @@
         this.fv = c.fv;
         this.topLevelOverloads = c.topLevelOverloads;
+        this.exportedToUnambiguous = c.exportedToUnambiguous;
         this.overloadedNamesAndSigs = c.overloadedNamesAndSigs;
 
@@ -142 +147 @@
         this.fv = fv;
         this.ci = ci;
+        this.exportedToUnambiguous = new MultiMap<String, Function> ();
+
+        /*
+         * Find every exported name, and make an entry mapping name to
+         * API declarations, so that unambiguous names from APIs can
+         * also be emitted.
+         */
+        List<APIName> exports = c.getExports();
+        for (APIName apiname:exports) {
+            ApiIndex api_index = env.api(apiname);
+            Relation<IdOrOpOrAnonymousName, Function> fns = api_index.functions();
+            for (IdOrOpOrAnonymousName name : fns.firstSet()) {
+                if (name instanceof IdOrOp) {
+                    Set<Function> defs = fns.matchFirst(name);
+                    for (Function def : defs) {
+                        IdOrOpOrAnonymousName ua_name = def.unambiguousName();
+                        if (ua_name instanceof IdOrOp) {
+                            IdOrOp ioo_name = (IdOrOp) name;
+                            IdOrOp ioo_ua_name = (IdOrOp) ua_name;
+                            if (! ioo_name.equals(ioo_ua_name)) {
+                                // Add mapping ioo_name -> def to MultiMap
+                                exportedToUnambiguous.putItem(
+                                        ioo_name.getText(),
+                                        def);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        
         this.topLevelOverloads =
             sizePartitionedOverloads(ci.functions());
+
         this.overloadedNamesAndSigs = new HashSet<String>();
         this.lexEnv = new BATree<String,VarCodeGen>(StringHashComparer.V);
         this.env = env;
+        
+        
         debug( "Compile: Compiling ", packageAndClassName );
     }
@@ -394 +433 @@
             // answer depends upon how intersection types are normalized.
             // conservative answer is "no".
-            methodName = Naming.mangleIdentifier(methodName);
+            // methodName = Naming.mangleIdentifier(methodName);
             signature = NamingCzar.jvmMethodDesc(arrow, component.getName());
 
@@ -400 +439 @@
             IntersectionType it = (IntersectionType) arrow;
             methodName = OverloadSet.actuallyOverloaded(it, paramCount) ?
-                    OverloadSet.oMangle(methodName) : Naming.mangleIdentifier(methodName);
+                    OverloadSet.oMangle(methodName) : methodName;
 
             signature = OverloadSet.getSignature(it, paramCount, ta);
@@ -566 +605 @@
 
         // Must do this first, to get local decls right.
-        overloadedNamesAndSigs = generateTopLevelOverloads(thisApi(), topLevelOverloads, ta, cw);
-
+        overloadedNamesAndSigs = generateTopLevelOverloads(thisApi(), topLevelOverloads, ta, cw, this);
+
+        /* Need wrappers for the API, too. */
+        generateUnambiguousWrappersForApi();
+        
         // Must process top-level values next to make sure fields end up in scope.
         for (Decl d : x.getDecls()) {
@@ -755 +797 @@
          */
 
+
         // Dotted method; downcast self and
         // forward to static method in springboard class
@@ -808 +851 @@
         cg.generateActualMethodCode(modifiers, mname, sig, params, selfIndex,
                                     inAMethod, body);
+        
+        generateAllWrappersForFn(x, params, sig, modifiers, mname);
+    }
+
+
+    /**
+     * @param x
+     * @param params
+     * @param selfIndex
+     * @param sig
+     * @param modifiers
+     * @param mname
+     */
+    private void generateAllWrappersForFn(FnDecl x, List<Param> params,
+            String sig, int modifiers,
+            String mname) {
+        CodeGen cg = new CodeGen(this);
+        /* This code generates forwarding wrappers for 
+         * the (local) unambiguous name of the function.
+         */
+                
+        // unambiguous within component
+        String wname = idOrOpToString(x.getUnambiguousName());
+        cg.generateWrapperMethodCode(modifiers, mname, wname, sig, params);
+    }
+
+
+    /**
+     * @param params
+     * @param sig
+     * @param modifiers
+     * @param mname
+     * @param cg
+     * @param sf
+     */
+    private void generateUnambiguousWrappersForApi() {
+
+        for (Map.Entry<String, Set<Function>> entry : exportedToUnambiguous
+                .entrySet()) {
+            Set<Function> sf = entry.getValue();
+            for (Function function : sf) {
+                List<Param> params = function.parameters();
+
+                String sig = NamingCzar.jvmSignatureFor(
+                        NodeUtil.getParamType(params, function.getSpan()),
+                        function.getReturnType().unwrap(),
+                        component.getName());
+                
+                String mname = idOrOpToString(function.name()); // entry.getKey();
+
+                String function_ua_name = idOrOpToString(function.unambiguousName());
+                generateWrapperMethodCode(
+                        Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, mname,
+                        function_ua_name, sig, params);
+            }
+        }
+    }
+
+    /** Generate an actual Java method and body code from an Expr.
+     *  Should be done within a nested codegen as follows:
+     *  new CodeGen(this).generateActualMethodCode(...);
+     */
+    private void generateWrapperMethodCode(int modifiers, String mname, String wname, String sig,
+                                          List<Param> params) {
+
+        // ignore virtual, now.
+        if (0 == (Opcodes.ACC_STATIC & modifiers))
+            return;
+        
+        mv = cw.visitCGMethod(modifiers, wname, sig, null, null);
+        mv.visitCode();
+
+        // Need to copy the parameter across for the wrapper call.
+        // Modifiers should tell us how to do the call, maybe?
+        // Invokestatic, for now.
+
+        int i = 0;
+        
+        for (Param p : params) {
+            // Type ty = p.getIdType().unwrap();
+            mv.visitVarInsn(Opcodes.ALOAD, i);
+            i++;
+        }
+
+        mv.visitMethodInsn(Opcodes.INVOKESTATIC, packageAndClassName, mname, sig);
+        
+        methodReturnAndFinish();
     }
 
@@ -1197 +1327 @@
                          sig, params.size(), true);
 
+        
+        generateAllWrappersForFn(x, params, sig, modifiers, mname);
+        
     }
 
@@ -1202 +1335 @@
      * @param cg
      */
+
     private void methodReturnAndFinish() {
         mv.visitInsn(Opcodes.ARETURN);
@@ -1302 +1436 @@
     private String singleName(IdOrOpOrAnonymousName name) {
         String nameString = idOrOpToString((IdOrOp)name);
-        String mname = Naming.mangleIdentifier(nameString);
+        String mname = nameString; // Naming.mangleIdentifier(nameString);
         return mname;
     }
@@ -1471 +1605 @@
                 int lastDot = n.lastIndexOf(".");
                 calleePackageAndClass = n.substring(0, lastDot).replace(".", "/");
-                method = n.substring(lastDot+1);
+                method = n.substring(lastDot+2);
+                int foreign_tag = method.indexOf(Naming.FOREIGN_TAG);
+                calleePackageAndClass = calleePackageAndClass + "/" + method.substring(0, foreign_tag);
+                method = method.substring(foreign_tag+1);
+                int paren_tag = method.indexOf("(");
+                if (paren_tag != -1)
+                    method = method.substring(0, paren_tag);
             }
         }
@@ -1936 +2076 @@
 
             mv.visitInsn(Opcodes.DUP);
-            int taskVar = mv.createCompilerLocal(Naming.mangleIdentifier(task),
+            int taskVar = mv.createCompilerLocal(task, // Naming.mangleIdentifier(task),
                     NamingCzar.internalToDesc(task));
             taskVars[i] = taskVar;
@@ -2045 +2185 @@
         mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL,
                            NamingCzar.makeInnerClassName(id),
-                           Naming.mangleIdentifier(opToString(op)),
+                           // Naming.mangleIdentifier(opToString(op)),
+                           opToString(op),
                            "(Lcom/sun/fortress/compiler/runtimeValues/FZZ32;)Lcom/sun/fortress/compiler/runtimeValues/FString;");
     }
@@ -2388 +2529 @@
             Map<IdOrOpOrAnonymousName,MultiMap<Integer, Function>> size_partitioned_overloads,
             TypeAnalyzer ta,
-            ClassWriter cw
+            CodeGenClassWriter cw, CodeGen cg
             ) {
 
@@ -2413 +2554 @@
 
                os.generateAnOverloadDefinition(s2, cw);
+               if (cg != null) {
+                   /* Need to check if the overloaded function happens to match
+                    * a name in an API that this component exports; if so, 
+                    * generate a forwarding wrapper from the 
+                    */
+               }
 
                for (Map.Entry<String, OverloadSet> o_entry : os.getOverloadSubsets().entrySet()) {

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

@@ -48 +48 @@
 
     /**
-     * Produce the set of unqualified, unambiguous names corresponding to the
-     * given function name.  Imported names are included. An undefined reference
-     * produces an empty set.
+     * Produce the set of qualified, unambiguous names corresponding to the
+     * given, possibly qualified function name.  
      */
     public abstract Set<IdOrOp> unambiguousFunctionNames(IdOrOp name);

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

@@ -446 +446 @@
     public Set<IdOrOp> unambiguousFunctionNames(final IdOrOp name) {
 
-        // Function that gets an unambiguous name out of a Function. If it is
-        // not a DeclaredFunction or FunctionalMethod, the original name will
-        // be returned.
+        // Function that gets an unambiguous name out of a Function.
         Lambda<Function, IdOrOp> unambiguousNameFromFunction = new Lambda<Function, IdOrOp>() {
+            @Override public IdOrOp value(Function fn) {
+                return fn.unambiguousName();
+            }
+        };
+
+        // Qualifies the given name with the given API. Create normal Lambdas
+        // by binding an API.
+        Lambda2<APIName, IdOrOp, IdOrOp> addApi = new Lambda2<APIName, IdOrOp, IdOrOp>() {
             @Override
-            public IdOrOp value(Function fn) {
-                if (fn instanceof DeclaredFunction) {
-                    return ((DeclaredFunction) fn).ast().getUnambiguousName();
-                } else if (fn instanceof FunctionalMethod) {
-                    return ((FunctionalMethod) fn).ast().getUnambiguousName();
+            public IdOrOp value(APIName api, IdOrOp name) {
+                if (name instanceof Id) {
+                    return NodeFactory.makeId(Option.some(api), (Id) name);
                 } else {
-                    return name;
+                    return NodeFactory.makeOp(Option.some(api), (Op) name);
                 }
             }
         };
+        
+        // If this name is qualified, then lookup names only in that API.
+        if (name.getApiName().isSome()) {
+            APIName api = name.getApiName().unwrap();
+            
+            // Get the functions from this api with this name.
+            Set<? extends Function> functions =
+                _onDemandImportedApis.get(api).functions().matchFirst(name);
+            
+            // Return their unambiguous names, qualified.
+            Lambda<IdOrOp, IdOrOp> addThisApi = LambdaUtil.bindFirst(addApi, api);
+            return CollectUtil.asSet(IterUtil.map(functions,
+                                                  LambdaUtil.compose(unambiguousNameFromFunction,
+                                                                     addThisApi)));
+        }
 
         // First get all the declarations from this compilation unit.
@@ -468 +487 @@
         // Loop over all the imported APIs.
         for (final ApiIndex api : _onDemandImportedApis.values()) {
-
-            // Qualifies the names with this API.
-            Lambda<IdOrOp, IdOrOp> addApi = new Lambda<IdOrOp, IdOrOp>() {
-                @Override
-                public IdOrOp value(IdOrOp name) {
-                    if (name instanceof Id) {
-                        return NodeFactory.makeId(api.ast().getName(), (Id) name, NodeUtil.getSpan(name));
-                    } else {
-                        return NodeFactory.makeOp(api.ast().getName(), (Op) name);
-                    }
-                }
-            };
+            Lambda<IdOrOp, IdOrOp> addThisApi = LambdaUtil.bindFirst(addApi, api.ast().getName());
 
             // Get all the declarations from this API and qualify the names.
             functions = api.functions().matchFirst(name);
-            results = IterUtil.compose(results, IterUtil.map(functions, LambdaUtil.compose(unambiguousNameFromFunction,
-                                                                                           addApi)));
-        }
+            results = IterUtil.compose(results,
+                                       IterUtil.map(functions,
+                                                    LambdaUtil.compose(unambiguousNameFromFunction,
+                                                                       addThisApi)));
+        }
+
+        // Add in the unambiguous names from the alias.
+        // TODO: Correct behavior?
+        if (_aliases.containsKey(name)) {
+            results = IterUtil.compose(results,
+                                       unambiguousFunctionNames((IdOrOp) _aliases.get(name)));
+        }
+
         return CollectUtil.asSet(results);
     }

trunk/ProjectFortress/src/com/sun/fortress/compiler/index/Coercion.java

@@ -118 +118 @@
         return (IdOrOp) ast().getHeader().getName();
     }
+    
+    public IdOrOp unambiguousName() {
+        return (IdOrOp) ast().getUnambiguousName();
+    }
 
     public Id declaringTrait() {

trunk/ProjectFortress/src/com/sun/fortress/compiler/index/Constructor.java

@@ -91 +91 @@
         return _declaringTrait;
     }
+    
+    public IdOrOp unambiguousName() {
+        return name();
+    }
 
     //    public List<StaticParam> staticParams() { return _staticParams; }

trunk/ProjectFortress/src/com/sun/fortress/compiler/index/DeclaredFunction.java

@@ -66 +66 @@
         return (IdOrOp) NodeUtil.getName(_ast);
     }
+    
+    public IdOrOp unambiguousName() {
+        return (IdOrOp) _ast.getUnambiguousName();
+    }
 
     @Override

trunk/ProjectFortress/src/com/sun/fortress/compiler/index/DeclaredMethod.java

@@ -123 +123 @@
         return (IdOrOp) NodeUtil.getName(_ast);
     }
+    
+    public IdOrOp unambiguousName() {
+        return (IdOrOp) _ast.getUnambiguousName();
+    }
 
     @Override

trunk/ProjectFortress/src/com/sun/fortress/compiler/index/FieldGetterOrSetterMethod.java

@@ -114 +114 @@
         return _ast.getName();
     }
+    
+    public IdOrOp unambiguousName() {
+        return name();
+    }
 }

trunk/ProjectFortress/src/com/sun/fortress/compiler/index/Functional.java

@@ -45 +45 @@
 
     public abstract IdOrOp name();
+    
+    public abstract IdOrOp unambiguousName();
 
     public String toString() {

trunk/ProjectFortress/src/com/sun/fortress/compiler/index/FunctionalMethod.java

@@ -98 +98 @@
         return (IdOrOp) NodeUtil.getName(_ast);
     }
+    
+    public IdOrOp unambiguousName() {
+        return (IdOrOp) _ast.getUnambiguousName();
+    }
 
     public Id declaringTrait() {

trunk/ProjectFortress/src/com/sun/fortress/compiler/nativeInterface/FortressMethodAdapter.java

@@ -24 +24 @@
 
 import com.sun.fortress.compiler.codegen.CodeGen;
+import com.sun.fortress.compiler.codegen.CodeGenClassWriter;
 import com.sun.fortress.compiler.index.Function;
 import com.sun.fortress.compiler.OverloadSet;
@@ -70 +71 @@
     private Map<IdOrOpOrAnonymousName,MultiMap<Integer, Function>> sizePartitionedOverloads;
     private TypeAnalyzer ta;
-    private ClassWriter cw;
+    private CodeGenClassWriter cw;
     private Set<String> overloadedNamesAndSigs;
 
@@ -112 +113 @@
     }
 
-    public FortressMethodAdapter(ClassWriter cv,
+    public FortressMethodAdapter(CodeGenClassWriter cv,
             String inputClassName,
             String outputClassName,
@@ -129 +130 @@
 
     public void visit(int version, int access, String name, String signature,
-                      String superName, String[] interfaces) {
-        Debug.debug( Debug.Type.COMPILER, 1,
-                     "visit:" + name + " generate " + inputClassName);
-        cv.visit(version, access, outputClassName, signature, superName, interfaces);
-
-        overloadedNamesAndSigs = CodeGen.generateTopLevelOverloads(apiName, sizePartitionedOverloads, ta, cw);
+            String superName, String[] interfaces) {
+        Debug.debug(Debug.Type.COMPILER, 1, "visit:" + name + " generate "
+                + inputClassName);
+        cv.visit(version, access, outputClassName, signature, superName,
+                interfaces);
+
+        /*
+         * TODO there may be more work be done in the method called below.
+         * cg=null allows a bunch of code reuse, but does not deal with the
+         * possibility of unambiguous reference to one of these
+         * adapter-generated overloaded (?) native methods.
+         */
+
+        overloadedNamesAndSigs = CodeGen.generateTopLevelOverloads(apiName,
+                sizePartitionedOverloads, ta, cw, /* cg= */null);
     }
 

trunk/ProjectFortress/src/com/sun/fortress/compiler/nativeInterface/FortressTransformer.java

@@ -24 +24 @@
 
 import com.sun.fortress.compiler.ByteCodeWriter;
+import com.sun.fortress.compiler.codegen.CodeGenClassWriter;
 import com.sun.fortress.compiler.index.Function;
 import com.sun.fortress.compiler.OverloadSet;
@@ -45 +46 @@
         try {
             ClassReader cr = new ClassReader(inputClassName);
-            ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+            CodeGenClassWriter cw = new CodeGenClassWriter(ClassWriter.COMPUTE_FRAMES);
             String outputClassName = Naming.NATIVE_PREFIX_DOT + inputClassName;
             

trunk/ProjectFortress/src/com/sun/fortress/exceptions/InterpreterBug.java

@@ -71 +71 @@
 
     public static <T> T bug(String msg) {
-        throw new InterpreterBug(msg);
+        throw new InterpreterBug("** bug! " + msg);
     }
 

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

@@ -486 +486 @@
                                     Option<Type> returnType,
                                     Option<Expr> body) {
-        return makeFnDecl(span, mods, name,
+        return makeFnDecl(span,
+                          mods,
+                          name,
                           Collections.<StaticParam>emptyList(),
                           params, returnType,
@@ -494 +496 @@
                           body);
     }
-
+    
+    private static String uaName(String tag, Span span ) {
+        String s = span.toString();
+        s = s.replaceAll("/", "|");
+        return s;
+    }
+    
     public static FnDecl makeFnDecl(Span span, Modifiers mods,
                                     IdOrOpOrAnonymousName name,
@@ -505 +513 @@
         IdOrOp unambiguousName;
         if (name instanceof Op) {
-                unambiguousName = makeOp((Op)name, "OP$"+span.toString());
+                unambiguousName = makeOp((Op)name, uaName("OP", span));
         } else {
-                unambiguousName = makeId(span, "FN$"+span.toString());
+                unambiguousName = makeId(span, uaName("FN", span));
         }
         return makeFnDecl(span, mods, name, staticParams, params, returnType,
@@ -525 +533 @@
         IdOrOp unambiguousName;
         if (name instanceof Op) {
-                unambiguousName = makeOp((Op)name, "OP$"+span.toString());
+                unambiguousName = makeOp((Op)name, uaName("OP", span));
         } else {
-                unambiguousName = makeId(span, "FN$"+span.toString());
+                unambiguousName = makeId(span, uaName("FN", span));
         }
         return makeFnDecl(span, mods, name, staticParams, params, returnType,
@@ -546 +554 @@
     }
 
-    public static FnDecl makeFnDecl(Span span, Modifiers mods,
+    public static FnDecl makeFnDecl(Span span,
+                                    Modifiers mods,
                                     IdOrOpOrAnonymousName name,
                                     List<StaticParam> staticParams,
@@ -1767 +1776 @@
     public static Op makeOp(final APIName api, Op op) {
         return makeOp(NodeUtil.getSpan(op), Option.some(api),
+                      op.getText(), op.getFixity(), op.isEnclosing() );
+    }
+
+    public static Op makeOp(Option<APIName> api, Op op) {
+        return makeOp(NodeUtil.getSpan(op), api,
                       op.getText(), op.getFixity(), op.isEnclosing() );
     }

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

@@ -32 +32 @@
 import com.sun.fortress.repository.graph.ApiGraphNode;
 import com.sun.fortress.repository.graph.GraphNode;
+import com.sun.fortress.runtimeSystem.Naming;
 import com.sun.fortress.scala_src.typechecker.IndexBuilder;
 import com.sun.fortress.useful.*;
@@ -172 +173 @@
     private static Span span() {
         return NodeFactory.internalSpan;
-    }
-
-    private static Span span(MethodNode m) {
-        return NodeFactory.makeSpan(methodName(m));
     }
 
@@ -413 +410 @@
 
         public int compare(MethodNode o1, MethodNode o2) {
-            return methodName(o1).compareTo(methodName(o2));
+            return justMethodName(o1).compareTo(justMethodName(o2));
         }
 
@@ -489 +486 @@
 
     private FnDecl recurOnMethod(APIName importing_package, ClassNode cl, MethodNode m, boolean is_static) {
-        String methodKey = methodName(m);
+        String methodKey = methodName(cl, m);
         if (methodToDecl.containsKey(methodKey)) return methodToDecl.get(methodKey);
 
@@ -501 +498 @@
         for (Type pt : pts) {
             com.sun.fortress.nodes.Type type = recurOnOpaqueClass(importing_package, pt);
-            Span param_span = NodeFactory.makeSpan(span(m) + " p#" + i);
+            Span param_span = NodeFactory.makeSpan(span(methodKey) + " p#" + i);
             Id id = NodeFactory.makeId(param_span, "p" + (i++));
             Param p = NodeFactory.makeParam(id, type);
@@ -507 +504 @@
         }
 
-        Span fn_span = span(m);
+        Span fn_span = span(methodKey);
         Id id = is_static ? NodeFactory.makeId(fn_span, getSimpleName(cl) + "." + getName(m)) : NodeFactory.makeId(
                 fn_span,
                 getName(m));
+        
+        String uan = Naming.FOREIGN_TAG + methodKey ;
+        
         FnDecl fndecl = NodeFactory.makeFnDecl(fn_span,
                                                Modifiers.None,
-                                               id,
+                                               (IdOrOpOrAnonymousName) id,
+                                               Collections.<StaticParam>emptyList(),
                                                params,
                                                Option.some(return_type),
-                                               Option.<Expr>none());
+                                               Option.<List<com.sun.fortress.nodes.Type>>none(),
+                                               Option.<WhereClause>none(),
+                                               Option.<Contract>none(),
+                                               (IdOrOp) NodeFactory.makeId(fn_span, uan),
+                                               Option.<Expr>none(),
+                                               Option.<IdOrOp>none()
+                                               );
+        
         methodToDecl.put(methodKey, fndecl);
         return fndecl;
@@ -525 +533 @@
      * @return
      */
-    private static String methodName(MethodNode m) {
+    private static String methodName(ClassNode cl, MethodNode m) {
+        String s = cl.name;
+        int i = s.lastIndexOf("/");
+        s = s.substring(i+1);
+        return s + Naming.FOREIGN_TAG + m.name + m.desc;
+    }
+    
+    private static String justMethodName(MethodNode m) {
         return m.name + m.desc;
     }

trunk/ProjectFortress/src/com/sun/fortress/runtimeSystem/Naming.java

@@ -634 +634 @@
                 mangledString = "\\=" + mangledString;
 
+            // debugging check for double-mangling
+            if (mangledString.startsWith("\\-"))
+                mangledString = mangledString;
+            
             return mangledString;
         }

trunk/ProjectFortress/src/com/sun/fortress/scala_src/disambiguator/ExprDisambiguator.scala

@@ -397 +397 @@
                   } else result = Some(SVarRef(info, newName, sargs, depth))
                 case (0, f, _) if f > 0 =>
-                  var new_fns = setToList[IdOrOp](toSet(fns))
+                  val new_fns = setToList[IdOrOp](toSet(fns))
+                  val unambiguous_fns = setToList[IdOrOp](toSet(env.unambiguousFunctionNames(name)))
                   // Create a list of overloadings for this FnRef from the
                   // matching function names.
                   // TODO: insert correct number of to-infer arguments?
                   result = Some(SFnRef(info, sargs, depth, name, new_fns, None,
-                                       new_fns.map(new Overloading(info, _, None)),
+                                       unambiguous_fns.map(new Overloading(info, _, None)),
                                        None))
                 case (1, 0, 1) =>
@@ -443 +444 @@
           }
         else {
-          var new_fns = setToList[IdOrOp](toSet(fns))
+          val new_fns = setToList[IdOrOp](toSet(fns))
+          val unambiguous_fns = setToList[IdOrOp](toSet(env.unambiguousFunctionNames(fn_name)))
           SFnRef(info, sargs, depth, fn_name.asInstanceOf[Id], new_fns, ovl,
                  // Create a list of overloadings for this FnRef from the matching
                  // function names.
-                 new_fns.map(new Overloading(info, _, None)), ovlType)
+                 unambiguous_fns.map(new Overloading(info, _, None)), ovlType)
         }
 
@@ -801 +803 @@
       if (ops.isEmpty) None
       else {
-        var new_ops = setToList[IdOrOp](toSet(ops))
+        val new_ops = setToList[IdOrOp](toSet(ops))
+        val unambiguous_ops = setToList[IdOrOp](toSet(env.unambiguousFunctionNames(op_name)))
         // Create a list of overloadings for this OpRef from the matching
         // operator names.
         Some(SOpRef(info, sargs, depth, op_name, new_ops, oldOvl,
-                    new_ops.map(new Overloading(info, _, None)), ovlType))
+                    unambiguous_ops.map(new Overloading(info, _, None)), ovlType))
       }
     case _ => None

trunk/ProjectFortress/src/com/sun/fortress/scala_src/linker/HygienicRenamer.scala

@@ -154 +154 @@
              SOptionalSymbol(walk(getInfo).asInstanceOf[com.sun.fortress.nodes.ASTNodeInfo], walk(getSymbol).asInstanceOf[com.sun.fortress.nodes.SyntaxSymbol])
          case SOverloading(getInfo, getUnambiguousName, getType) =>
-             SOverloading(walk(getInfo).asInstanceOf[com.sun.fortress.nodes.ASTNodeInfo], walk(getUnambiguousName).asInstanceOf[com.sun.fortress.nodes.IdOrOp], walk(getType).asInstanceOf[Option[com.sun.fortress.nodes.Type]])
+             SOverloading(walk(getInfo).asInstanceOf[com.sun.fortress.nodes.ASTNodeInfo], walk(getUnambiguousName).asInstanceOf[com.sun.fortress.nodes.IdOrOp], walk(getType).asInstanceOf[Option[com.sun.fortress.nodes.ArrowType]])
          case SParam(getInfo, getName, getMods, getIdType, getDefaultExpr, getVarargsType) =>
              SParam(walk(getInfo).asInstanceOf[com.sun.fortress.nodes.ASTNodeInfo], walk(getName).asInstanceOf[com.sun.fortress.nodes.Id], walk(getMods).asInstanceOf[com.sun.fortress.nodes_util.Modifiers], walk(getIdType).asInstanceOf[Option[com.sun.fortress.nodes.Type]], walk(getDefaultExpr).asInstanceOf[Option[com.sun.fortress.nodes.Expr]], walk(getVarargsType).asInstanceOf[Option[com.sun.fortress.nodes.Type]])

trunk/ProjectFortress/src/com/sun/fortress/scala_src/typechecker/STypeChecker.scala

@@ -337 +337 @@
     }
 
+  /**
+   * Lookup the functional indices for the given name in the proper type
+   * environment.
+   */
+  protected def getFnIndicesFromName(name: Name): Option[List[Functional]] =
+    getRealName(name, toList(current.ast.getImports)) match {
+      case id@SIdOrOp(_, Some(api), _) => getEnvFromApi(api).getFnIndices(id)
+      case id:IdOrOp => env.getFnIndices(id)
+      case _ => None
+    }
+
   def getErrors(): List[StaticError] = errors.errors
 

trunk/ProjectFortress/src/com/sun/fortress/scala_src/typechecker/impls/Functionals.scala

@@ -21 +21 @@
 import com.sun.fortress.compiler.index._
 import com.sun.fortress.exceptions._
+import com.sun.fortress.exceptions.InterpreterBug.bug
 import com.sun.fortress.exceptions.StaticError.errorMsg
 import com.sun.fortress.nodes._
@@ -466 +467 @@
   def checkFunctionals(node: Node): Node = node match {
 
-    case SOverloading(info, name, _) => {
-      val checkedName = check(name).asInstanceOf[IdOrOp]
+    case SOverloading(info, unambigName, _) => {
+      val checkedName = check(unambigName).asInstanceOf[IdOrOp]
+
+      // Should have one arrow type for this unambiguous name.
       getTypeFromName(checkedName) match {
-        case Some(checkedType) =>
-          SOverloading(info, checkedName, Some(normalize(checkedType)))
+        case Some(arrow: ArrowType) =>
+          SOverloading(info, checkedName, Some(arrow))
+        case Some(typ) =>
+          bug("type env binds unambiguous name %s to non-arrow type %s".format(unambigName, typ))
         case None => node
       }
@@ -557 +562 @@
         case SOverloading(info, name, Some(ty)) =>
           instantiateStaticParams(sargs, ty).
-            map(t => SOverloading(info, name, Some(t)))
+            map(t => SOverloading(info, name, Some(t.asInstanceOf[ArrowType])))
         case _ => hadNoType = true; None
       }

trunk/ProjectFortress/src/com/sun/fortress/scala_src/typechecker/staticenv/STypeEnv.scala

@@ -31 +31 @@
 import com.sun.fortress.scala_src.useful.Options._
 import com.sun.fortress.scala_src.useful.Sets._
-import com.sun.fortress.scala_src.useful.STypesUtil
-import com.sun.fortress.scala_src.useful.STypesUtil.TypeThunk
+import com.sun.fortress.scala_src.useful.SNodeUtil._
+import com.sun.fortress.scala_src.useful.STypesUtil._
 import edu.rice.cs.plt.collect.Relation
 
@@ -101 +101 @@
   /** Get the modifiers for the given name, if it exists. */
   def getMods(x: Name): Option[Modifiers] = lookup(x).map(_.mods)
+  
+  /** Get the functional indices for this name, if any. */
+  def getFnIndices(x: Name): Option[List[Functional]] =
+    lookup(x).map(_.fnIndices)
 }
 
@@ -151 +155 @@
                             typeThunk: TypeThunk,
                             mods: Modifiers,
-                            mutable: Boolean): TypeBinding =
-    TypeBinding(name, typeThunk, mods, mutable)
+                            mutable: Boolean,
+                            functions: Collection[Functional]): TypeBinding =
+    TypeBinding(name, typeThunk, mods, mutable, functions.toList)
 
   /**
@@ -163 +168 @@
                             mutable: Boolean): TypeBinding = {
     val typeThunk = new TypeThunk { def apply: Option[Type] = Some(typ) }
-    TypeBinding(name, typeThunk, mods, mutable)
+    TypeBinding(name, typeThunk, mods, mutable, Nil)
   }
 
@@ -211 +216 @@
               NF.makeArrowType(NU.getSpan(qualifiedName),
                                // Constructors must have all param types.
-                               STypesUtil.makeDomainType(toList(params)).get,
+                               makeDomainType(toList(params)).get,
                                NF.makeTraitType(qualifiedName))
             case Some(params) =>
               // Generic arrow type for constructor.
-              val sargs = toList(sparams).map(STypesUtil.staticParamToArg)
+              val sargs = toList(sparams).map(staticParamToArg)
               NF.makeArrowType(NU.getSpan(decl),
                                false,
                                // Constructors must have all param types.
-                               STypesUtil.makeDomainType(toList(params)).get,
+                               makeDomainType(toList(params)).get,
                                NF.makeTraitType(qualifiedName,
                                                 toJavaList(sargs)),
@@ -242 +247 @@
           def apply: Option[Type] = v.getInferredType
         }
-        makeBinding(x, lazyTypeEvaluation, v.modifiers, v.mutable)
+        makeBinding(x, lazyTypeEvaluation, v.modifiers, v.mutable, Nil)
       })
     }
@@ -259 +264 @@
                                        (functions: Iterable[(S,Set[T])],
                                         api: Option[APIName]): Iterable[TypeBinding] = {
-    functions.map{ tuple =>
-      val (x,fns) = tuple
-      // Lazily compute the type for this function binding at the time of
-      // lookup.
-      val lazyTypeEvaluation: TypeThunk = new TypeThunk {
+                                         
+    // Collect all bindings found among all these functions.
+    functions.flatMap { nameAndFunctions =>
+      val (f, fnsSet) = nameAndFunctions
+      val fns = fnsSet.toList
+      
+      // Create the binding for each overloading of the function named f.
+      val unambiguousBindings = fns.map { fn =>
+        
+        // Create a lazy computation for the type of this overloading.
+        val lazyType = new TypeThunk {
+          def apply: Option[Type] = makeArrowFromFunctional(fn)
+        }
+        
+        // Bind the unambiguous name of this overloading to its type.
+        makeBinding(unqualifiedName(fn.unambiguousName),
+                    lazyType,
+                    fn.mods,
+                    false,
+                    List(fn))
+      }
+      
+      // Create a lazy computation for the type of the whole overloaded
+      // function named x.
+      val ambiguousThunk = new TypeThunk {
         def apply: Option[Type] = {
-          // TODO: Currently ignoring any errors from makeArrowFromFunctional
-          val oTypes = fns.flatMap[Type](STypesUtil.makeArrowFromFunctional)
+          val oTypes = fns.flatMap[Type](makeArrowFromFunctional)
           if (oTypes.isEmpty)
             None
@@ -273 +297 @@
         }
       }
-      val mods = if ( fns.isEmpty ) Modifiers.None
-                 else fns.find(_.mods != Modifiers.None) match {
-                   case Some(f) => f.mods
-                     case _ => Modifiers.None
-                   }
-      makeBinding(x, lazyTypeEvaluation, mods, false)
+      
+      // Create the modifiers for the whole binding.
+      val ambiguousMods =
+        if (fns.isEmpty)
+          Modifiers.None
+        else fns.find(_.mods != Modifiers.None) match {
+          case Some(f) => f.mods
+          case _ => Modifiers.None
+        }
+      
+      // Bind the ambiguous, plain name of this function to the intersection
+      // of all its overloadings' types.
+      val ambiguousBinding = makeBinding(unqualifiedName(f),
+                                         ambiguousThunk,
+                                         ambiguousMods,
+                                         false,
+                                         fns)
+      
+      // Return all the bindings.
+      ambiguousBinding :: unambiguousBindings
     }
   } 
@@ -293 +331 @@
  * @param mods Any modifiers for the binding.
  * @param mutable Whether or not the binding is mutable.
+ * @param fnIndices A list of Functional indices, if any, to which this name
+ *                  refers.
  */
 case class TypeBinding(name: Name,
                        typeThunk: TypeThunk,
                        mods: Modifiers,
-                       mutable: Boolean)
+                       mutable: Boolean,
+                       fnIndices: List[Functional])
 
 /**

trunk/ProjectFortress/src/com/sun/fortress/scala_src/useful/STypesUtil.scala

@@ -796 +796 @@
                              (implicit analyzer: TypeAnalyzer)
                               : Option[Overloading] = {
-    // Is this arrow type applicable.
-    def arrowTypeIsApplicable(ovType: ArrowType): Option[Type] = {
-    
-      // If static args, then instantiate the unlifted static params.
-      val typ1 =
-        if (!sargs.isEmpty)
-          instantiateStaticParams(sargs, ovType).getOrElse(return None)
-        else
-          ovType
-      
-      // If there were lifted, inferred static args, then instantiate those.
-      val typ2 =
-        if (!liftedInfSargs.isEmpty)
-          instantiateLiftedStaticParams(liftedInfSargs, typ1).getOrElse(return None)
-        else
-          typ1
-
-      // If there are still some static params in it, then we can't infer them
-      // so it's not applicable.
-      val typ = typ2.asInstanceOf[ArrowType]
+    val SOverloading(ovInfo, ovName, Some(ovType)) = overloading
+
+    // If static args, then instantiate the unlifted static params.
+    val typ1 =
+      if (!sargs.isEmpty)
+        instantiateStaticParams(sargs, ovType).getOrElse(return None)
+      else
+        ovType
+
+    // If there were lifted, inferred static args, then instantiate those.
+    val typ2 =
+      if (!liftedInfSargs.isEmpty)
+        instantiateLiftedStaticParams(liftedInfSargs, typ1).getOrElse(return None)
+      else
+        typ1
+
+    // If there are still some static params in it, then we can't infer them
+    // so it's not applicable.
+    val typ = typ2.asInstanceOf[ArrowType]
+    val newOvType =
       if (!hasStaticParams(typ) && isSubtype(typ.getDomain, smaArrow.getDomain))
-        Some(typ)
+        typ
       else
-        None
-    }
-
-    // If overloading type is an intersection, check that any of its
-    // constituents is applicable.
-    val applicableArrows = conjuncts(toOption(overloading.getType).get).
-      map(_.asInstanceOf[ArrowType]).
-      flatMap(arrowTypeIsApplicable).
-      toList
-
-    val overloadingType = applicableArrows match {
-      case Nil => return None
-      case t::Nil => t
-      case _ => NF.makeIntersectionType(toJavaList(applicableArrows))
-    }
-    Some(SOverloading(overloading.getInfo,
-                      overloading.getUnambiguousName,
-                      Some(overloadingType)))
+        return None
+
+    Some(SOverloading(ovInfo, ovName, Some(newOvType)))
   }