Add KernelNativeBehaviorComputer

pkg/compiler/lib/src/ssa/kernel_ast_adapter.dart

 // Copyright (c) 2016, 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 'package:js_runtime/shared/embedded_names.dart';
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../core_types.dart';
 import '../elements/resolution_types.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/modelx.dart';
 import '../elements/types.dart';
 import '../js/js.dart' as js;
 import '../js_backend/js_backend.dart';
 import '../kernel/element_adapter.dart';
 import '../kernel/kernel.dart';
 import '../kernel/kernel_debug.dart';
 import '../native/native.dart' as native;
 import '../resolution/tree_elements.dart';
 import '../tree/tree.dart' as ast;
 import '../types/masks.dart';
 import '../types/types.dart';
-import '../universe/call_structure.dart';
 import '../universe/selector.dart';
 import '../universe/side_effects.dart';
 import '../world.dart';
 import 'graph_builder.dart';
 import 'jump_handler.dart' show SwitchCaseJumpHandler;
 import 'locals_handler.dart';
 import 'types.dart';
 
 /// A helper class that abstracts all accesses of the AST from Kernel nodes.
 ///
@@ skipping 12 matching lines @@
   final Map<ir.TreeNode, KernelJumpTarget> _jumpTargets =
       <ir.TreeNode, KernelJumpTarget>{};
   DartTypeConverter _typeConverter;
   ResolvedAst _resolvedAst;
 
   /// Sometimes for resolution the resolved AST element needs to change (for
   /// example, if we're inlining, or if we're in a constructor, but then also
   /// constructing the field values). We keep track of this with a stack.
   final List<ResolvedAst> _resolvedAstStack = <ResolvedAst>[];
 
+  final native.BehaviorBuilder nativeBehaviorBuilder;
+
   KernelAstAdapter(this.kernel, this._backend, this._resolvedAst,
-      this._nodeToAst, this._nodeToElement) {
+      this._nodeToAst, this._nodeToElement)
+      : nativeBehaviorBuilder =
+            new native.ResolverBehaviorBuilder(_backend.compiler) {
     KernelJumpTarget.index = 0;
     // TODO(het): Maybe just use all of the kernel maps directly?
     for (FieldElement fieldElement in kernel.fields.keys) {
       _nodeToElement[kernel.fields[fieldElement]] = fieldElement;
     }
     for (FunctionElement functionElement in kernel.functions.keys) {
       _nodeToElement[kernel.functions[functionElement]] = functionElement;
     }
     for (ClassElement classElement in kernel.classes.keys) {
       _nodeToElement[kernel.classes[classElement]] = classElement;
     }
     for (LibraryElement libraryElement in kernel.libraries.keys) {
       _nodeToElement[kernel.libraries[libraryElement]] = libraryElement;
     }
     for (LocalFunctionElement localFunction in kernel.localFunctions.keys) {
       _nodeToElement[kernel.localFunctions[localFunction]] = localFunction;
     }
     for (TypeVariableElement typeVariable in kernel.typeParameters.keys) {
       _nodeToElement[kernel.typeParameters[typeVariable]] = typeVariable;
     }
     _typeConverter = new DartTypeConverter(this);
   }
 
+  @override
   CommonElements get commonElements => _compiler.commonElements;
 
+  @override
+  ElementEnvironment get elementEnvironment => _compiler.elementEnvironment;
+
   /// Push the existing resolved AST on the stack and shift the current resolved
   /// AST to the AST that this kernel node points to.
   void pushResolvedAst(ir.Node node) {
     _resolvedAstStack.add(_resolvedAst);
     _resolvedAst = (getElement(node) as AstElement).resolvedAst;
   }
 
   /// Pop the resolved AST stack to reset it to the previous resolved AST node.
   void popResolvedAstStack() {
     assert(_resolvedAstStack.isNotEmpty);
@@ skipping 462 matching lines @@
   ResolutionInterfaceType getInterfaceType(ir.InterfaceType type) =>
       getDartType(type);
 
   ResolutionInterfaceType createInterfaceType(
       ir.Class cls, List<ir.DartType> typeArguments) {
     return new ResolutionInterfaceType(
         getClass(cls), getDartTypes(typeArguments));
   }
 
   @override
-  LibraryEntity lookupLibrary(Uri uri) {
-    return _compiler.libraryLoader.lookupLibrary(uri);
-  }
-
-  @override
-  ClassElement lookupClass(LibraryElement library, String name) {
-    Element element = library.find(name);
-    if (element != null && element.isClass) {
-      return element;
-    }
-    return null;
-  }
-
-  @override
-  InterfaceType getRawType(ClassElement cls) {
-    return cls.rawType;
-  }
-
-  @override
-  InterfaceType getThisType(ClassElement cls) {
-    return cls.thisType;
-  }
-
-  native.BehaviorBuilder get nativeBehaviorBuilder =>
-      new native.ResolverBehaviorBuilder(_compiler);
-
-  /// Computes the native behavior for reading the native [field].
-  // TODO(johnniwinther): Cache this for later use.
-  native.NativeBehavior getNativeBehaviorForFieldLoad(ir.Field field) {
-    ResolutionDartType type = getDartType(field.type);
-    List<ConstantExpression> metadata = getMetadata(field.annotations);
-    // TODO(johnniwinther): Provide the correct value for [isJsInterop].
-    return nativeBehaviorBuilder.buildFieldLoadBehavior(
-        type, metadata, typeLookup(resolveAsRaw: false),
-        isJsInterop: false);
-  }
-
-  /// Computes the native behavior for writing to the native [field].
-  // TODO(johnniwinther): Cache this for later use.
-  native.NativeBehavior getNativeBehaviorForFieldStore(ir.Field field) {
-    DartType type = getDartType(field.type);
-    return nativeBehaviorBuilder.buildFieldStoreBehavior(type);
-  }
-
-  /// Computes the native behavior for calling [procedure].
-  // TODO(johnniwinther): Cache this for later use.
-  native.NativeBehavior getNativeBehaviorForMethod(ir.Procedure procedure) {
-    DartType type = getFunctionType(procedure.function);
-    List<ConstantExpression> metadata = getMetadata(procedure.annotations);
-    // TODO(johnniwinther): Provide the correct value for [isJsInterop].
-    return nativeBehaviorBuilder.buildMethodBehavior(
-        type, metadata, typeLookup(resolveAsRaw: false),
-        isJsInterop: false);
+  InterfaceType getThisType(ir.Class cls) {
+    return getClass(cls).thisType;
   }
 
   MemberEntity getConstructorBodyEntity(ir.Constructor constructor) {
     AstElement element = getElement(constructor);
     MemberEntity constructorBody =
         ConstructorBodyElementX.createFromResolvedAst(element.resolvedAst);
     assert(constructorBody != null);
     return constructorBody;
   }
 }
@@ skipping 195 matching lines @@
       JumpTarget continueTarget =
           astAdapter.getJumpTarget(switchCase, isContinueTarget: true);
       assert(continueTarget is KernelJumpTarget);
       targetIndexMap[continueTarget] = switchIndex;
       assert(builder.jumpTargets[continueTarget] == null);
       builder.jumpTargets[continueTarget] = this;
       switchIndex++;
     }
   }
 }