Handle Native("...") annotations in KernelBehaviorBuilder.

pkg/compiler/lib/src/kernel/world_builder.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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/backend_api.dart';
 import '../common/names.dart';
 import '../compile_time_constants.dart';
@@ skipping 39 matching lines @@
       <ir.TypeParameter, KTypeVariable>{};
 
   Map<ir.Member, KConstructor> _constructorMap = <ir.Member, KConstructor>{};
   // TODO(johnniwinther): Change this to a list of 'KConstructorData' class
   // holding the [ConstantConstructor] if we need more data for constructors.
   List<ir.Member> _constructorList = <ir.Member>[];
   Map<KConstructor, ConstantConstructor> _constructorConstantMap =
       <KConstructor, ConstantConstructor>{};
 
   Map<ir.Procedure, KFunction> _methodMap = <ir.Procedure, KFunction>{};
+
   Map<ir.Field, KField> _fieldMap = <ir.Field, KField>{};
+  // TODO(johnniwinther): Change this to a list of 'KFieldData' class
+  // holding the [ConstantExpression] if we need more data for fields.
+  List<ir.Field> _fieldList = <ir.Field>[];
+  Map<KField, ConstantExpression> _fieldConstantMap =
+      <KField, ConstantExpression>{};
+
   Map<ir.TreeNode, KLocalFunction> _localFunctionMap =
       <ir.TreeNode, KLocalFunction>{};
 
   KernelWorldBuilder(this.reporter, ir.Program program)
       : _env = new KEnv(program) {
     _elementEnvironment = new KernelElementEnvironment(this);
     _commonElements = new KernelCommonElements(_elementEnvironment);
-    BackendHelpers helpers =
-        new BackendHelpers(_elementEnvironment, null, _commonElements);
     ConstantEnvironment constants = new KernelConstantEnvironment(this);
     _nativeBehaviorBuilder =
         new KernelBehaviorBuilder(_commonElements, helpers, constants);
     _typeConverter = new DartTypeConverter(this);
   }
 
+  @override
   CommonElements get commonElements => _commonElements;
 
+  @override
   ElementEnvironment get elementEnvironment => _elementEnvironment;
 
+  @override
   native.BehaviorBuilder get nativeBehaviorBuilder => _nativeBehaviorBuilder;
 
   LibraryEntity lookupLibrary(Uri uri) {
     KLibraryEnv libraryEnv = _env.lookupLibrary(uri);
     return _getLibrary(libraryEnv.library, libraryEnv);
   }
 
   KLibrary _getLibrary(ir.Library node, [KLibraryEnv libraryEnv]) {
     return _libraryMap.putIfAbsent(node, () {
       _libraryEnvs.add(libraryEnv ?? _env.lookupLibrary(node.importUri));
@@ skipping 108 matching lines @@
           return new KMethod(enclosingClass, name, isStatic: isStatic);
         case ir.ProcedureKind.Setter:
           return new KSetter(enclosingClass, getName(node.name).setter,
               isStatic: isStatic);
       }
     });
   }
 
   KField _getField(ir.Field node) {
     return _fieldMap.putIfAbsent(node, () {
+      int fieldIndex = _fieldList.length;
       KClass enclosingClass =
           node.enclosingClass != null ? _getClass(node.enclosingClass) : null;
       Name name = getName(node.name);
       bool isStatic = node.isStatic;
-      return new KField(enclosingClass, name,
+      _fieldList.add(node);
+      return new KField(fieldIndex, enclosingClass, name,
           isStatic: isStatic, isAssignable: node.isMutable);
     });
   }
 
   KLocalFunction _getLocal(ir.TreeNode node) {
     return _localFunctionMap.putIfAbsent(node, () {
       MemberEntity memberContext;
       Entity executableContext;
       ir.TreeNode parent = node.parent;
       while (parent != null) {
@@ skipping 126 matching lines @@
 
   @override
   FunctionEntity getConstructor(ir.Member node) => _getConstructor(node);
 
   ConstantConstructor _getConstructorConstant(KConstructor constructor) {
     return _constructorConstantMap.putIfAbsent(constructor, () {
       ir.Member node = _constructorList[constructor.constructorIndex];
       if (node is ir.Constructor && node.isConst) {
         return new Constantifier(this).computeConstantConstructor(node);
       }
-      throw new SpannableAssertionFailure(constructor,
-          "Unexpected constructor $constructor in KernelWorldBuilder._getConstructorConstant");
+      throw new SpannableAssertionFailure(
+          constructor,
+          "Unexpected constructor $constructor in "
+          "KernelWorldBuilder._getConstructorConstant");
+    });
+  }
+
+  ConstantExpression _getFieldConstant(KField field) {
+    return _fieldConstantMap.putIfAbsent(field, () {
+      ir.Field node = _fieldList[field.fieldIndex];
+      if (node.isConst) {
+        return node.initializer.accept(new Constantifier(this));
+      }
+      throw new SpannableAssertionFailure(
+          field,
+          "Unexpected field $field in "
+          "KernelWorldBuilder._getConstructorConstant");
     });
   }
 }
 
 /// Environment for fast lookup of program libraries.
 class KEnv {
   final ir.Program program;
 
   Map<Uri, KLibraryEnv> _libraryMap;
 
@@ skipping 356 matching lines @@
     return base;
   }
 
   @override
   ConstantConstructor getConstructorConstant(ConstructorEntity constructor) {
     return _worldBuilder._getConstructorConstant(constructor);
   }
 
   @override
   ConstantExpression getFieldConstant(FieldEntity field) {
-    throw new UnimplementedError("_EvaluationEnvironment.getFieldConstant");
+    return _worldBuilder._getFieldConstant(field);
   }
 
   @override
   ConstantExpression getLocalConstant(Local local) {
     throw new UnimplementedError("_EvaluationEnvironment.getLocalConstant");
   }
 
   @override
   String readFromEnvironment(String name) {
     throw new UnimplementedError("_EvaluationEnvironment.readFromEnvironment");
@@ skipping 27 matching lines @@
     }
     return builder._getLibrary(library);
   }
 
   KLibrary getLibraryForFunction(KFunction function) =>
       _getLibrary(function, builder._methodMap);
 
   KLibrary getLibraryForField(KField field) =>
       _getLibrary(field, builder._fieldMap);
 }