Split ClassEnv into env and data to avoid copying types/constants from the k-model

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 '../common.dart';
 import '../common/names.dart' show Identifiers;
@@ skipping 66 matching lines @@
   List<MemberEntity> _memberList = <MemberEntity>[];
 
   /// List of library environments by `IndexedLibrary.libraryIndex`. This is
   /// used for fast lookup into library classes and members.
   List<LibraryEnv> _libraryEnvs = <LibraryEnv>[];
 
   /// List of class environments by `IndexedClass.classIndex`. This is used for
   /// fast lookup into class members.
   List<ClassEnv> _classEnvs = <ClassEnv>[];
 
+  /// List of class data by `IndexedClass.classIndex`. This is used for
+  /// fast lookup into class properties.
+  List<ClassData> _classData = <ClassData>[];
+
   /// List of member data by `IndexedMember.classIndex`. This is used for
   /// fast lookup into member properties.
   List<MemberData> _memberData = <MemberData>[];
 
   KernelToElementMapBase(this.reporter, Environment environment) {
     _elementEnvironment = new KernelElementEnvironment(this);
     _commonElements = new CommonElements(_elementEnvironment);
     _constantEnvironment = new KernelConstantEnvironment(this, environment);
     _typeConverter = new DartTypeConverter(this);
     _types = new _KernelDartTypes(this);
@@ skipping 85 matching lines @@
   LibraryEntity getLibrary(ir.Library node) => _getLibrary(node);
 
   LibraryEntity _getLibrary(ir.Library node, [LibraryEnv libraryEnv]);
 
   @override
   ClassEntity getClass(ir.Class node) => _getClass(node);
 
   ClassEntity _getClass(ir.Class node, [ClassEnv classEnv]);
 
   InterfaceType _getSuperType(IndexedClass cls) {
-    ClassEnv env = _classEnvs[cls.classIndex];
-    _ensureSupertypes(cls, env);
-    return env.supertype;
+    ClassData data = _classData[cls.classIndex];
+    _ensureSupertypes(cls, data);
+    return data.supertype;
   }
 
-  void _ensureThisAndRawType(ClassEntity cls, ClassEnv env) {
-    if (env.thisType == null) {
-      ir.Class node = env.cls;
+  void _ensureThisAndRawType(ClassEntity cls, ClassData data) {
+    if (data.thisType == null) {
+      ir.Class node = data.cls;
       // TODO(johnniwinther): Add the type argument to the list literal when we
       // no longer use resolution types.
       if (node.typeParameters.isEmpty) {
-        env.thisType =
-            env.rawType = new InterfaceType(cls, const/*<DartType>*/ []);
+        data.thisType =
+            data.rawType = new InterfaceType(cls, const/*<DartType>*/ []);
       } else {
-        env.thisType = new InterfaceType(
+        data.thisType = new InterfaceType(
             cls,
             new List/*<DartType>*/ .generate(node.typeParameters.length,
                 (int index) {
               return new TypeVariableType(
                   _getTypeVariable(node.typeParameters[index]));
             }));
-        env.rawType = new InterfaceType(
+        data.rawType = new InterfaceType(
             cls,
             new List/*<DartType>*/ .filled(
                 node.typeParameters.length, const DynamicType()));
       }
     }
   }
 
   TypeVariableEntity getTypeVariable(ir.TypeParameter node) =>
       _getTypeVariable(node);
 
   TypeVariableEntity _getTypeVariable(ir.TypeParameter node);
 
-  void _ensureSupertypes(ClassEntity cls, ClassEnv env) {
-    if (env.orderedTypeSet == null) {
-      _ensureThisAndRawType(cls, env);
+  void _ensureSupertypes(ClassEntity cls, ClassData data) {
+    if (data.orderedTypeSet == null) {
+      _ensureThisAndRawType(cls, data);
 
-      ir.Class node = env.cls;
+      ir.Class node = data.cls;
 
       if (node.supertype == null) {
-        env.orderedTypeSet = new OrderedTypeSet.singleton(env.thisType);
-        env.isMixinApplication = false;
-        env.interfaces = const <InterfaceType>[];
+        data.orderedTypeSet = new OrderedTypeSet.singleton(data.thisType);
+        data.isMixinApplication = false;
+        data.interfaces = const <InterfaceType>[];
       } else {
         InterfaceType processSupertype(ir.Supertype node) {
-          InterfaceType type = _typeConverter.visitSupertype(node);
-          IndexedClass superclass = type.element;
-          ClassEnv env = _classEnvs[superclass.classIndex];
-          _ensureSupertypes(superclass, env);
-          return type;
+          InterfaceType supertype = _typeConverter.visitSupertype(node);
+          IndexedClass superclass = supertype.element;
+          ClassData superdata = _classData[superclass.classIndex];
+          _ensureSupertypes(superclass, superdata);
+          return supertype;
         }
 
-        env.supertype = processSupertype(node.supertype);
+        data.supertype = processSupertype(node.supertype);
         LinkBuilder<InterfaceType> linkBuilder =
             new LinkBuilder<InterfaceType>();
         if (node.mixedInType != null) {
-          env.isMixinApplication = true;
+          data.isMixinApplication = true;
           linkBuilder
-              .addLast(env.mixedInType = processSupertype(node.mixedInType));
+              .addLast(data.mixedInType = processSupertype(node.mixedInType));
         } else {
-          env.isMixinApplication = false;
+          data.isMixinApplication = false;
         }
         node.implementedTypes.forEach((ir.Supertype supertype) {
           linkBuilder.addLast(processSupertype(supertype));
         });
         Link<InterfaceType> interfaces = linkBuilder.toLink();
         OrderedTypeSetBuilder setBuilder =
             new _KernelOrderedTypeSetBuilder(this, cls);
-        env.orderedTypeSet =
-            setBuilder.createOrderedTypeSet(env.supertype, interfaces);
-        env.interfaces = new List<InterfaceType>.from(interfaces.toList());
+        data.orderedTypeSet =
+            setBuilder.createOrderedTypeSet(data.supertype, interfaces);
+        data.interfaces = new List<InterfaceType>.from(interfaces.toList());
       }
     }
   }
 
   @override
   MemberEntity getMember(ir.Member node) {
     if (node is ir.Field) {
       return _getField(node);
     } else if (node is ir.Constructor) {
       return _getConstructor(node);
@@ skipping 111 matching lines @@
       {bool requireConstant: true}) {
     return _constantEnvironment.getConstantValue(constant);
   }
 
   DartType _substByContext(DartType type, InterfaceType context) {
     return type.subst(
         context.typeArguments, _getThisType(context.element).typeArguments);
   }
 
   InterfaceType _getThisType(IndexedClass cls) {
-    ClassEnv env = _classEnvs[cls.classIndex];
-    _ensureThisAndRawType(cls, env);
-    return env.thisType;
+    ClassData data = _classData[cls.classIndex];
+    _ensureThisAndRawType(cls, data);
+    return data.thisType;
   }
 
   InterfaceType _getRawType(IndexedClass cls) {
-    ClassEnv env = _classEnvs[cls.classIndex];
-    _ensureThisAndRawType(cls, env);
-    return env.rawType;
+    ClassData data = _classData[cls.classIndex];
+    _ensureThisAndRawType(cls, data);
+    return data.rawType;
   }
 
   FunctionType _getFunctionType(IndexedFunction function) {
     FunctionData data = _memberData[function.memberIndex];
     return data.getFunctionType(this);
   }
 
   ClassEntity _getAppliedMixin(IndexedClass cls) {
-    ClassEnv env = _classEnvs[cls.classIndex];
-    _ensureSupertypes(cls, env);
-    return env.mixedInType?.element;
+    ClassData data = _classData[cls.classIndex];
+    _ensureThisAndRawType(cls, data);
+    return data.mixedInType?.element;
   }
 
   bool _isMixinApplication(IndexedClass cls) {
-    ClassEnv env = _classEnvs[cls.classIndex];
-    _ensureSupertypes(cls, env);
-    return env.isMixinApplication;
+    ClassData data = _classData[cls.classIndex];
+    _ensureThisAndRawType(cls, data);
+    return data.isMixinApplication;
   }
 
   bool _isUnnamedMixinApplication(IndexedClass cls) {
     ClassEnv env = _classEnvs[cls.classIndex];
-    _ensureSupertypes(cls, env);
     return env.isUnnamedMixinApplication;
   }
 
   void _forEachSupertype(IndexedClass cls, void f(InterfaceType supertype)) {
-    ClassEnv env = _classEnvs[cls.classIndex];
-    _ensureSupertypes(cls, env);
-    env.orderedTypeSet.supertypes.forEach(f);
+    ClassData data = _classData[cls.classIndex];
+    _ensureThisAndRawType(cls, data);
+    data.orderedTypeSet.supertypes.forEach(f);
   }
 
   void _forEachMixin(IndexedClass cls, void f(ClassEntity mixin)) {
     while (cls != null) {
-      ClassEnv env = _classEnvs[cls.classIndex];
-      _ensureSupertypes(cls, env);
-      if (env.mixedInType != null) {
-        f(env.mixedInType.element);
+      ClassData data = _classData[cls.classIndex];
+      _ensureThisAndRawType(cls, data);
+      if (data.mixedInType != null) {
+        f(data.mixedInType.element);
       }
-      cls = env.supertype?.element;
+      cls = data.supertype?.element;
     }
   }
 
   void _forEachConstructor(IndexedClass cls, void f(ConstructorEntity member)) {
     ClassEnv env = _classEnvs[cls.classIndex];
     env.forEachConstructor((ir.Member member) {
       f(getConstructor(member));
     });
   }
 
   void _forEachClassMember(
       IndexedClass cls, void f(ClassEntity cls, MemberEntity member)) {
     ClassEnv env = _classEnvs[cls.classIndex];
     env.forEachMember((ir.Member member) {
       f(cls, getMember(member));
     });
-    _ensureSupertypes(cls, env);
-    if (env.supertype != null) {
-      _forEachClassMember(env.supertype.element, f);
+    ClassData data = _classData[cls.classIndex];
+    _ensureSupertypes(cls, data);
+    if (data.supertype != null) {
+      _forEachClassMember(data.supertype.element, f);
     }
   }
 
   ConstantConstructor _getConstructorConstant(IndexedConstructor constructor) {
     ConstructorData data = _memberData[constructor.memberIndex];
     return data.getConstructorConstant(this, constructor);
   }
 
   ConstantExpression _getFieldConstant(IndexedField field) {
     FieldData data = _memberData[field.memberIndex];
     return data.getFieldConstant(this, field);
   }
 
   InterfaceType _asInstanceOf(InterfaceType type, ClassEntity cls) {
     OrderedTypeSet orderedTypeSet = _getOrderedTypeSet(type.element);
     InterfaceType supertype =
         orderedTypeSet.asInstanceOf(cls, _getHierarchyDepth(cls));
     if (supertype != null) {
       supertype = _substByContext(supertype, type);
     }
     return supertype;
   }
 
   OrderedTypeSet _getOrderedTypeSet(IndexedClass cls) {
-    ClassEnv env = _classEnvs[cls.classIndex];
-    _ensureSupertypes(cls, env);
-    return env.orderedTypeSet;
+    ClassData data = _classData[cls.classIndex];
+    _ensureThisAndRawType(cls, data);
+    return data.orderedTypeSet;
   }
 
   int _getHierarchyDepth(IndexedClass cls) {
-    ClassEnv env = _classEnvs[cls.classIndex];
-    _ensureSupertypes(cls, env);
-    return env.orderedTypeSet.maxDepth;
+    ClassData data = _classData[cls.classIndex];
+    _ensureThisAndRawType(cls, data);
+    return data.orderedTypeSet.maxDepth;
   }
 
   Iterable<InterfaceType> _getInterfaces(IndexedClass cls) {
-    ClassEnv env = _classEnvs[cls.classIndex];
-    _ensureSupertypes(cls, env);
-    return env.interfaces;
+    ClassData data = _classData[cls.classIndex];
+    _ensureThisAndRawType(cls, data);
+    return data.interfaces;
   }
 
   Spannable _getSpannable(MemberEntity member, ir.Node node) {
     return member;
   }
 
   ir.Member _getMemberNode(covariant IndexedMember member) {
     return _memberData[member.memberIndex].node;
   }
 
   ir.Class _getClassNode(covariant IndexedClass cls) {
     return _classEnvs[cls.classIndex].cls;
   }
 }
 
 /// Mixin that implements the abstract methods in [KernelToElementMapBase] by
 /// creating K-model elements.
 abstract class ElementCreatorMixin {
   ProgramEnv get _env;
   List<LibraryEntity> get _libraryList;
   List<LibraryEnv> get _libraryEnvs;
   List<ClassEntity> get _classList;
   List<ClassEnv> get _classEnvs;
+  List<ClassData> get _classData;
   List<MemberEntity> get _memberList;
   List<MemberData> get _memberData;
 
   Map<ir.Library, IndexedLibrary> _libraryMap = <ir.Library, IndexedLibrary>{};
   Map<ir.Class, IndexedClass> _classMap = <ir.Class, IndexedClass>{};
   Map<ir.TypeParameter, TypeVariableEntity> _typeVariableMap =
       <ir.TypeParameter, TypeVariableEntity>{};
   Map<ir.Member, IndexedConstructor> _constructorMap =
       <ir.Member, IndexedConstructor>{};
   Map<ir.Procedure, IndexedFunction> _methodMap =
@@ skipping 32 matching lines @@
     });
   }
 
   ClassEntity _getClass(ir.Class node, [ClassEnv classEnv]) {
     return _classMap.putIfAbsent(node, () {
       KLibrary library = _getLibrary(node.enclosingLibrary);
       if (classEnv == null) {
         classEnv = _libraryEnvs[library.libraryIndex].lookupClass(node.name);
       }
       _classEnvs.add(classEnv);
+      _classData.add(new ClassData(node));
       ClassEntity cls = createClass(library, _classMap.length, node.name,
           isAbstract: node.isAbstract);
       _classList.add(cls);
       return cls;
     });
   }
 
   TypeVariableEntity _getTypeVariable(ir.TypeParameter node) {
     return _typeVariableMap.putIfAbsent(node, () {
       if (node.parent is ir.Class) {
@@ skipping 355 matching lines @@
   ResolutionImpact computeWorldImpact(KMember member) {
     return _memberData[member.memberIndex].getWorldImpact(this);
   }
 
   /// Returns the kernel [ir.Procedure] node for the [method].
   ir.Procedure _lookupProcedure(KFunction method) {
     return _memberData[method.memberIndex].node;
   }
 
   Iterable<ConstantValue> _getClassMetadata(KClass cls) {
-    return _classEnvs[cls.classIndex].getMetadata(this);
+    return _classData[cls.classIndex].getMetadata(this);
   }
 }
 
 /// Implementation of [KernelToElementMapForImpact] that only supports world
 /// impact computation.
 // TODO(johnniwinther): Merge this with [KernelToElementMapForImpactImpl] when
 // [JsStrategy] is the default.
 class KernelToElementMapForImpactImpl2 extends KernelToElementMapBase
     with
         KernelToElementMapForImpactMixin,
@@ skipping 112 matching lines @@
   InterfaceType getRawType(ClassEntity cls) {
     return elementMap._getRawType(cls);
   }
 
   @override
   bool isGenericClass(ClassEntity cls) {
     return getThisType(cls).typeArguments.isNotEmpty;
   }
 
   @override
-  bool isMixinApplication(covariant KClass cls) {
+  bool isMixinApplication(ClassEntity cls) {
     return elementMap._isMixinApplication(cls);
   }
 
   @override
-  bool isUnnamedMixinApplication(covariant KClass cls) {
+  bool isUnnamedMixinApplication(ClassEntity cls) {
     return elementMap._isUnnamedMixinApplication(cls);
   }
 
   @override
   ClassEntity getEffectiveMixinClass(ClassEntity cls) {
     if (!isMixinApplication(cls)) return null;
     do {
       cls = elementMap._getAppliedMixin(cls);
     } while (isMixinApplication(cls));
     return cls;
@@ skipping 107 matching lines @@
       {bool required: false}) {
     ClassEntity cls = elementMap.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(covariant KLibrary library, void f(ClassEntity cls)) {
+  void forEachClass(LibraryEntity library, void f(ClassEntity cls)) {
     elementMap._forEachClass(library, f);
   }
 
   @override
   LibraryEntity lookupLibrary(Uri uri, {bool required: false}) {
     LibraryEntity library = elementMap.lookupLibrary(uri);
     if (library == null && required) {
       throw new SpannableAssertionFailure(
           CURRENT_ELEMENT_SPANNABLE, "The library '$uri' was not found.");
     }
     return library;
   }
 
   @override
-  bool isDeferredLoadLibraryGetter(covariant KMember member) {
+  bool isDeferredLoadLibraryGetter(MemberEntity member) {
     // TODO(redemption): Support these.
     return false;
   }
 
   @override
-  Iterable<ConstantValue> getMemberMetadata(covariant KMember member) {
+  Iterable<ConstantValue> getMemberMetadata(covariant IndexedMember member) {
     MemberData memberData = elementMap._memberData[member.memberIndex];
     return memberData.getMetadata(elementMap);
   }
 }
 
 /// Visitor that converts kernel dart types into [DartType].
 class DartTypeConverter extends ir.DartTypeVisitor<DartType> {
   final KernelToElementMapBase elementMap;
   bool topLevel = true;
 
@@ skipping 456 matching lines @@
       LibraryEntity oldLibrary = _elementMap._libraryList[libraryIndex];
       LibraryEntity newLibrary = convertLibrary(oldLibrary);
       _libraryMap[env.library] = newLibrary;
       _libraryList.add(newLibrary);
       _libraryEnvs.add(env);
     }
     for (int classIndex = 0;
         classIndex < _elementMap._classEnvs.length;
         classIndex++) {
       ClassEnv env = _elementMap._classEnvs[classIndex];
+      ClassData data = _elementMap._classData[classIndex];
       ClassEntity oldClass = _elementMap._classList[classIndex];
       IndexedLibrary oldLibrary = oldClass.library;
       LibraryEntity newLibrary = _libraryList[oldLibrary.libraryIndex];
       ClassEntity newClass = convertClass(newLibrary, oldClass);
       _classMap[env.cls] = newClass;
       _classList.add(newClass);
       _classEnvs.add(env);
+      _classData.add(data.copy());
     }
     for (int memberIndex = 0;
         memberIndex < _elementMap._memberData.length;
         memberIndex++) {
       MemberData data = _elementMap._memberData[memberIndex];
       MemberEntity oldMember = _elementMap._memberList[memberIndex];
       IndexedLibrary oldLibrary = oldMember.library;
       IndexedClass oldClass = oldMember.enclosingClass;
       LibraryEntity newLibrary = _libraryList[oldLibrary.libraryIndex];
       ClassEntity newClass =
           oldClass != null ? _classList[oldClass.classIndex] : null;
       IndexedMember newMember = convertMember(newLibrary, newClass, oldMember);
       _memberList.add(newMember);
-      _memberData.add(data);
+      _memberData.add(data.copy());
       if (newMember.isField) {
         _fieldMap[data.node] = newMember;
       } else if (newMember.isConstructor) {
         _constructorMap[data.node] = newMember;
       } else {
         _methodMap[data.node] = newMember;
       }
     }
   }
 
@@ skipping 20 matching lines @@
     throw new UnsupportedError("JsKernelToElementMap.getLocalFunction");
   }
 
   @override
   ClassEntity _getClass(ir.Class node, [ClassEnv env]) {
     ClassEntity cls = _classMap[node];
     assert(cls != null, "No class entity for $node");
     return cls;
   }
 
-  @override
-  TypeVariableEntity _getTypeVariable(ir.TypeParameter node) {
-    throw new UnsupportedError("JsKernelToElementMap._getTypeVariable");
-  }
-
   // TODO(johnniwinther): Reinsert these when [ElementCreatorMixin] is no longer
   // mixed in.
   /*@override
   FieldEntity _getField(ir.Field node) {
     FieldEntity field = _fieldMap[node];
     assert(field != null, "No field entity for $node");
     return field;
   }*/
 
   /*@override
@@ skipping 36 matching lines @@
     throw new UnsupportedError(
         "JsKernelToElementMap.getConstantFieldInitializer");
   }
 
   @override
   bool hasConstantFieldInitializer(FieldEntity field) {
     throw new UnsupportedError(
         "JsKernelToElementMap.hasConstantFieldInitializer");
   }
 }