Handle js interop members in impact computation.

pkg/compiler/lib/src/kernel/element_map_impl.dart

 // Copyright (c) 2017, 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.kernel.element_map;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart' show BoxLocal;
 import '../common.dart';
@@ skipping 971 matching lines @@
 
 /// Implementation of [KernelToElementMapForImpact] that only supports world
 /// impact computation.
 class KernelToElementMapForImpactImpl extends KernelToElementMapBase
     with
         KernelToElementMapForImpactMixin,
         ElementCreatorMixin,
         KElementCreatorMixin {
   native.BehaviorBuilder _nativeBehaviorBuilder;
   FrontendStrategy _frontendStrategy;
+  CompilerOptions _options;
 
   KernelToElementMapForImpactImpl(DiagnosticReporter reporter,
-      Environment environment, this._frontendStrategy)
+      Environment environment, this._frontendStrategy, this._options)
       : super(reporter, environment);
 
   @override
   bool checkFamily(Entity entity) {
     assert(
         '$entity'.startsWith(kElementPrefix),
         failedAt(entity,
             "Unexpected entity $entity, expected family $kElementPrefix."));
     return true;
   }
 
   @override
   NativeBasicData get nativeBasicData => _frontendStrategy.nativeBasicData;
 
   /// Adds libraries in [program] to the set of libraries.
   ///
   /// The main method of the first program is used as the main method for the
   /// compilation.
   void addProgram(ir.Program program) {
     _env.addProgram(program);
   }
 
   @override
   native.BehaviorBuilder get nativeBehaviorBuilder =>
-      _nativeBehaviorBuilder ??= new KernelBehaviorBuilder(commonElements);
+      _nativeBehaviorBuilder ??= new KernelBehaviorBuilder(elementEnvironment,
+          commonElements, nativeBasicData, reporter, _options);
 
   ResolutionImpact computeWorldImpact(KMember member) {
     return buildKernelImpact(
         _memberData[member.memberIndex].definition.node, this);
   }
 
   ClosureModel computeClosureModel(KMember member) {
     ir.Member node = _memberData[member.memberIndex].definition.node;
     return KernelClosureAnalysis.computeClosureModel(member, node);
   }
 
   /// Returns the kernel [ir.Procedure] node for the [method].
   ir.Procedure _lookupProcedure(KFunction method) {
     return _memberData[method.memberIndex].definition.node;
   }
 
-  Iterable<ConstantValue> _getClassMetadata(KClass cls) {
-    return _classData[cls.classIndex].getMetadata(this);
-  }
-
   @override
   Local getLocalFunction(ir.TreeNode node) {
     assert(
         node is ir.FunctionDeclaration || node is ir.FunctionExpression,
         failedAt(
             CURRENT_ELEMENT_SPANNABLE, 'Invalid local function node: $node'));
     return _localFunctionMap.putIfAbsent(node, () {
       MemberEntity memberContext;
       Entity executableContext;
       ir.TreeNode parent = node.parent;
@@ skipping 321 matching lines @@
   @override
   DartType visitInvalidType(ir.InvalidType node) {
     // Root uses such a `o is Unresolved` and `o as Unresolved` must be special
     // cased in the builder, nested invalid types are treated as `dynamic`.
     return const DynamicType();
   }
 }
 
 /// [native.BehaviorBuilder] for kernel based elements.
 class KernelBehaviorBuilder extends native.BehaviorBuilder {
+  final ElementEnvironment elementEnvironment;
   final CommonElements commonElements;
+  final DiagnosticReporter reporter;
+  final NativeBasicData nativeBasicData;
+  final CompilerOptions _options;
 
-  KernelBehaviorBuilder(this.commonElements);
+  KernelBehaviorBuilder(this.elementEnvironment, this.commonElements,
+      this.nativeBasicData, this.reporter, this._options);
 
   @override
-  bool get trustJSInteropTypeAnnotations {
-    throw new UnimplementedError(
-        "KernelNativeBehaviorComputer.trustJSInteropTypeAnnotations");
-  }
-
-  @override
-  DiagnosticReporter get reporter {
-    throw new UnimplementedError("KernelNativeBehaviorComputer.reporter");
-  }
-
-  NativeBasicData get nativeBasicData {
-    throw new UnimplementedError(
-        "KernelNativeBehaviorComputer.nativeBasicData");
-  }
+  bool get trustJSInteropTypeAnnotations =>
+      _options.trustJSInteropTypeAnnotations;
 }
 
 /// Constant environment mapping [ConstantExpression]s to [ConstantValue]s using
 /// [_EvaluationEnvironment] for the evaluation.
 class KernelConstantEnvironment implements ConstantEnvironment {
   final KernelToElementMapBase _elementMap;
   final Environment _environment;
 
   Map<ConstantExpression, ConstantValue> _valueMap =
       <ConstantExpression, ConstantValue>{};
@@ skipping 318 matching lines @@
   bool isNativeMethod(covariant KFunction function) {
     if (!native.maybeEnableNative(function.library.canonicalUri)) return false;
     ir.Member node =
         elementMap._memberData[function.memberIndex].definition.node;
     return node.isExternal &&
         !elementMap.isForeignLibrary(node.enclosingLibrary);
   }
 
   @override
   bool isJsInteropMember(MemberEntity element) {
-    // TODO(redemption): Compute this.
-    return false;
+    return nativeBasicData.isJsInteropMember(element);
   }
 }
 
 class JsToFrontendMapImpl extends JsToFrontendMapBase
     implements JsToFrontendMap {
   final KernelToElementMapBase _backend;
 
   JsToFrontendMapImpl(this._backend);
 
   LibraryEntity toBackendLibrary(covariant IndexedLibrary library) {
@@ skipping 377 matching lines @@
   ///
   /// These names are not used in generated code, just as element name.
   String _getClosureVariableName(String name, int id) {
     return "_captured_${name}_$id";
   }
 
   String getDeferredUri(ir.LibraryDependency node) {
     throw new UnimplementedError('JsKernelToElementMap.getDeferredUri');
   }
 }