Split js interop registration into library/class/member elements

pkg/compiler/lib/src/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.
 
 import 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 1058 matching lines @@
       for (Link<ast.Node> link = initializers;
           !link.isEmpty;
           link = link.tail) {
         assert(link.head is ast.Send);
         if (link.head is! ast.SendSet) {
           // A super initializer or constructor redirection.
           foundSuperOrRedirect = true;
           ast.Send call = link.head;
           assert(ast.Initializers.isSuperConstructorCall(call) ||
               ast.Initializers.isConstructorRedirect(call));
-          FunctionElement target = elements[call].implementation;
+          ConstructorElement target = elements[call];
           CallStructure callStructure =
               elements.getSelector(call).callStructure;
           Link<ast.Node> arguments = call.arguments;
           List<HInstruction> compiledArguments;
           inlinedFrom(resolvedAst, () {
             compiledArguments =
                 makeStaticArgumentList(callStructure, arguments, target);
           });
           inlineSuperOrRedirect(target.resolvedAst, compiledArguments,
               constructorResolvedAsts, fieldValues, constructor);
@@ skipping 1400 matching lines @@
     }
   }
 
   /**
    * Returns a list with the evaluated [arguments] in the normalized order.
    *
    * Precondition: `this.applies(element, world)`.
    * Invariant: [element] must be an implementation element.
    */
   List<HInstruction> makeStaticArgumentList(CallStructure callStructure,
-      Link<ast.Node> arguments, FunctionElement element) {
-    assert(invariant(element, element.isImplementation));
+      Link<ast.Node> arguments, MethodElement element) {
+    assert(invariant(element, element.isDeclaration));
 
     HInstruction compileArgument(ast.Node argument) {
       visit(argument);
       return pop();
     }
 
     return Elements.makeArgumentsList<HInstruction>(
         callStructure,
         arguments,
-        element,
+        element.implementation,
         compileArgument,
         backend.nativeData.isJsInteropMember(element)
             ? handleConstantForOptionalParameterJsInterop
             : handleConstantForOptionalParameter);
   }
 
   void addGenericSendArgumentsToList(
       Link<ast.Node> link, List<HInstruction> list) {
     for (; !link.isEmpty; link = link.tail) {
       visit(link.head);
@@ skipping 547 matching lines @@
   }
 
   /// Generate a call to a super method or constructor.
   void generateSuperInvoke(ast.Send node, MethodElement method,
       SourceInformation sourceInformation) {
     // TODO(5347): Try to avoid the need for calling [implementation] before
     // calling [makeStaticArgumentList].
     Selector selector = elements.getSelector(node);
     assert(invariant(node, selector.applies(method.implementation),
         message: "$selector does not apply to ${method.implementation}"));
-    List<HInstruction> inputs = makeStaticArgumentList(
-        selector.callStructure, node.arguments, method.implementation);
+    List<HInstruction> inputs =
+        makeStaticArgumentList(selector.callStructure, node.arguments, method);
     push(buildInvokeSuper(selector, method, inputs, sourceInformation));
   }
 
   /// Access the value from the super [element].
   void handleSuperGet(ast.Send node, Element element) {
     Selector selector = elements.getSelector(node);
     SourceInformation sourceInformation =
         sourceInformationBuilder.buildGet(node);
     push(buildInvokeSuper(
         selector, element, const <HInstruction>[], sourceInformation));
@@ skipping 311 matching lines @@
 
     List<HInstruction> inputs = <HInstruction>[];
     if (constructor.isGenerativeConstructor &&
         backend.nativeData
             .isNativeOrExtendsNative(constructor.enclosingClass) &&
         !backend.nativeData.isJsInteropMember(constructor)) {
       // Native class generative constructors take a pre-constructed object.
       inputs.add(graph.addConstantNull(closedWorld));
     }
     inputs.addAll(makeStaticArgumentList(
-        callStructure, send.arguments, constructorImplementation));
+        callStructure, send.arguments, constructorImplementation.declaration));
 
     TypeMask elementType = computeType(constructor);
     if (isFixedListConstructorCall) {
       if (!inputs[0].isNumber(closedWorld)) {
         HTypeConversion conversion = new HTypeConversion(
             null,
             HTypeConversion.ARGUMENT_TYPE_CHECK,
             commonMasks.numType,
             inputs[0]);
         add(conversion);
@@ skipping 139 matching lines @@
     }
     return false;
   }
 
   visitStaticSend(ast.Send node) {
     internalError(node, "Unexpected visitStaticSend");
   }
 
   /// Generate an invocation to the static or top level [function].
   void generateStaticFunctionInvoke(
-      ast.Send node, FunctionElement function, CallStructure callStructure) {
-    List<HInstruction> inputs = makeStaticArgumentList(
-        callStructure, node.arguments, function.implementation);
+      ast.Send node, MethodElement function, CallStructure callStructure) {
+    List<HInstruction> inputs =
+        makeStaticArgumentList(callStructure, node.arguments, function);
 
     pushInvokeStatic(node, function, inputs,
         sourceInformation:
             sourceInformationBuilder.buildCall(node, node.selector));
   }
 
   /// Generate an invocation to a static or top level function with the wrong
   /// number of arguments.
   void generateStaticFunctionIncompatibleInvoke(
       ast.Send node, Element element) {
@@ skipping 441 matching lines @@
       var filteredArguments = <HInstruction>[];
       var parameterNameMap = new Map<String, js.Expression>();
       params.orderedForEachParameter((ParameterElement parameter) {
         // TODO(jacobr): consider throwing if parameter names do not match
         // names of properties in the class.
         assert(parameter.isNamed);
         HInstruction argument = arguments[i];
         if (argument != null) {
           filteredArguments.add(argument);
           var jsName =
-              backend.nativeData.getUnescapedJSInteropName(parameter.name);
+              backend.nativeData.computeUnescapedJSInteropName(parameter.name);
           parameterNameMap[jsName] = new js.InterpolatedExpression(positions++);
         }
         i++;
       });
       var codeTemplate =
           new js.Template(null, js.objectLiteral(parameterNameMap));
 
       var nativeBehavior = new native.NativeBehavior()
         ..codeTemplate = codeTemplate;
       if (compiler.options.trustJSInteropTypeAnnotations) {
         nativeBehavior.typesReturned.add(constructor.enclosingClass.thisType);
       }
       return new HForeignCode(
           codeTemplate, commonMasks.dynamicType, filteredArguments,
           nativeBehavior: nativeBehavior)
         ..sourceInformation = sourceInformation;
     }
     var target = new HForeignCode(
-        js.js.parseForeignJS("${backend.namer.fixedBackendMethodPath(element)}."
+        js.js.parseForeignJS(
+            "${backend.nativeData.getFixedBackendMethodPath(element)}."
             "${backend.nativeData.getFixedBackendName(element)}"),
         commonMasks.dynamicType,
         <HInstruction>[]);
     add(target);
     // Strip off trailing arguments that were not specified.
     // we could assert that the trailing arguments are all null.
     // TODO(jacobr): rewrite named arguments to an object literal matching
     // the factory constructor case.
     arguments = arguments.where((arg) => arg != null).toList();
     var inputs = <HInstruction>[target]..addAll(arguments);
@@ skipping 2662 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }