Handle js interop members in impact computation.

pkg/compiler/lib/src/native/behavior.dart

 // Copyright (c) 2014, 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 '../common.dart';
 import '../common/backend_api.dart' show ForeignResolver;
 import '../common/resolution.dart' show ParsingContext, Resolution;
 import '../compiler.dart' show Compiler;
 import '../constants/values.dart';
-import '../common_elements.dart' show CommonElements;
+import '../common_elements.dart' show CommonElements, ElementEnvironment;
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/resolution_types.dart';
 import '../elements/types.dart';
 import '../js/js.dart' as js;
 import '../js_backend/native_data.dart' show NativeBasicData;
+import '../resolution/resolution_strategy.dart';
 import '../tree/tree.dart';
 import '../universe/side_effects.dart' show SideEffects;
 import '../util/util.dart';
 import 'js.dart';
 
 typedef dynamic /*DartType|SpecialType*/ TypeLookup(String typeString,
     {bool required});
 
 /// This class is a temporary work-around until we get a more powerful DartType.
 class SpecialType {
@@ skipping 817 matching lines @@
     }
     return const ResolutionDynamicType();
   }
 }
 
 abstract class BehaviorBuilder {
   CommonElements get commonElements;
   DiagnosticReporter get reporter;
   NativeBasicData get nativeBasicData;
   bool get trustJSInteropTypeAnnotations;
-
-  Resolution get resolution => null;
+  ElementEnvironment get elementEnvironment;
 
   NativeBehavior _behavior;
 
   void _overrideWithAnnotations(
       Iterable<ConstantValue> metadata, TypeLookup lookupType) {
     if (metadata.isEmpty) return;
 
     List creates =
         _collect(metadata, commonElements.annotationCreatesClass, lookupType);
     List returns =
@@ skipping 37 matching lines @@
         if (types == null) types = [];
         types.add(type);
       }
     }
     return types;
   }
 
   /// Models the behavior of having instances of [type] escape from Dart code
   /// into native code.
   void _escape(DartType type) {
-    if (type is ResolutionDartType) {
-      type.computeUnaliased(resolution);
-    }
-    type = type.unaliased;
+    type = elementEnvironment.getUnaliasedType(type);
     if (type is FunctionType) {
       FunctionType functionType = type;
       // A function might be called from native code, passing us novel
       // parameters.
       _escape(functionType.returnType);
       for (DartType parameter in functionType.parameterTypes) {
         _capture(parameter);
       }
     }
   }
 
   /// Models the behavior of Dart code receiving instances and methods of [type]
   /// from native code.  We usually start the analysis by capturing a native
   /// method that has been used.
   ///
   /// We assume that JS-interop APIs cannot instantiate Dart types or
   /// non-JSInterop native types.
   void _capture(DartType type, {bool isInterop: false}) {
-    if (type is ResolutionDartType) {
-      type.computeUnaliased(resolution);
-    }
-    type = type.unaliased;
+    type = elementEnvironment.getUnaliasedType(type);
     if (type is FunctionType) {
       FunctionType functionType = type;
       _capture(functionType.returnType, isInterop: isInterop);
       for (DartType parameter in functionType.parameterTypes) {
         _escape(parameter);
       }
     } else {
       if (!isInterop) {
         _behavior.typesInstantiated.add(type);
       } else {
         if (type is InterfaceType &&
             nativeBasicData.isNativeClass(type.element)) {
           // Any declared native or interop type (isNative implies isJsInterop)
           // is assumed to be allocated.
           _behavior.typesInstantiated.add(type);
         }
 
         if (!trustJSInteropTypeAnnotations ||
             type.isDynamic ||
             type == commonElements.objectType) {
           // By saying that only JS-interop types can be created, we prevent
           // pulling in every other native type (e.g. all of dart:html) when a
           // JS interop API returns dynamic or when we don't trust the type
           // annotations. This means that to some degree we still use the return
           // type to decide whether to include native types, even if we don't
           // trust the type annotation.
-          ClassElement cls = commonElements.jsJavaScriptObjectClass;
-          cls.ensureResolved(resolution);
-          _behavior.typesInstantiated.add(cls.thisType);
+          ClassEntity cls = commonElements.jsJavaScriptObjectClass;
+          _behavior.typesInstantiated.add(elementEnvironment.getThisType(cls));
         } else {
           // Otherwise, when the declared type is a Dart type, we do not
           // register an allocation because we assume it cannot be instantiated
           // from within the JS-interop code. It must have escaped from another
           // API.
         }
       }
     }
   }
 
@@ skipping 55 matching lines @@
   }
 }
 
 class ResolverBehaviorBuilder extends BehaviorBuilder {
   final Compiler compiler;
   final NativeBasicData nativeBasicData;
 
   ResolverBehaviorBuilder(this.compiler, this.nativeBasicData);
 
   @override
-  CommonElements get commonElements => resolution.commonElements;
+  CommonElements get commonElements => compiler.resolution.commonElements;
 
   @override
   bool get trustJSInteropTypeAnnotations =>
       compiler.options.trustJSInteropTypeAnnotations;
 
   @override
   DiagnosticReporter get reporter => compiler.reporter;
 
   @override
-  Resolution get resolution => compiler.resolution;
+  ElementEnvironment get elementEnvironment {
+    ResolutionFrontEndStrategy frontendStrategy = compiler.frontendStrategy;
+    return frontendStrategy.elementEnvironment;
+  }
 }