Enhance precision of recorded instantiation info in ResolutionWorldBuilder

pkg/compiler/lib/src/enqueue.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.
 
 library dart2js.enqueue;
 
 import 'dart:collection' show Queue;
 
 import 'cache_strategy.dart';
 import 'common/backend_api.dart' show Backend;
 import 'common/names.dart' show Identifiers;
 import 'common/resolution.dart' show Resolution, ResolutionWorkItem;
 import 'common/tasks.dart' show CompilerTask;
 import 'common/work.dart' show WorkItem;
 import 'common.dart';
 import 'compiler.dart' show Compiler, GlobalDependencyRegistry;
 import 'core_types.dart' show CommonElements;
 import 'options.dart';
 import 'dart_types.dart' show DartType, InterfaceType;
 import 'elements/elements.dart'
     show
         AnalyzableElement,
         AstElement,
         ClassElement,
+        ConstructorElement,
         Element,
         Entity,
         FunctionElement,
         LibraryElement,
         LocalFunctionElement,
         TypedElement;
 import 'native/native.dart' as native;
 import 'types/types.dart' show TypeMaskStrategy;
 import 'universe/selector.dart' show Selector;
 import 'universe/world_builder.dart';
@@ skipping 116 matching lines @@
 
   ResolutionEnqueuer(
       this.task,
       this.options,
       this.resolution,
       this.filter,
       this.strategy,
       this.globalDependencies,
       Backend backend,
       CommonElements commonElements,
-      CacheStrategy cacheStrategy)
-      : this.name = 'resolution enqueuer',
-        this.backend = backend,
+      CacheStrategy cacheStrategy,
+      [this.name = 'resolution enqueuer'])
+      : this.backend = backend,
         this.commonElements = commonElements,
         this.nativeEnqueuer = backend.nativeResolutionEnqueuer(),
         processedElements = new Set<AstElement>(),
         queue = new Queue<ResolutionWorkItem>(),
         deferredQueue = new Queue<_DeferredAction>(),
         _universe = new ResolutionWorldBuilderImpl(
             backend, commonElements, cacheStrategy, const TypeMaskStrategy()) {
     impactVisitor = new _EnqueuerImpactVisitor(this);
   }
 
@@ skipping 23 matching lines @@
       {Element impactSource}) {
     impactStrategy.visitImpact(
         impactSource, worldImpact, impactVisitor, impactUse);
   }
 
   void registerInstantiatedType(InterfaceType type) {
     _registerInstantiatedType(type, globalDependency: true);
   }
 
   void _registerInstantiatedType(InterfaceType type,
-      {bool mirrorUsage: false,
+      {ConstructorElement constructor,
+      bool mirrorUsage: false,
       bool nativeUsage: false,
-      bool globalDependency: false}) {
+      bool globalDependency: false,
+      bool isRedirection: false}) {
     task.measure(() {
       ClassElement cls = type.element;
       cls.ensureResolved(resolution);
       bool isNative = backend.isNative(cls);
       _universe.registerTypeInstantiation(type,
+          constructor: constructor,
           isNative: isNative,
-          byMirrors: mirrorUsage, onImplemented: (ClassElement cls) {
+          byMirrors: mirrorUsage,
+          isRedirection: isRedirection, onImplemented: (ClassElement cls) {
         backend.registerImplementedClass(cls, this);
       });
       if (globalDependency && !mirrorUsage) {
         globalDependencies.registerDependency(type.element);
       }
       if (nativeUsage) {
         nativeEnqueuer.onInstantiatedType(type);
       }
       backend.registerInstantiatedType(type);
       // TODO(johnniwinther): Share this reasoning with [Universe].
@@ skipping 219 matching lines @@
           universe.closuresWithFreeTypeVariables.add(closure);
         }
         addElement = false;
         break;
       case StaticUseKind.SUPER_FIELD_SET:
       case StaticUseKind.SUPER_TEAR_OFF:
       case StaticUseKind.GENERAL:
         break;
       case StaticUseKind.CONSTRUCTOR_INVOKE:
       case StaticUseKind.CONST_CONSTRUCTOR_INVOKE:
-        _registerTypeUse(new TypeUse.instantiation(staticUse.type));
+        _registerInstantiatedType(staticUse.type,
+            constructor: staticUse.element, globalDependency: false);
+        break;
+      case StaticUseKind.REDIRECTION:
+        _registerInstantiatedType(staticUse.type,
+            constructor: staticUse.element,
+            globalDependency: false,
+            isRedirection: true);
         break;
       case StaticUseKind.DIRECT_INVOKE:
         invariant(
             element, 'Direct static use is not supported for resolution.');
         break;
     }
     if (addElement) {
       addToWorkList(element);
     }
   }
@@ skipping 295 matching lines @@
 }
 
 typedef void _DeferredActionFunction();
 
 class _DeferredAction {
   final Element element;
   final _DeferredActionFunction action;
 
   _DeferredAction(this.element, this.action);
 }