Add ClassEntity.library, MemberEntity.library and FunctionEntity.isExternal

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 130 matching lines @@
   }
 
   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) {
-        KLibrary library = _getLibrary(node.enclosingLibrary);
         classEnv = _libraryEnvs[library.libraryIndex].lookupClass(node.name);
       }
       _classEnvs.add(classEnv);
-      return new KClass(_classMap.length, node.name);
+      return new KClass(library, _classMap.length, node.name);
     });
   }
 
   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);
       }
@@ skipping 16 matching lines @@
         }
       }
       throw new UnsupportedError('Unsupported type parameter type node $node.');
     });
   }
 
   KConstructor _getConstructor(ir.Member node) {
     return _constructorMap.putIfAbsent(node, () {
       int constructorIndex = _constructorList.length;
       KConstructor constructor;
+      KClass enclosingClass = _getClass(node.enclosingClass);
+      Name name = getName(node.name);
+      bool isExternal = node.isExternal;
       if (node is ir.Constructor) {
-        constructor = new KGenerativeConstructor(constructorIndex,
-            _getClass(node.enclosingClass), getName(node.name));
+        constructor = new KGenerativeConstructor(
+            constructorIndex, enclosingClass, name,
+            isExternal: isExternal);
       } else {
-        constructor = new KFactoryConstructor(constructorIndex,
-            _getClass(node.enclosingClass), getName(node.name));
+        constructor = new KFactoryConstructor(
+            constructorIndex, enclosingClass, name,
+            isExternal: isExternal);
       }
       _constructorList.add(node);
       return constructor;
     });
   }
 
   KFunction _getMethod(ir.Procedure node) {
     return _methodMap.putIfAbsent(node, () {
-      KClass enclosingClass =
-          node.enclosingClass != null ? _getClass(node.enclosingClass) : null;
+      KLibrary library;
+      KClass enclosingClass;
+      if (node.enclosingClass != null) {
+        enclosingClass = _getClass(node.enclosingClass);
+        library = enclosingClass.library;
+      } else {
+        library = _getLibrary(node.enclosingLibrary);
+      }
       Name name = getName(node.name);
       bool isStatic = node.isStatic;
+      bool isExternal = node.isExternal;
       switch (node.kind) {
         case ir.ProcedureKind.Factory:
           throw new UnsupportedError("Cannot create method from factory.");
         case ir.ProcedureKind.Getter:
-          return new KGetter(enclosingClass, name, isStatic: isStatic);
+          return new KGetter(library, enclosingClass, name,
+              isStatic: isStatic, isExternal: isExternal);
         case ir.ProcedureKind.Method:
         case ir.ProcedureKind.Operator:
-          return new KMethod(enclosingClass, name, isStatic: isStatic);
+          return new KMethod(library, enclosingClass, name,
+              isStatic: isStatic, isExternal: isExternal);
         case ir.ProcedureKind.Setter:
-          return new KSetter(enclosingClass, getName(node.name).setter,
-              isStatic: isStatic);
+          return new KSetter(library, enclosingClass, getName(node.name).setter,
+              isStatic: isStatic, isExternal: isExternal);
       }
     });
   }
 
   KField _getField(ir.Field node) {
     return _fieldMap.putIfAbsent(node, () {
       int fieldIndex = _fieldList.length;
-      KClass enclosingClass =
-          node.enclosingClass != null ? _getClass(node.enclosingClass) : null;
+      KLibrary library;
+      KClass enclosingClass;
+      if (node.enclosingClass != null) {
+        enclosingClass = _getClass(node.enclosingClass);
+        library = enclosingClass.library;
+      } else {
+        library = _getLibrary(node.enclosingLibrary);
+      }
       Name name = getName(node.name);
       bool isStatic = node.isStatic;
       _fieldList.add(node);
-      return new KField(fieldIndex, enclosingClass, name,
+      return new KField(fieldIndex, library, 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 588 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);
   }
 }