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

pkg/compiler/lib/src/kernel/env.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.env;
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/clone.dart';
 import 'package:kernel/type_algebra.dart';
 
@@ skipping 139 matching lines @@
       } else {
         // Skip fields; these are also in _memberMap.
       }
     }
   }
 }
 
 /// Environment for fast lookup of class members.
 class ClassEnv {
   final ir.Class cls;
-  bool isMixinApplication;
   final bool isUnnamedMixinApplication;
 
-  InterfaceType thisType;
-  InterfaceType rawType;
-  InterfaceType supertype;
-  InterfaceType mixedInType;
-  List<InterfaceType> interfaces;
-  OrderedTypeSet orderedTypeSet;
-
   Map<String, ir.Member> _constructorMap;
   Map<String, ir.Member> _memberMap;
   Map<String, ir.Member> _setterMap;
 
-  Iterable<ConstantValue> _metadata;
-
   ClassEnv(this.cls)
       // TODO(johnniwinther): Change this to use a property on [cls] when such
       // is added to kernel.
       : isUnnamedMixinApplication =
             cls.name.contains('+') || cls.name.contains('&');
 
   /// Copied from 'package:kernel/transformations/mixin_full_resolution.dart'.
   ir.Constructor _buildForwardingConstructor(
       CloneVisitor cloner, ir.Constructor superclassConstructor) {
     var superFunction = superclassConstructor.function;
@@ skipping 120 matching lines @@
       } else {
         // Skip fields; these are also in _memberMap.
       }
     }
   }
 
   void forEachConstructor(void f(ir.Member member)) {
     _ensureMaps();
     _constructorMap.values.forEach(f);
   }
+}
+
+class ClassData {
+  final ir.Class cls;
+  bool isMixinApplication;
+
+  InterfaceType thisType;
+  InterfaceType rawType;
+  InterfaceType supertype;
+  InterfaceType mixedInType;
+  List<InterfaceType> interfaces;
+  OrderedTypeSet orderedTypeSet;
+
+  Iterable<ConstantValue> _metadata;
+
+  ClassData(this.cls);
 
   Iterable<ConstantValue> getMetadata(KernelToElementMapBase elementMap) {
     return _metadata ??= elementMap.getMetadata(cls.annotations);
   }
+
+  ClassData copy() {
+    return new ClassData(cls);
+  }
 }
 
 class MemberData {
   final ir.Member node;
   Iterable<ConstantValue> _metadata;
 
   MemberData(this.node);
 
   ResolutionImpact getWorldImpact(KernelToElementMapForImpact elementMap) {
     return buildKernelImpact(node, elementMap);
   }
 
   Iterable<ConstantValue> getMetadata(KernelToElementMapBase elementMap) {
     return _metadata ??= elementMap.getMetadata(node.annotations);
   }
+
+  MemberData copy() {
+    return new MemberData(node);
+  }
 }
 
 class FunctionData extends MemberData {
   final ir.FunctionNode functionNode;
   FunctionType _type;
 
   FunctionData(ir.Member node, this.functionNode) : super(node);
 
   FunctionType getFunctionType(KernelToElementMapBase elementMap) {
     return _type ??= elementMap.getFunctionType(functionNode);
@@ skipping 16 matching lines @@
     }
 
     for (int i = 0; i < functionNode.positionalParameters.length; i++) {
       handleParameter(functionNode.positionalParameters[i],
           isOptional: i < functionNode.requiredParameterCount);
     }
     functionNode.namedParameters.toList()
       ..sort(namedOrdering)
       ..forEach(handleParameter);
   }
+
+  @override
+  FunctionData copy() {
+    return new FunctionData(node, functionNode);
+  }
 }
 
 class ConstructorData extends FunctionData {
   ConstantConstructor _constantConstructor;
 
   ConstructorData(ir.Member node, ir.FunctionNode functionNode)
       : super(node, functionNode);
 
   ConstantConstructor getConstructorConstant(
       KernelToElementMapBase elementMap, ConstructorEntity constructor) {
     if (_constantConstructor == null) {
       if (node is ir.Constructor && constructor.isConst) {
         _constantConstructor =
             new Constantifier(elementMap).computeConstantConstructor(node);
       } else {
         throw new SpannableAssertionFailure(
             constructor,
             "Unexpected constructor $constructor in "
             "KernelWorldBuilder._getConstructorConstant");
       }
     }
     return _constantConstructor;
   }
+
+  @override
+  ConstructorData copy() {
+    return new ConstructorData(node, functionNode);
+  }
 }
 
 class FieldData extends MemberData {
   ConstantExpression _constant;
 
   FieldData(ir.Field node) : super(node);
 
   ir.Field get node => super.node;
 
   ConstantExpression getFieldConstant(
       KernelToElementMapBase elementMap, FieldEntity field) {
     if (_constant == null) {
       if (node.isConst) {
         _constant = new Constantifier(elementMap).visit(node.initializer);
       } else {
         throw new SpannableAssertionFailure(
             field,
             "Unexpected field $field in "
             "KernelWorldBuilder._getConstructorConstant");
       }
     }
     return _constant;
   }
+
+  @override
+  FieldData copy() {
+    return new FieldData(node);
+  }
 }