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

pkg/compiler/lib/src/resolution/constructors.dart

 // Copyright (c) 2015, 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.
 
 library dart2js.resolution.constructors;
 
 import '../common.dart';
 import '../compiler.dart' show
     Compiler;
 import '../constants/constructors.dart' show
@@ skipping 10 matching lines @@
     FieldElementX,
     InitializingFormalElementX,
     ParameterElementX;
 import '../tree/tree.dart';
 import '../util/util.dart' show
     Link;
 import '../universe/call_structure.dart' show
     CallStructure;
 import '../universe/selector.dart' show
     Selector;
+import '../universe/use.dart' show
+    StaticUse;
 
 import 'members.dart' show
     lookupInScope,
     ResolverVisitor;
 import 'registry.dart' show
     ResolutionRegistry;
 import 'resolution_common.dart' show
     CommonResolverVisitor;
 import 'resolution_result.dart';
 
@@ skipping 77 matching lines @@
             selector, MessageKind.INIT_STATIC_FIELD, {'fieldName': name});
       } else {
         field = target;
       }
     } else {
       reporter.reportErrorMessage(
           init, MessageKind.INVALID_RECEIVER_IN_INITIALIZER);
     }
     if (target != null) {
       registry.useElement(init, target);
-      registry.registerStaticUse(target);
+      if (!target.isMalformed) {
+        registry.registerStaticUse(new StaticUse.fieldInit(target));
+      }
       checkForDuplicateInitializers(target, init);
     }
     // Resolve initializing value.
     ResolutionResult result = visitor.visitInStaticContext(
         init.arguments.head,
         inConstantInitializer: isConst);
     if (isConst) {
       if (result.isConstant && field != null) {
         // TODO(johnniwinther): Report error if `result.constant` is `null`.
         fieldInitializers[field] = result.constant;
@@ skipping 37 matching lines @@
     final bool isImplicitSuperCall = false;
     final String className = lookupTarget.name;
     verifyThatConstructorMatchesCall(calledConstructor,
                                      argumentsResult.callStructure,
                                      isImplicitSuperCall,
                                      call,
                                      className,
                                      constructorSelector);
     if (calledConstructor != null) {
       registry.useElement(call, calledConstructor);
-      registry.registerStaticUse(calledConstructor);
+      registry.registerStaticUse(
+          new StaticUse.superConstructorInvoke(
+              calledConstructor, argumentsResult.callStructure));
     }
     if (isConst) {
       if (isValidAsConstant &&
           calledConstructor.isConst &&
           argumentsResult.isValidAsConstant) {
         CallStructure callStructure = argumentsResult.callStructure;
         List<ConstantExpression> arguments = argumentsResult.constantArguments;
         return new ConstantResult(
             call,
             new ConstructedConstantExpression(
@@ skipping 28 matching lines @@
 
       final String className = lookupTarget.name;
       final bool isImplicitSuperCall = true;
       verifyThatConstructorMatchesCall(calledConstructor,
                                        CallStructure.NO_ARGS,
                                        isImplicitSuperCall,
                                        functionNode,
                                        className,
                                        constructorSelector);
       if (calledConstructor != null) {
-        registry.registerImplicitSuperCall(calledConstructor);
+        registry.registerStaticUse(
+            new StaticUse.constructorInvoke(
+                calledConstructor, constructorSelector.callStructure));
       }
 
       if (isConst && isValidAsConstant) {
         return new ConstructedConstantExpression(
             targetType,
             calledConstructor,
             CallStructure.NO_ARGS,
             const <ConstantExpression>[]);
       }
     }
@@ skipping 507 matching lines @@
     // constructors.
     return null;
   }
   // TODO(johnniwinther): Use [Name] for lookup.
   ConstructorElement constructor = cls.lookupConstructor(constructorName);
   if (constructor != null) {
     constructor = constructor.declaration;
   }
   return constructor;
 }