Properly register types on the JS foreign instruction.

sdk/lib/_internal/compiler/implementation/ssa/builder.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 161 matching lines @@
   void redirectElement(Element from, Element to) {
     assert(redirectionMapping[from] == null);
     redirectionMapping[from] = to;
     assert(isStoredInClosureField(from) || isBoxed(from));
   }
 
   HInstruction createBox() {
     // TODO(floitsch): Clean up this hack. Should we create a box-object by
     // just creating an empty object literal?
     HInstruction box = new HForeign(const LiteralDartString("{}"),
-                                    const LiteralDartString('Object'),
+                                    HType.UNKNOWN,
                                     <HInstruction>[]);
     builder.add(box);
     return box;
   }
 
   /**
    * If the scope (function or loop) [node] has captured variables then this
    * method creates a box and sets up the redirections.
    */
   void enterScope(Node node, Element element) {
@@ skipping 1126 matching lines @@
     // Call the JavaScript constructor with the fields as argument.
     List<HInstruction> constructorArguments = <HInstruction>[];
     classElement.forEachInstanceField(
         (ClassElement enclosingClass, Element member) {
           constructorArguments.add(potentiallyCheckType(
               fieldValues[member], member.computeType(compiler)));
         },
         includeBackendMembers: true,
         includeSuperMembers: true);
 
-    HForeignNew newObject = new HForeignNew(classElement, constructorArguments);
+    InterfaceType type = classElement.computeType(compiler);
+    HType ssaType = new HBoundedType.exact(type);

[kasperl, 2013/02/04 09:27:50]

This is fairly common. Maybe have an HBoundedType constructor that takes an
element and a compiler?

[ngeoffray, 2013/02/04 10:45:06]

Good point. There are too many constructors in HBoundedType currently, I plan on
cleaning this up with named parameters, and with it add this new constructor
that takes an element.

+    HForeignNew newObject = new HForeignNew(classElement,
+                                            ssaType,
+                                            constructorArguments);
     add(newObject);
 
     // Create the runtime type information, if needed.
-    InterfaceType type = classElement.computeType(compiler);
     List<HInstruction> inputs = <HInstruction>[];
     if (compiler.world.needsRti(classElement)) {
       classElement.typeVariables.forEach((TypeVariableType typeVariable) {
         inputs.add(localsHandler.directLocals[typeVariable.element]);
       });
       callSetRuntimeTypeInfo(classElement, inputs, newObject);
     }
 
     // Generate calls to the constructor bodies.
     for (int index = constructors.length - 1; index >= 0; index--) {
@@ skipping 762 matching lines @@
     closureClassElement.forEachBackendMember((Element member) {
       // The backendMembers also contains the call method(s). We are only
       // interested in the fields.
       if (member.isField()) {
         Element capturedLocal = nestedClosureData.capturedFieldMapping[member];
         assert(capturedLocal != null);
         capturedVariables.add(localsHandler.readLocal(capturedLocal));
       }
     });
 
-    push(new HForeignNew(closureClassElement, capturedVariables));
+    HType type = new HBoundedType.exact(
+        compiler.functionClass.computeType(compiler));
+    push(new HForeignNew(closureClassElement, type, capturedVariables));
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
     visit(node.function);
     localsHandler.updateLocal(elements[node], pop());
   }
 
   visitIdentifier(Identifier node) {
     if (node.isThis()) {
       stack.add(localsHandler.readThis());
@@ skipping 373 matching lines @@
 
   void pushInvokeHelper5(Element helper, HInstruction a0, HInstruction a1,
                          HInstruction a2, HInstruction a3, HInstruction a4) {
     HInstruction reference = new HStatic(helper);
     add(reference);
     List<HInstruction> inputs = <HInstruction>[reference, a0, a1, a2, a3, a4];
     HInstruction result = new HInvokeStatic(inputs);
     push(result);
   }
 
-  HForeign createForeign(String code, String type, List<HInstruction> inputs) {
-    return new HForeign(new LiteralDartString(code),
-                        new LiteralDartString(type),
-                        inputs);
+  HForeign createForeign(String code, HType type, List<HInstruction> inputs) {
+    return new HForeign(new LiteralDartString(code), type, inputs);
   }
 
   HInstruction getRuntimeTypeInfo(HInstruction target) {
     pushInvokeHelper1(backend.getGetRuntimeTypeInfo(), target);
     return pop();
   }
 
   // TODO(karlklose): change construction of the representations to be GVN'able
   // (dartbug.com/7182).
   List<HInstruction> buildTypeArgumentRepresentations(DartType type) {
     HInstruction createForeignArray(String code, inputs) {
-      return createForeign(code, '=List', inputs);
+      return createForeign(code, HType.READABLE_ARRAY, inputs);
     }
     HInstruction typeInfo;
 
     /// Helper to create an instruction that contains the runtime value of
     /// the type variable [variable].
     HInstruction getTypeArgument(TypeVariableType variable) {
       if (typeInfo == null) {
         typeInfo = getRuntimeTypeInfo(localsHandler.readThis());
       }
       int intIndex = RuntimeTypeInformation.getTypeVariableIndex(variable);
@@ skipping 79 matching lines @@
             buildTypeArgumentRepresentations(type);
         // For each type argument, build a call to isSubtype, with the type
         // argument as first and the representation of the tested type as
         // second argument.
         List<HInstruction> checks = <HInstruction>[];
         int index = 0;
         representations.forEach((HInstruction representation) {
           HInstruction position = graph.addConstantInt(index, constantSystem);
           // Get the index'th type argument from the runtime type information.
           HInstruction typeArgument =
-              createForeign('#[#]', 'Object', [typeInfo, position]);
+              createForeign('#[#]', HType.UNKNOWN, [typeInfo, position]);
           add(typeArgument);
           // Create the call to isSubtype.
           List<HInstruction> inputs =
               <HInstruction>[isSubtype, typeArgument, representation];
           HInstruction call = new HInvokeStatic(inputs);
           add(call);
           checks.add(call);
           index++;
         });
         instruction = new HIs(type, <HInstruction>[expression]..addAll(checks));
@@ skipping 177 matching lines @@
       assert(Elements.isLocal(element));
       closureTarget = localsHandler.readLocal(element);
     }
     var inputs = <HInstruction>[];
     inputs.add(closureTarget);
     addDynamicSendArgumentsToList(node, inputs);
     Selector closureSelector = new Selector.callClosureFrom(selector);
     pushWithPosition(new HInvokeClosure(closureSelector, inputs), node);
   }
 
-  void registerForeignTypes(String specString) {
-    CodegenEnqueuer enqueuer = compiler.enqueuer.codegen;
-    for (final typeString in specString.split('|')) {
-      if (typeString == '=List') {
-        enqueuer.registerInstantiatedClass(compiler.listClass);
-      } else if (typeString == 'int') {
-        enqueuer.registerInstantiatedClass(compiler.intClass);
-      } else if (typeString == 'double') {
-        enqueuer.registerInstantiatedClass(compiler.doubleClass);
-      } else if (typeString == 'num') {
-        enqueuer.registerInstantiatedClass(compiler.intClass);
-        enqueuer.registerInstantiatedClass(compiler.doubleClass);
-      } else if (typeString == 'Null') {
-        enqueuer.registerInstantiatedClass(compiler.nullClass);
-      } else if (typeString == 'String') {
-        enqueuer.registerInstantiatedClass(compiler.stringClass);
-      }
-    }
-  }
-
   void handleForeignJs(Send node) {
     Link<Node> link = node.arguments;
     // If the invoke is on foreign code, don't visit the first
     // argument, which is the type, and the second argument,
     // which is the foreign code.
     if (link.isEmpty || link.tail.isEmpty) {
       compiler.cancel('At least two arguments expected',
                       node: node.argumentsNode);
     }
     List<HInstruction> inputs = <HInstruction>[];
     Node type = link.head;
     Node code = link.tail.head;
     addGenericSendArgumentsToList(link.tail.tail, inputs);
 
-    if (type is !LiteralString) {
-      // The type must not be a juxtaposition or interpolation.
-      compiler.cancel('The type of a JS expression must be a string literal',
-                      node: type);
-    }
-    LiteralString typeString = type;
-    // TODO(ngeoffray): This should be registered in codegen, not here.
-    // Also, we should share the type parsing with the native
-    // enqueuer.
-    registerForeignTypes(typeString.dartString.slowToString());
-
+    native.NativeBehavior nativeBehavior =
+        compiler.enqueuer.resolution.nativeEnqueuer.getNativeBehaviorOf(node);
+    HType ssaType = mapNativeBehaviorType(nativeBehavior);
+    print('$node for $ssaType');

[kasperl, 2013/02/04 09:27:50]

Remove printing.

[ngeoffray, 2013/02/04 10:45:06]

Done.

     if (code is StringNode) {
       StringNode codeString = code;
       if (!codeString.isInterpolation) {
         // codeString may not be an interpolation, but may be a juxtaposition.
-        push(new HForeign(codeString.dartString,
-                          typeString.dartString,
-                          inputs));
+        push(new HForeign(codeString.dartString, ssaType, inputs));
         return;
       }
     }
     compiler.cancel('JS code must be a string literal', node: code);
   }
 
   void handleForeignJsCurrentIsolate(Send node) {
     if (!node.arguments.isEmpty) {
       compiler.cancel(
           'Too many arguments to JS_CURRENT_ISOLATE', node: node);
     }
 
     if (!compiler.hasIsolateSupport()) {
       // If the isolate library is not used, we just generate code
       // to fetch the Leg's current isolate.
       String name = backend.namer.CURRENT_ISOLATE;
       push(new HForeign(new DartString.literal(name),
-                        const LiteralDartString('var'),
+                        HType.UNKNOWN,
                         <HInstruction>[]));
     } else {
       // Call a helper method from the isolate library. The isolate
       // library uses its own isolate structure, that encapsulates
       // Leg's isolate.
       Element element = compiler.isolateHelperLibrary.find(
           const SourceString('_currentIsolate'));
       if (element == null) {
         compiler.cancel(
             'Isolate library and compiler mismatch', node: node);
@@ skipping 52 matching lines @@
     visit(closure);
     return params;
   }
 
   void handleForeignDartClosureToJs(Send node, String name) {
     FunctionSignature params = handleForeignRawFunctionRef(node, name);
     List<HInstruction> inputs = <HInstruction>[pop()];
     String invocationName = backend.namer.invocationName(
         new Selector.callClosure(params.requiredParameterCount));
     push(new HForeign(new DartString.literal('#.$invocationName'),
-                      const LiteralDartString('var'),
+                      HType.UNKNOWN,
                       inputs));
   }
 
   void handleForeignSetCurrentIsolate(Send node) {
     if (node.arguments.isEmpty || !node.arguments.tail.isEmpty) {
       compiler.cancel('Exactly one argument required',
                       node: node.argumentsNode);
     }
     visit(node.arguments.head);
     String isolateName = backend.namer.CURRENT_ISOLATE;
     push(new HForeign(new DartString.literal("$isolateName = #"),
-                      const LiteralDartString('void'),
+                      HType.UNKNOWN,
                       <HInstruction>[pop()]));
   }
 
   void handleForeignCreateIsolate(Send node) {
     if (!node.arguments.isEmpty) {
       compiler.cancel('Too many arguments',
                       node: node.argumentsNode);
     }
     String constructorName = backend.namer.isolateName;
     push(new HForeign(new DartString.literal("new $constructorName"),
-                      const LiteralDartString('var'),
+                      HType.UNKNOWN,
                       <HInstruction>[]));
   }
 
   visitForeignSend(Send node) {
     Selector selector = elements.getSelector(node);
     SourceString name = selector.name;
     if (name == const SourceString('JS')) {
       handleForeignJs(node);
     } else if (name == const SourceString('JS_CURRENT_ISOLATE')) {
       handleForeignJsCurrentIsolate(node);
@@ skipping 146 matching lines @@
         inputs.add(localsHandler.readLocal(type.element));
       } else if (member.isInstanceMember()
                  || member.isGenerativeConstructor()) {
         // The type variable is stored in [this].
         if (typeInfo == null) {
           pushInvokeHelper1(backend.getGetRuntimeTypeInfo(),
                             localsHandler.readThis());
           typeInfo = pop();
         }
         int index = RuntimeTypeInformation.getTypeVariableIndex(type);
-        HInstruction foreign = createForeign('#[$index]', 'String',
+        HInstruction foreign = createForeign('#[$index]', HType.STRING,
                                              <HInstruction>[typeInfo]);
         add(foreign);
         inputs.add(foreign);
       } else {
         // TODO(ngeoffray): Match the VM behavior and throw an
         // exception at runtime.
         compiler.cancel('Unimplemented unresolved type variable',
                         node: currentNode);
       }
     }
 
     String template = rti.getTypeRepresentation(argument,
                                                 addTypeVariableReference);
-    HInstruction result = createForeign(template, 'String', inputs);
+    HInstruction result = createForeign(template, HType.STRING, inputs);
     add(result);
     return result;
   }
 
   void handleListConstructor(InterfaceType type,
                              Node currentNode,
                              HInstruction newObject) {
     if (!compiler.world.needsRti(type.element)) return;
     List<HInstruction> inputs = <HInstruction>[];
     if (!type.isRaw) {
@@ skipping 1378 matching lines @@
   }
 
   visitTypedef(Typedef node) {
     compiler.unimplemented('SsaBuilder.visitTypedef', node: node);
   }
 
   visitTypeVariable(TypeVariable node) {
     compiler.internalError('SsaBuilder.visitTypeVariable');
   }
 
+  HType mapBaseType(BaseType baseType) {
+    if (!baseType.isClass()) return HType.UNKNOWN;
+    ClassBaseType classBaseType = baseType;

[kasperl, 2013/02/04 09:27:50]

Unused local variable.

[ngeoffray, 2013/02/04 10:45:06]

Done.

+    return new HType.fromBoundedType(
+        baseType.element.computeType(compiler), compiler, false);
+  }
+
   HType mapInferredType(ConcreteType concreteType) {
     if (concreteType == null) return HType.UNKNOWN;
-    ClassElement element = concreteType.getUniqueType();
-    if (element == null) return HType.UNKNOWN;
-    if (element == builder.compiler.boolClass) return HType.BOOLEAN;
-    if (element == builder.compiler.doubleClass) return HType.DOUBLE;
-    if (element == builder.compiler.intClass) return HType.INTEGER;
-    if (element == builder.compiler.listClass) return HType.READABLE_ARRAY;
-    if (element == builder.compiler.nullClass) return HType.NULL;
-    if (element == builder.compiler.stringClass) return HType.STRING;
-    return HType.UNKNOWN;
+    HType ssaType = HType.CONFLICTING;
+    for (BaseType baseType in concreteType.baseTypes) {
+      ssaType = ssaType.union(mapBaseType(baseType), compiler);
+    }
+    assert(!ssaType.isConflicting());
+    return ssaType;
+  }
+
+  HType mapNativeType(type) {
+    if (type == native.SpecialType.JsObject) {
+      return new HBoundedType.exact(
+          compiler.objectClass.computeType(compiler));
+    } else if (type == native.SpecialType.JsArray) {
+      return HType.READABLE_ARRAY;
+    } else {
+      return new HType.fromBoundedType(type, compiler, false);
+    }
+  }
+
+  HType mapNativeBehaviorType(native.NativeBehavior nativeBehavior) {
+    if (nativeBehavior.typesInstantiated.isEmpty) return HType.UNKNOWN;
+
+    HType ssaType = HType.CONFLICTING;
+    for (final type in nativeBehavior.typesInstantiated) {
+      ssaType = ssaType.union(mapNativeType(type), compiler);
+    }
+    assert(!ssaType.isConflicting());
+    return ssaType;
   }
 }
 
 /**
  * Visitor that handles generation of string literals (LiteralString,
  * StringInterpolation), and otherwise delegates to the given visitor for
  * non-literal subexpressions.
  * TODO(lrn): Consider whether to handle compile time constant int/boolean
  * expressions as well.
  */
@@ skipping 365 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }