Handle member closurization in closed_world2_test

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';
@@ skipping 46 matching lines @@
 
   /// List of class environments by `KClass.classIndex`. This is used for
   /// fast lookup into class members.
   List<KClassEnv> _classEnvs = <KClassEnv>[];
 
   Map<ir.Library, KLibrary> _libraryMap = <ir.Library, KLibrary>{};
   Map<ir.Class, KClass> _classMap = <ir.Class, KClass>{};
   Map<ir.TypeParameter, KTypeVariable> _typeVariableMap =
       <ir.TypeParameter, KTypeVariable>{};
 
-  // TODO(johnniwinther): Change this to a list of 'KMemberData' class if we
-  // need more data for members.
-  List<ir.Member> _memberList = <ir.Member>[];
+  List<_MemberData> _memberList = <_MemberData>[];
 
   Map<ir.Member, KConstructor> _constructorMap = <ir.Member, KConstructor>{};
-  Map<KConstructor, ConstantConstructor> _constructorConstantMap =
-      <KConstructor, ConstantConstructor>{};
-
   Map<ir.Procedure, KFunction> _methodMap = <ir.Procedure, KFunction>{};
-
   Map<ir.Field, KField> _fieldMap = <ir.Field, KField>{};
-  Map<KField, ConstantExpression> _fieldConstantMap =
-      <KField, ConstantExpression>{};
 
   Map<ir.TreeNode, KLocalFunction> _localFunctionMap =
       <ir.TreeNode, KLocalFunction>{};
 
   KernelWorldBuilder(this.reporter) {
     _elementEnvironment = new KernelElementEnvironment(this);
     _commonElements = new CommonElements(_elementEnvironment);
     _constantEnvironment = new KernelConstantEnvironment(this);
     _nativeBehaviorBuilder =
         new KernelBehaviorBuilder(_commonElements, _constantEnvironment);
@@ skipping 153 matching lines @@
   }
 
   KConstructor _getConstructor(ir.Member node) {
     return _constructorMap.putIfAbsent(node, () {
       int memberIndex = _memberList.length;
       KConstructor constructor;
       KClass enclosingClass = _getClass(node.enclosingClass);
       Name name = getName(node.name);
       bool isExternal = node.isExternal;
 
+      ir.FunctionNode functionNode;
       if (node is ir.Constructor) {
+        functionNode = node.function;
         constructor = new KGenerativeConstructor(memberIndex, enclosingClass,
-            name, _getParameterStructure(node.function),
+            name, _getParameterStructure(functionNode),
             isExternal: isExternal, isConst: node.isConst);
       } else if (node is ir.Procedure) {
+        functionNode = node.function;
         constructor = new KFactoryConstructor(memberIndex, enclosingClass, name,
-            _getParameterStructure(node.function),
+            _getParameterStructure(functionNode),
             isExternal: isExternal, isConst: node.isConst);
       } else {
         // TODO(johnniwinther): Convert `node.location` to a [SourceSpan].
         throw new SpannableAssertionFailure(
             NO_LOCATION_SPANNABLE, "Unexpected constructor node: ${node}.");
       }
-      _memberList.add(node);
+      _memberList.add(new _ConstructorData(node, functionNode));
       return constructor;
     });
   }
 
   KFunction _getMethod(ir.Procedure node) {
     return _methodMap.putIfAbsent(node, () {
       int memberIndex = _memberList.length;
       KLibrary library;
       KClass enclosingClass;
       if (node.enclosingClass != null) {
@@ skipping 25 matching lines @@
               isAbstract: isAbstract);
           break;
         case ir.ProcedureKind.Setter:
           function = new KSetter(
               memberIndex, library, enclosingClass, getName(node.name).setter,
               isStatic: isStatic,
               isExternal: isExternal,
               isAbstract: isAbstract);
           break;
       }
-      _memberList.add(node);
+      _memberList.add(new _FunctionData(node, node.function));
       return function;
     });
   }
 
   KField _getField(ir.Field node) {
     return _fieldMap.putIfAbsent(node, () {
       int memberIndex = _memberList.length;
       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;
-      _memberList.add(node);
+      _memberList.add(new _FieldData(node));
       return new KField(memberIndex, library, enclosingClass, name,
           isStatic: isStatic,
           isAssignable: node.isMutable,
           isConst: node.isConst);
     });
   }
 
   KLocalFunction _getLocal(ir.TreeNode node) {
     return _localFunctionMap.putIfAbsent(node, () {
       MemberEntity memberContext;
@@ skipping 221 matching lines @@
         return _getMethod(node);
       }
     }
     throw new UnsupportedError("Unexpected member: $node");
   }
 
   @override
   FunctionEntity getConstructor(ir.Member node) => _getConstructor(node);
 
   ConstantConstructor _getConstructorConstant(KConstructor constructor) {
-    return _constructorConstantMap.putIfAbsent(constructor, () {
-      ir.Member node = _memberList[constructor.memberIndex];
-      if (node is ir.Constructor && node.isConst) {
-        return new Constantifier(this).computeConstantConstructor(node);
-      }
-      throw new SpannableAssertionFailure(
-          constructor,
-          "Unexpected constructor $constructor in "
-          "KernelWorldBuilder._getConstructorConstant");
-    });
+    _ConstructorData data = _memberList[constructor.memberIndex];
+    return data.getConstructorConstant(this, constructor);
   }
 
   ConstantExpression _getFieldConstant(KField field) {
-    return _fieldConstantMap.putIfAbsent(field, () {
-      ir.Field node = _memberList[field.memberIndex];
-      if (node.isConst) {
-        return new Constantifier(this).visit(node.initializer);
-      }
-      throw new SpannableAssertionFailure(
-          field,
-          "Unexpected field $field in "
-          "KernelWorldBuilder._getConstructorConstant");
-    });
+    _FieldData data = _memberList[field.memberIndex];
+    return data.getFieldConstant(this, field);
+  }
+
+  FunctionType _getFunctionType(KFunction function) {
+    _FunctionData data = _memberList[function.memberIndex];
+    return data.getFunctionType(this);
   }
 
   ResolutionImpact computeWorldImpact(KMember member) {
-    ir.Member node = _memberList[member.memberIndex];
-    return buildKernelImpact(node, this);
+    return _memberList[member.memberIndex].getWorldImpact(this);
   }
 }
 
 /// Environment for fast lookup of program libraries.
 class KEnv {
   final Set<ir.Program> programs = new Set<ir.Program>();
 
   Map<Uri, KLibraryEnv> _libraryMap;
 
   /// TODO(johnniwinther): Handle arbitrary load order if needed.
@@ skipping 165 matching lines @@
   }
 
   Iterable<ConstantExpression> getMetadata(KernelWorldBuilder worldBuilder) {
     if (_metadata == null) {
       _metadata = worldBuilder.getMetadata(cls.annotations);
     }
     return _metadata;
   }
 }
 
+class _MemberData {
+  final ir.Member node;
+
+  _MemberData(this.node);
+
+  ResolutionImpact getWorldImpact(KernelWorldBuilder worldBuilder) {
+    return buildKernelImpact(node, worldBuilder);
+  }
+}
+
+class _FunctionData extends _MemberData {
+  final ir.FunctionNode functionNode;
+  FunctionType _type;
+  CallStructure _callStructure;
+
+  _FunctionData(ir.Member node, this.functionNode) : super(node);
+
+  FunctionType getFunctionType(KernelWorldBuilder worldBuilder) {
+    return _type ??= worldBuilder.getFunctionType(functionNode);
+  }
+
+  CallStructure get callStructure {
+    return _callStructure ??= new CallStructure(
+        functionNode.positionalParameters.length +
+            functionNode.namedParameters.length,
+        functionNode.namedParameters.map((d) => d.name).toList());
+  }
+}
+
+class _ConstructorData extends _FunctionData {
+  ConstantConstructor _constantConstructor;
+
+  _ConstructorData(ir.Member node, ir.FunctionNode functionNode)
+      : super(node, functionNode);
+
+  ConstantConstructor getConstructorConstant(
+      KernelWorldBuilder worldBuilder, KConstructor constructor) {
+    if (_constantConstructor == null) {
+      if (node is ir.Constructor && constructor.isConst) {
+        _constantConstructor =
+            new Constantifier(worldBuilder).computeConstantConstructor(node);
+      } else {
+        throw new SpannableAssertionFailure(
+            constructor,
+            "Unexpected constructor $constructor in "
+            "KernelWorldBuilder._getConstructorConstant");
+      }
+    }
+    return _constantConstructor;
+  }
+}
+
+class _FieldData extends _MemberData {
+  ConstantExpression _constant;
+
+  _FieldData(ir.Field node) : super(node);
+
+  ir.Field get node => super.node;
+
+  ConstantExpression getFieldConstant(
+      KernelWorldBuilder worldBuilder, KField field) {
+    if (_constant == null) {
+      if (node.isConst) {
+        _constant = new Constantifier(worldBuilder).visit(node.initializer);
+      } else {
+        throw new SpannableAssertionFailure(
+            field,
+            "Unexpected field $field in "
+            "KernelWorldBuilder._getConstructorConstant");
+      }
+    }
+    return _constant;
+  }
+}
+
 class KernelElementEnvironment implements ElementEnvironment {
   final KernelWorldBuilder worldBuilder;
 
   KernelElementEnvironment(this.worldBuilder);
 
   @override
   DartType get dynamicType => const DynamicType();
 
   @override
   LibraryEntity get mainLibrary => worldBuilder._mainLibrary;
@@ skipping 26 matching lines @@
     return new InterfaceType(cls, typeArguments);
   }
 
   @override
   bool isSubtype(DartType a, DartType b) {
     return worldBuilder.types.isSubtype(a, b);
   }
 
   @override
   FunctionType getFunctionType(KFunction function) {
-    throw new UnimplementedError('KernelElementEnvironment.getFunctionType');
+    return worldBuilder._getFunctionType(function);
   }
 
   @override
   FunctionType getLocalFunctionType(KLocalFunction function) {
     return function.functionType;
   }
 
   @override
   DartType getUnaliasedType(DartType type) => type;
 
@@ skipping 76 matching lines @@
     LibraryEntity library = worldBuilder.lookupLibrary(uri);
     if (library == null && required) {
       throw new SpannableAssertionFailure(
           CURRENT_ELEMENT_SPANNABLE, "The library '$uri' was not found.");
     }
     return library;
   }
 
   @override
   CallStructure getCallStructure(KFunction function) {
-    ir.Member member = worldBuilder._memberList[function.memberIndex];
-    ir.FunctionNode functionNode;
-    if (member is ir.Procedure) {
-      functionNode = member.function;
-    } else if (member is ir.Constructor) {
-      functionNode = member.function;
-    } else {
-      throw new SpannableAssertionFailure(
-          function, "Unexpected function node ${member} for $function.");
-    }
-    return new CallStructure(
-        functionNode.positionalParameters.length +
-            functionNode.namedParameters.length,
-        functionNode.namedParameters.map((d) => d.name).toList());
+    _FunctionData data = worldBuilder._memberList[function.memberIndex];
+    return data.callStructure;
   }
 
   @override
   bool isDeferredLoadLibraryGetter(KMember member) {
     // TODO(johnniwinther): Support these.
     return false;
   }
 }
 
 /// Visitor that converts kernel dart types into [DartType].
@@ skipping 257 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);
   }
 }