Add StaticUse for more precise registration of statically known element use.

pkg/compiler/lib/src/ssa/codegen.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;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
   final SourceInformationStrategy sourceInformationFactory;
@@ skipping 1561 matching lines @@
          .withSourceInformation(node.sourceInformation));
   }
 
   void visitInvokeConstructorBody(HInvokeConstructorBody node) {
     use(node.inputs[0]);
     js.Expression object = pop();
     js.Name methodName = backend.namer.instanceMethodName(node.element);
     List<js.Expression> arguments = visitArguments(node.inputs);
     push(js.propertyCall(object, methodName, arguments)
          .withSourceInformation(node.sourceInformation));
-    registry.registerStaticUse(node.element);
+    registry.registerStaticUse(
+        new StaticUse.constructorBodyInvoke(
+            node.element, new CallStructure.unnamed(arguments.length)));
   }
 
   void visitOneShotInterceptor(HOneShotInterceptor node) {
     List<js.Expression> arguments = visitArguments(node.inputs);
     var isolate = new js.VariableUse(
         backend.namer.globalObjectFor(helpers.interceptorsLibrary));
     Selector selector = node.selector;
     TypeMask mask = getOptimizedSelectorFor(node, selector, node.mask);
     js.Name methodName = backend.registerOneShotInterceptor(selector);
     push(js.propertyCall(isolate, methodName, arguments)
@@ skipping 41 matching lines @@
 
     // If we don't know what we're calling or if we are calling a getter,
     // we need to register that fact that we may be calling a closure
     // with the same arguments.
     Element target = node.element;
     if (target == null || target.isGetter) {
       // TODO(kasperl): If we have a typed selector for the call, we
       // may know something about the types of closures that need
       // the specific closure call method.
       Selector call = new Selector.callClosureFrom(selector);
-      registry.registerDynamicInvocation(
+      registry.registerDynamicUse(
           new UniverseSelector(call, null));
     }
-    registry.registerDynamicInvocation(
+    registry.registerDynamicUse(
         new UniverseSelector(selector, mask));
   }
 
   void registerSetter(HInvokeDynamic node) {
     Selector selector = node.selector;
     TypeMask mask = getOptimizedSelectorFor(node, selector, node.mask);
-    registry.registerDynamicSetter(
+    registry.registerDynamicUse(
         new UniverseSelector(selector, mask));
   }
 
   void registerGetter(HInvokeDynamic node) {
     Selector selector = node.selector;
     TypeMask mask = getOptimizedSelectorFor(node, selector, node.mask);
-    registry.registerDynamicGetter(
+    registry.registerDynamicUse(
         new UniverseSelector(selector, mask));
   }
 
   visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
     use(node.receiver);
     js.Name name = backend.namer.invocationName(node.selector);
     push(js.propertyCall(pop(), name, visitArguments(node.inputs))
          .withSourceInformation(node.sourceInformation));
     registerSetter(node);
   }
 
   visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
     use(node.receiver);
     js.Name name = backend.namer.invocationName(node.selector);
     push(js.propertyCall(pop(), name, visitArguments(node.inputs))
          .withSourceInformation(node.sourceInformation));
     registerGetter(node);
   }
 
   visitInvokeClosure(HInvokeClosure node) {
     Selector call = new Selector.callClosureFrom(node.selector);
     use(node.receiver);
     push(js.propertyCall(pop(),
                          backend.namer.invocationName(call),
                          visitArguments(node.inputs))
             .withSourceInformation(node.sourceInformation));
-    registry.registerDynamicInvocation(
+    registry.registerDynamicUse(
         new UniverseSelector(call, null));
   }
 
   visitInvokeStatic(HInvokeStatic node) {
     Element element = node.element;
     List<DartType> instantiatedTypes = node.instantiatedTypes;
 
     if (instantiatedTypes != null && !instantiatedTypes.isEmpty) {
       instantiatedTypes.forEach((type) {
-        registry.registerInstantiatedType(type);
+        registry.registerInstantiation(type);
       });
     }
 
     List<js.Expression> arguments = visitArguments(node.inputs, start: 0);
 
     if (element == backend.helpers.checkConcurrentModificationError) {
       // Manually inline the [checkConcurrentModificationError] function.  This
       // function is only called from a for-loop update.  Ideally we would just
       // generate the conditionalcontrol flow in the builder but it adds basic
       // blocks in the loop update that interfere with other optimizations and
       // confuses loop recognition.
 
       assert(arguments.length == 2);
       Element throwFunction = backend.helpers.throwConcurrentModificationError;
-      registry.registerStaticInvocation(throwFunction);
+      registry.registerStaticUse(
+          new StaticUse.staticInvoke(throwFunction, CallStructure.ONE_ARG));
 
       // Calling using `(0, #)(#)` instead of `#(#)` separates the property load
       // of the static function access from the call.  For some reason this
       // helps V8 see that the call never happens so V8 makes the call a
       // deoptimization. This removes the call from the optimized loop, making
       // more optimizations available to the loop.  This form is 50% faster on
       // some small loop, almost as fast as loops with no concurrent
       // modification check.
       push(js.js('# || (0, #)(#)',[
           arguments[0],
           backend.emitter.staticFunctionAccess(throwFunction),
           arguments[1]]));
     } else {
-      registry.registerStaticInvocation(element);
+      CallStructure callStructure = new CallStructure.unnamed(arguments.length);
+      registry.registerStaticUse(
+          element.isConstructor
+            ? new StaticUse.constructorInvoke(element, callStructure)
+            : new StaticUse.staticInvoke(element, callStructure));
       push(backend.emitter.staticFunctionAccess(element));
       push(new js.Call(pop(), arguments,
           sourceInformation: node.sourceInformation));
     }
 
   }
 
   visitInvokeSuper(HInvokeSuper node) {
-    Element superMethod = node.element;
-    registry.registerSuperInvocation(superMethod);
-    ClassElement superClass = superMethod.enclosingClass;
-    if (superMethod.kind == ElementKind.FIELD) {
+    Element superElement = node.element;
+    ClassElement superClass = superElement.enclosingClass;
+    if (superElement.isField) {
       js.Name fieldName =
-          backend.namer.instanceFieldPropertyName(superMethod);
+          backend.namer.instanceFieldPropertyName(superElement);
       use(node.inputs[0]);
       js.PropertyAccess access =
           new js.PropertyAccess(pop(), fieldName)
               .withSourceInformation(node.sourceInformation);
       if (node.isSetter) {
+        registry.registerStaticUse(
+            new StaticUse.superSet(superElement));
         use(node.value);
         push(new js.Assignment(access, pop())
             .withSourceInformation(node.sourceInformation));
       } else {
+        registry.registerStaticUse(new StaticUse.superGet(superElement));
         push(access);
       }
     } else {
       Selector selector = node.selector;
-
-      if (!backend.maybeRegisterAliasedSuperMember(superMethod, selector)) {
+      if (!backend.maybeRegisterAliasedSuperMember(superElement, selector)) {
         js.Name methodName;
         if (selector.isGetter) {
           // If the selector we need to register a typed getter to the
           // [world]. The emitter needs to know if it needs to emit a
           // bound closure for a method.
 
           // If [superMethod] is mixed in, [superClass] might not be live.
           // We use the superclass of the access instead.
           TypeMask receiverType =
               new TypeMask.nonNullExact(node.caller.superclass, compiler.world);
           // TODO(floitsch): we know the target. We shouldn't register a
           // dynamic getter.
-          registry.registerDynamicGetter(
+          registry.registerDynamicUse(
               new UniverseSelector(selector, receiverType));
-          registry.registerGetterForSuperMethod(node.element);
+          if (superElement.isFunction) {
+            registry.registerStaticUse(
+                new StaticUse.superTearOff(superElement));
+          }
           methodName = backend.namer.invocationName(selector);
         } else {
           assert(invariant(node, compiler.hasIncrementalSupport));
-          methodName = backend.namer.instanceMethodName(superMethod);
+          methodName = backend.namer.instanceMethodName(superElement);
         }
+        registry.registerStaticUse(
+            new StaticUse.superInvoke(
+                superElement,
+                new CallStructure.unnamed(node.inputs.length)));
         push(js.js('#.#.call(#)',
                    [backend.emitter.prototypeAccess(superClass,
                                                     hasBeenInstantiated: true),
                     methodName, visitArguments(node.inputs, start: 0)])
                 .withSourceInformation(node.sourceInformation));
       } else {
         use(node.receiver);
+        registry.registerStaticUse(
+            new StaticUse.superInvoke(
+                superElement,
+                new CallStructure.unnamed(node.inputs.length - 1)));
         push(
           js.js('#.#(#)', [
-            pop(), backend.namer.aliasedSuperMemberPropertyName(superMethod),
+            pop(), backend.namer.aliasedSuperMemberPropertyName(superElement),
             visitArguments(node.inputs, start: 1)]) // Skip receiver argument.
               .withSourceInformation(node.sourceInformation));
       }
     }
   }
 
   visitFieldGet(HFieldGet node) {
     use(node.receiver);
     Element element = node.element;
     if (node.isNullCheck) {
       // We access a JavaScript member we know all objects besides
       // null and undefined have: V8 does not like accessing a member
       // that does not exist.
       push(new js.PropertyAccess.field(pop(), 'toString')
           .withSourceInformation(node.sourceInformation));
     } else if (element == helpers.jsIndexableLength) {
       // We're accessing a native JavaScript property called 'length'
       // on a JS String or a JS array. Therefore, the name of that
       // property should not be mangled.
       push(new js.PropertyAccess.field(pop(), 'length')
           .withSourceInformation(node.sourceInformation));
     } else {
       js.Name name = backend.namer.instanceFieldPropertyName(element);
       push(new js.PropertyAccess(pop(), name)
           .withSourceInformation(node.sourceInformation));
-      registry.registerFieldGetter(element);
+      registry.registerStaticUse(new StaticUse.fieldGet(element));
     }
   }
 
   visitFieldSet(HFieldSet node) {
     Element element = node.element;
-    registry.registerFieldSetter(element);
+    registry.registerStaticUse(new StaticUse.fieldSet(element));
     js.Name name = backend.namer.instanceFieldPropertyName(element);
     use(node.receiver);
     js.Expression receiver = pop();
     use(node.value);
     push(new js.Assignment(new js.PropertyAccess(receiver, name), pop())
         .withSourceInformation(node.sourceInformation));
   }
 
   visitReadModifyWrite(HReadModifyWrite node) {
     Element element = node.element;
-    registry.registerFieldSetter(element);
+    registry.registerStaticUse(new StaticUse.fieldGet(element));
+    registry.registerStaticUse(new StaticUse.fieldSet(element));
     js.Name name = backend.namer.instanceFieldPropertyName(element);
     use(node.receiver);
     js.Expression fieldReference = new js.PropertyAccess(pop(), name);
     if (node.isPreOp) {
       push(new js.Prefix(node.jsOp, fieldReference)
           .withSourceInformation(node.sourceInformation));
     } else if (node.isPostOp) {
       push(new js.Postfix(node.jsOp, fieldReference)
           .withSourceInformation(node.sourceInformation));
     } else {
@@ skipping 54 matching lines @@
     // We also use ForeignNew to instantiate closure classes that belong to
     // function expressions. We have to register their use here, as otherwise
     // code for them might not be emitted.
     if (node.element.isClosure) {
       registry.registerInstantiatedClass(node.element);
     }
     if (node.instantiatedTypes == null) {
       return;
     }
     node.instantiatedTypes.forEach((type) {
-      registry.registerInstantiatedType(type);
+      registry.registerInstantiation(type);
     });
   }
 
   js.Expression newLiteralBool(bool value,
                                SourceInformation sourceInformation) {
     if (compiler.enableMinification) {
       // Use !0 for true, !1 for false.
       return new js.Prefix("!", new js.LiteralNumber(value ? "0" : "1"))
           .withSourceInformation(sourceInformation);
     } else {
       return new js.LiteralBool(value)
           .withSourceInformation(sourceInformation);
     }
   }
 
   void generateConstant(ConstantValue constant,
                         SourceInformation sourceInformation) {
     if (constant.isFunction) {
       FunctionConstantValue function = constant;
-      registry.registerStaticUse(function.element);
+      registry.registerStaticUse(
+          new StaticUse.staticTearOff(function.element));
     }
     if (constant.isType) {
       // If the type is a web component, we need to ensure the constructors are
       // available to 'upgrade' the native object.
       TypeConstantValue type = constant;
       Element element = type.representedType.element;
       if (element != null && element.isClass) {
         registry.registerTypeConstant(element);
       }
     }
@@ skipping 215 matching lines @@
       pushStatement(new js.If.noElse(underOver, thenBody)
           .withSourceInformation(node.sourceInformation));
     } else {
       generateThrowWithHelper(helpers.throwIndexOutOfRangeException,
           [node.array, node.index]);
     }
   }
 
   void generateThrowWithHelper(Element helper, argument,
                                {SourceInformation sourceInformation}) {
-    registry.registerStaticUse(helper);
     js.Expression jsHelper = backend.emitter.staticFunctionAccess(helper);
     List arguments = [];
     var location;
     if (argument is List) {
       location = argument[0];
       argument.forEach((instruction) {
         use(instruction);
         arguments.add(pop());
       });
     } else {
       location = argument;
       use(argument);
       arguments.add(pop());
     }
+    registry.registerStaticUse(
+        new StaticUse.staticInvoke(
+            helper, new CallStructure.unnamed(arguments.length)));
     js.Call value = new js.Call(jsHelper, arguments.toList(growable: false),
         sourceInformation: sourceInformation);
     // BUG(4906): Using throw/return here adds to the size of the generated code
     // but it has the advantage of explicitly telling the JS engine that
     // this code path will terminate abruptly. Needs more work.
     if (helper == helpers.wrapExceptionHelper) {
       pushStatement(new js.Throw(value)
           .withSourceInformation(sourceInformation));
     } else {
       Element element = work.element;
       if (element is FunctionElement && element.asyncMarker.isYielding) {
         // `return <expr>;` is illegal in a sync* or async* function.
         // To have the the async-translator working, we avoid introducing
         // `return` nodes.
         pushStatement(new js.ExpressionStatement(value)
             .withSourceInformation(sourceInformation));
       } else {
         pushStatement(new js.Return(value)
             .withSourceInformation(sourceInformation));
       }
     }
   }
 
   visitThrowExpression(HThrowExpression node) {
     HInstruction argument = node.inputs[0];
     use(argument);
 
     Element helper = helpers.throwExpressionHelper;
-    registry.registerStaticUse(helper);
+    registry.registerStaticUse(
+        new StaticUse.staticInvoke(helper, CallStructure.ONE_ARG));
 
     js.Expression jsHelper = backend.emitter.staticFunctionAccess(helper);
     js.Call value = new js.Call(jsHelper, [pop()])
         .withSourceInformation(node.sourceInformation);
     push(value);
   }
 
   void visitSwitch(HSwitch node) {
     // Switches are handled using [visitSwitchInfo].
   }
 
   void visitStatic(HStatic node) {
     Element element = node.element;
     assert(element.isFunction || element.isField);
     if (element.isFunction) {
       push(backend.emitter.isolateStaticClosureAccess(element)
            .withSourceInformation(node.sourceInformation));
-      registry.registerGetOfStaticFunction(element);
+      registry.registerStaticUse(
+          new StaticUse.staticTearOff(element));
     } else {
       push(backend.emitter.staticFieldAccess(element)
            .withSourceInformation(node.sourceInformation));
+      registry.registerStaticUse(
+          new StaticUse.staticGet(element));
     }
-    registry.registerStaticUse(element);
   }
 
   void visitLazyStatic(HLazyStatic node) {
     Element element = node.element;
-    registry.registerStaticUse(element);
+    registry.registerStaticUse(
+        new StaticUse.staticInit(element));
     js.Expression lazyGetter =
         backend.emitter.isolateLazyInitializerAccess(element);
     js.Call call = new js.Call(lazyGetter, <js.Expression>[],
         sourceInformation: node.sourceInformation);
     push(call);
   }
 
   void visitStaticStore(HStaticStore node) {
-    registry.registerStaticUse(node.element);
+    registry.registerStaticUse(
+        new StaticUse.staticSet(node.element));
     js.Node variable = backend.emitter.staticFieldAccess(node.element);
     use(node.inputs[0]);
     push(new js.Assignment(variable, pop())
         .withSourceInformation(node.sourceInformation));
   }
 
   void visitStringConcat(HStringConcat node) {
     use(node.left);
     js.Expression jsLeft = pop();
     use(node.right);
@@ skipping 13 matching lines @@
           && node.usedBy[0] is HStringConcat
           && node.usedBy[0].inputs[1] == node) {
         // The context is already <string> + value.
       } else {
         // Force an empty string for the first operand.
         push(new js.Binary('+', js.string(""), pop())
             .withSourceInformation(node.sourceInformation));
       }
     } else {
       Element convertToString = backend.helpers.stringInterpolationHelper;
-      registry.registerStaticUse(convertToString);
+      registry.registerStaticUse(
+          new StaticUse.staticInvoke(convertToString, CallStructure.ONE_ARG));
       js.Expression jsHelper =
           backend.emitter.staticFunctionAccess(convertToString);
       use(input);
       push(new js.Call(jsHelper, <js.Expression>[pop()],
                        sourceInformation: node.sourceInformation));
     }
   }
 
   void visitLiteralList(HLiteralList node) {
     registry.registerInstantiatedClass(coreClasses.listClass);
@@ skipping 214 matching lines @@
     use(input);
 
     js.Expression jsClassReference =
         backend.emitter.constructorAccess(type.element);
     push(js.js('# instanceof #', [pop(), jsClassReference])
             .withSourceInformation(sourceInformation));
     if (negative) {
       push(new js.Prefix('!', pop())
           .withSourceInformation(sourceInformation));
     }
-    registry.registerInstantiatedType(type);
+    registry.registerInstantiation(type);
   }
 
   void handleNumberOrStringSupertypeCheck(HInstruction input,
                                           HInstruction interceptor,
                                           DartType type,
                                           SourceInformation sourceInformation,
                                           {bool negative: false}) {
     assert(!identical(type.element, coreClasses.listClass) &&
            !Elements.isListSupertype(type.element, compiler) &&
            !Elements.isStringOnlySupertype(type.element, compiler));
@@ skipping 304 matching lines @@
           returnType,
           new js.ArrayInitializer(parameterTypes),
           new js.ObjectInitializer(namedParameters)];
       push(js.js('#(#)', [accessHelper('buildNamedFunctionType'), arguments]));
     }
   }
 
   void visitReadTypeVariable(HReadTypeVariable node) {
     TypeVariableElement element = node.dartType.element;
     Element helperElement = helpers.convertRtiToRuntimeType;
-    registry.registerStaticUse(helperElement);
+    registry.registerStaticUse(
+        new StaticUse.staticInvoke(helperElement, CallStructure.ONE_ARG));
 
     use(node.inputs[0]);
     if (node.hasReceiver) {
       if (backend.isInterceptorClass(element.enclosingClass)) {
         int index = element.index;
         js.Expression receiver = pop();
         js.Expression helper = backend.emitter
             .staticFunctionAccess(helperElement);
         push(js.js(r'#(#.$builtinTypeInfo && #.$builtinTypeInfo[#])',
                 [helper, receiver, receiver, js.js.number(index)]));
@@ skipping 14 matching lines @@
     for (HInstruction type in node.inputs) {
       use(type);
       typeArguments.add(pop());
     }
 
     ClassElement cls = node.dartType.element;
     var arguments = [backend.emitter.typeAccess(cls)];
     if (!typeArguments.isEmpty) {
       arguments.add(new js.ArrayInitializer(typeArguments));
     }
-    push(js.js('#(#)', [accessHelper('buildInterfaceType'), arguments]));
+    push(js.js('#(#)',
+        [accessHelper('buildInterfaceType', arguments.length), arguments]));
   }
 
   void visitVoidType(HVoidType node) {
     push(js.js('#()', accessHelper('getVoidRuntimeType')));
   }
 
   void visitDynamicType(HDynamicType node) {
     push(js.js('#()', accessHelper('getDynamicRuntimeType')));
   }
 
-  js.PropertyAccess accessHelper(String name) {
+  js.PropertyAccess accessHelper(String name, [int argumentCount = 0]) {
     Element helper = helpers.findHelper(name);
     if (helper == null) {
       // For mocked-up tests.
       return js.js('(void 0).$name');
     }
-    registry.registerStaticUse(helper);
+    registry.registerStaticUse(
+        new StaticUse.staticInvoke(helper,
+            new CallStructure.unnamed(argumentCount)));
     return backend.emitter.staticFunctionAccess(helper);
   }
 
   @override
   void visitRef(HRef node) {
     visit(node.value);
   }
 }