Compute NativeBasicData for KernelWorldBuilder

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.
 
 library dart2js.kernel.world_builder;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/resolution.dart';
 import '../compile_time_constants.dart';
 import '../constants/constant_system.dart';
 import '../constants/constructors.dart';
 import '../constants/evaluation.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../common_elements.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/types.dart';
 import '../js_backend/constant_system_javascript.dart';
-import '../js_backend/native_data.dart' show NativeData;
+import '../js_backend/native_data.dart';
 import '../js_backend/no_such_method_registry.dart';
 import '../native/native.dart' as native;
 import '../native/resolver.dart';
 import '../ssa/kernel_impact.dart';
 import '../universe/call_structure.dart';
 import 'element_adapter.dart';
 import 'elements.dart';
 
+part 'native_basic_data.dart';
 part 'native_class_resolver.dart';
 part 'no_such_method_resolver.dart';
 
 /// World builder used for creating elements and types corresponding to Kernel
 /// IR nodes.
 // TODO(johnniwinther): Implement [ResolutionWorldBuilder].
 class KernelWorldBuilder extends KernelElementAdapterMixin {
   CommonElements _commonElements;
   native.BehaviorBuilder _nativeBehaviorBuilder;
   final DiagnosticReporter reporter;
   ElementEnvironment _elementEnvironment;
   DartTypeConverter _typeConverter;
+  KernelConstantEnvironment _constantEnvironment;
 
   /// Library environment. Used for fast lookup.
   KEnv _env;
 
   /// List of library environments by `KLibrary.libraryIndex`. This is used for
   /// fast lookup into library classes and members.
   List<KLibraryEnv> _libraryEnvs = <KLibraryEnv>[];
 
   /// List of class environments by `KClass.classIndex`. This is used for
   /// fast lookup into class members.
@@ skipping 18 matching lines @@
   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 CommonElements(_elementEnvironment);
-    ConstantEnvironment constants = new KernelConstantEnvironment(this);
+    _constantEnvironment = new KernelConstantEnvironment(this);
     _nativeBehaviorBuilder =
-        new KernelBehaviorBuilder(_commonElements, constants);
+        new KernelBehaviorBuilder(_commonElements, _constantEnvironment);
     _typeConverter = new DartTypeConverter(this);
   }
 
   KMethod get _mainFunction {
     return _env.program.mainMethod != null
         ? _getMethod(_env.program.mainMethod)
         : null;
   }
 
   KLibrary get _mainLibrary {
     return _env.program.mainMethod != null
         ? _getLibrary(_env.program.mainMethod.enclosingLibrary)
         : null;
   }
 
+  Iterable<LibraryEntity> get _libraries {
+    if (_env.length != _libraryMap.length) {
+      // Create a [KLibrary] for each library.
+      _env.forEachLibrary((KLibraryEnv env) {
+        _getLibrary(env.library, env);
+      });
+    }
+    return _libraryMap.values;
+  }
+
   @override
   CommonElements get commonElements => _commonElements;
 
   @override
   ElementEnvironment get elementEnvironment => _elementEnvironment;
 
+  ConstantEnvironment get constantEnvironment => _constantEnvironment;
+
   @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, () {
@@ skipping 18 matching lines @@
 
   ClassEntity lookupClass(KLibrary library, String name) {
     KLibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
     KClassEnv classEnv = libraryEnv.lookupClass(name);
     if (classEnv != null) {
       return _getClass(classEnv.cls, classEnv);
     }
     return null;
   }
 
+  void _forEachClass(KLibrary library, void f(ClassEntity cls)) {
+    KLibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
+    libraryEnv.forEachClass((KClassEnv classEnv) {
+      f(_getClass(classEnv.cls, classEnv));
+    });
+  }
+
   MemberEntity lookupClassMember(KClass cls, String name,
       {bool setter: false}) {
     KClassEnv classEnv = _classEnvs[cls.classIndex];
     ir.Member member = classEnv.lookupMember(name, setter: setter);
     return member != null ? getMember(member) : null;
   }
 
   ConstructorEntity lookupConstructor(KClass cls, String name) {
     KClassEnv classEnv = _classEnvs[cls.classIndex];
     ir.Member member = classEnv.lookupConstructor(name);
     return member != null ? getConstructor(member) : null;
   }
 
   KClass _getClass(ir.Class node, [KClassEnv classEnv]) {
     return _classMap.putIfAbsent(node, () {
       KLibrary library = _getLibrary(node.enclosingLibrary);
       if (classEnv == null) {
         classEnv = _libraryEnvs[library.libraryIndex].lookupClass(node.name);
       }
       _classEnvs.add(classEnv);
       return new KClass(library, _classMap.length, node.name,
           isAbstract: node.isAbstract);
     });
   }
 
+  Iterable<ConstantExpression> _getClassMetadata(KClass cls) {
+    return _classEnvs[cls.classIndex].getMetadata(this);
+  }
+
   KTypeVariable _getTypeVariable(ir.TypeParameter node) {
     return _typeVariableMap.putIfAbsent(node, () {
       if (node.parent is ir.Class) {
         ir.Class cls = node.parent;
         int index = cls.typeParameters.indexOf(node);
         return new KTypeVariable(_getClass(cls), node.name, index);
       }
       if (node.parent is ir.FunctionNode) {
         ir.FunctionNode func = node.parent;
         int index = func.typeParameters.indexOf(node);
@@ skipping 350 matching lines @@
 }
 
 /// Environment for fast lookup of program libraries.
 class KEnv {
   final ir.Program program;
 
   Map<Uri, KLibraryEnv> _libraryMap;
 
   KEnv(this.program);
 
-  /// Return the [KLibraryEnv] for the library with the canonical [uri].
-  KLibraryEnv lookupLibrary(Uri uri) {
+  void _ensureLibraryMap() {
     if (_libraryMap == null) {
       _libraryMap = <Uri, KLibraryEnv>{};
       for (ir.Library library in program.libraries) {
         _libraryMap[library.importUri] = new KLibraryEnv(library);
       }
     }
+  }
+
+  /// Return the [KLibraryEnv] for the library with the canonical [uri].
+  KLibraryEnv lookupLibrary(Uri uri) {
+    _ensureLibraryMap();
     return _libraryMap[uri];
   }
+
+  /// Calls [f] for each library in this environment.
+  void forEachLibrary(void f(KLibraryEnv library)) {
+    _ensureLibraryMap();
+    _libraryMap.values.forEach(f);
+  }
+
+  /// Returns the number of libraries in this environment.
+  int get length {
+    _ensureLibraryMap();
+    return _libraryMap.length;
+  }
 }
 
 /// Environment for fast lookup of library classes and members.
 // TODO(johnniwinther): Add member lookup.
 class KLibraryEnv {
   final ir.Library library;
 
   Map<String, KClassEnv> _classMap;
   Map<String, ir.Member> _memberMap;
 
   KLibraryEnv(this.library);
 
-  /// Return the [KClassEnv] for the class [name] in [library].
-  KClassEnv lookupClass(String name) {
+  void _ensureClassMap() {
     if (_classMap == null) {
       _classMap = <String, KClassEnv>{};
       for (ir.Class cls in library.classes) {
         _classMap[cls.name] = new KClassEnv(cls);
       }
     }
+  }
+
+  /// Return the [KClassEnv] for the class [name] in [library].
+  KClassEnv lookupClass(String name) {
+    _ensureClassMap();
     return _classMap[name];
   }
 
+  /// Calls [f] for each class in this library.
+  void forEachClass(void f(KClassEnv cls)) {
+    _ensureClassMap();
+    _classMap.values.forEach(f);
+  }
+
   /// Return the [ir.Member] for the member [name] in [library].
   ir.Member lookupMember(String name, {bool setter: false}) {
     if (_memberMap == null) {
       _memberMap = <String, ir.Member>{};
       for (ir.Member member in library.members) {
         // TODO(johnniwinther): Support setter vs. getter.
         _memberMap[member.name.name] = member;
       }
     }
     return _memberMap[name];
   }
 }
 
 /// Environment for fast lookup of class members.
 // TODO(johnniwinther): Add member lookup.
 class KClassEnv {
   final ir.Class cls;
 
   InterfaceType thisType;
   InterfaceType rawType;
   InterfaceType supertype;
   List<InterfaceType> supertypes;
 
   Map<String, ir.Member> _constructorMap;
   Map<String, ir.Member> _memberMap;
 
+  Iterable<ConstantExpression> _metadata;
+
   KClassEnv(this.cls);
 
   void _ensureMaps() {
     if (_memberMap == null) {
       _memberMap = <String, ir.Member>{};
       _constructorMap = <String, ir.Member>{};
       for (ir.Member member in cls.members) {
         if (member is ir.Procedure && member.kind == ir.ProcedureKind.Factory) {
           _constructorMap[member.name.name] = member;
         } else {
@@ skipping 11 matching lines @@
   ir.Member lookupMember(String name, {bool setter: false}) {
     _ensureMaps();
     return _memberMap[name];
   }
 
   /// Return the [ir.Member] for the member [name] in [library].
   ir.Member lookupConstructor(String name, {bool setter: false}) {
     _ensureMaps();
     return _constructorMap[name];
   }
+
+  Iterable<ConstantExpression> getMetadata(KernelWorldBuilder worldBuilder) {
+    if (_metadata == null) {
+      _metadata = worldBuilder.getMetadata(cls.annotations);
+    }
+    return _metadata;
+  }
 }
 
 class KernelElementEnvironment implements ElementEnvironment {
   final KernelWorldBuilder worldBuilder;
 
   KernelElementEnvironment(this.worldBuilder);
 
   @override
   DartType get dynamicType => const DynamicType();
 
   @override
   LibraryEntity get mainLibrary => worldBuilder._mainLibrary;
 
   @override
   FunctionEntity get mainFunction => worldBuilder._mainFunction;
 
   @override
-  Iterable<LibraryEntity> get libraries => worldBuilder._libraryMap.values;
+  Iterable<LibraryEntity> get libraries => worldBuilder._libraries;
 
   @override
   InterfaceType getThisType(ClassEntity cls) {
     return worldBuilder._getThisType(cls);
   }
 
   @override
   InterfaceType getRawType(ClassEntity cls) {
     return worldBuilder._getRawType(cls);
   }
@@ skipping 92 matching lines @@
       {bool required: false}) {
     ClassEntity cls = worldBuilder.lookupClass(library, name);
     if (cls == null && required) {
       throw new SpannableAssertionFailure(CURRENT_ELEMENT_SPANNABLE,
           "The class '$name'  was not found in library '${library.name}'.");
     }
     return cls;
   }
 
   @override
+  void forEachClass(KLibrary library, void f(ClassEntity cls)) {
+    worldBuilder._forEachClass(library, f);
+  }
+
+  @override
   LibraryEntity lookupLibrary(Uri uri, {bool required: false}) {
     LibraryEntity library = worldBuilder.lookupLibrary(uri);
     if (library == null && required) {
       throw new SpannableAssertionFailure(
           CURRENT_ELEMENT_SPANNABLE, "The library '$uri' was not found.");
     }
     return library;
   }
 
   @override
@@ skipping 238 matching lines @@
   }
 
   InterfaceType getMixinTypeForClass(KClass cls) {
     KClassEnv env = builder._classEnvs[cls.classIndex];
     ir.Supertype mixedInType = env.cls.mixedInType;
     if (mixedInType == null) return null;
     return builder.createInterfaceType(
         mixedInType.classNode, mixedInType.typeArguments);
   }
 }