Support forEachClassMember on closure classes

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';
 
 import '../common.dart';
-import '../common/resolution.dart';
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../elements/entities.dart';
 import '../elements/types.dart';
 import '../ordered_typeset.dart';
-import '../ssa/kernel_impact.dart';
 import 'element_map.dart';
 import 'element_map_impl.dart';
 import 'element_map_mixins.dart';
 
 /// Environment for fast lookup of program libraries.
 class ProgramEnv {
   final Set<ir.Program> _programs = new Set<ir.Program>();
 
   Map<Uri, LibraryEnv> _libraryMap;
 
@@ skipping 49 matching lines @@
   Map<String, ClassEnv> _classMap;
   Map<String, ir.Member> _memberMap;
   Map<String, ir.Member> _setterMap;
 
   LibraryEnv(this.library);
 
   void _ensureClassMap() {
     if (_classMap == null) {
       _classMap = <String, ClassEnv>{};
       for (ir.Class cls in library.classes) {
-        _classMap[cls.name] = new ClassEnv(cls);
+        _classMap[cls.name] = new ClassEnvImpl(cls);
       }
     }
   }
 
   /// Return the [ClassEnv] for the class [name] in [library].
   ClassEnv lookupClass(String name) {
     _ensureClassMap();
     return _classMap[name];
   }
 
@@ skipping 58 matching lines @@
 
   Iterable<ConstantValue> getMetadata(KernelToElementMapBase elementMap) {
     return _metadata ??= elementMap.getMetadata(library.annotations);
   }
 
   LibraryData copy() {
     return new LibraryData(library);
   }
 }
 
+/// Member data for a class.
+abstract class ClassEnv {
+  /// The [ir.Class] that defined the class, if any.
+  ir.Class get cls;
+
+  /// Whether the class is an unnamed mixin application.
+  bool get isUnnamedMixinApplication;
+
+  /// Return the [MemberEntity] for the member [name] in the class. If [setter]
+  /// is `true`, the setter or assignable field corresponding to [name] is
+  /// returned.
+  MemberEntity lookupMember(KernelToElementMap elementMap, String name,
+      {bool setter: false});
+
+  /// Calls [f] for each member of the class.
+  void forEachMember(
+      KernelToElementMap elementMap, void f(MemberEntity member));
+
+  /// Return the [ConstructorEntity] for the constructor [name] in the class.
+  ConstructorEntity lookupConstructor(
+      KernelToElementMap elementMap, String name);
+
+  /// Calls [f] for each constructor of the class.
+  void forEachConstructor(
+      KernelToElementMap elementMap, void f(ConstructorEntity constructor));
+
+  /// Calls [f] for each constructor body for the live constructors in the
+  /// class.
+  void forEachConstructorBody(void f(ConstructorBodyEntity constructor));
+}
+
 /// Environment for fast lookup of class members.
-class ClassEnv {
+class ClassEnvImpl implements ClassEnv {
   final ir.Class cls;
   final bool isUnnamedMixinApplication;
 
   Map<String, ir.Member> _constructorMap;
   Map<String, ir.Member> _memberMap;
   Map<String, ir.Member> _setterMap;
 
-  ClassEnv(this.cls)
+  /// Constructor bodies created for this class.
+  List<ConstructorBodyEntity> _constructorBodyList;
+
+  ClassEnvImpl(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('&');
 
-  // TODO(efortuna): This is gross because even though the closure class *has*
-  // members, we're not populating this because they aren't ir.Member types. :-(
-  ClassEnv.closureClass()
-      : cls = null,
-        isUnnamedMixinApplication = false,
-        _constructorMap = const <String, ir.Member>{},
-        _memberMap = const <String, ir.Member>{},
-        _setterMap = const <String, ir.Member>{};
-
   /// Copied from 'package:kernel/transformations/mixin_full_resolution.dart'.
   ir.Constructor _buildForwardingConstructor(
       CloneVisitor cloner, ir.Constructor superclassConstructor) {
     var superFunction = superclassConstructor.function;
 
     // We keep types and default values for the parameters but always mark the
     // parameters as final (since we just forward them to the super
     // constructor).
     ir.VariableDeclaration cloneVariable(ir.VariableDeclaration variable) {
       ir.VariableDeclaration clone = cloner.clone(variable);
@@ skipping 90 matching lines @@
           var forwardingConstructor = _buildForwardingConstructor(
               superclassCloner, superclassConstructor);
           cls.addMember(forwardingConstructor);
           _constructorMap[forwardingConstructor.name.name] =
               forwardingConstructor;
         }
       }
     }
   }
 
-  /// Return the [ir.Member] for the member [name] in [library].
-  ir.Member lookupMember(String name, {bool setter: false}) {
+  /// Return the [MemberEntity] for the member [name] in [cls]. If [setter] is
+  /// `true`, the setter or assignable field corresponding to [name] is
+  /// returned.
+  MemberEntity lookupMember(KernelToElementMap elementMap, String name,
+      {bool setter: false}) {
     _ensureMaps();
-    return setter ? _setterMap[name] : _memberMap[name];
+    ir.Member member = setter ? _setterMap[name] : _memberMap[name];
+    return member != null ? elementMap.getMember(member) : null;
   }
 
-  /// Return the [ir.Member] for the member [name] in [library].
-  ir.Member lookupConstructor(String name) {
+  /// Calls [f] for each member of [cls].
+  void forEachMember(
+      KernelToElementMap elementMap, void f(MemberEntity member)) {
     _ensureMaps();
-    return _constructorMap[name];
-  }
-
-  void forEachMember(void f(ir.Member member)) {
-    _ensureMaps();
-    _memberMap.values.forEach(f);
+    _memberMap.values.forEach((ir.Member member) {
+      f(elementMap.getMember(member));
+    });
     for (ir.Member member in _setterMap.values) {
       if (member is ir.Procedure) {
-        f(member);
+        f(elementMap.getMember(member));
       } else {
         // Skip fields; these are also in _memberMap.
       }
     }
   }
 
-  void forEachConstructor(void f(ir.Member member)) {
+  /// Return the [ConstructorEntity] for the constructor [name] in [cls].
+  ConstructorEntity lookupConstructor(
+      KernelToElementMap elementMap, String name) {
     _ensureMaps();
-    _constructorMap.values.forEach(f);
+    ir.Member constructor = _constructorMap[name];
+    return constructor != null ? elementMap.getConstructor(constructor) : null;
+  }
+
+  /// Calls [f] for each constructor of [cls].
+  void forEachConstructor(
+      KernelToElementMap elementMap, void f(ConstructorEntity constructor)) {
+    _ensureMaps();
+    _constructorMap.values.forEach((ir.Member constructor) {
+      f(elementMap.getConstructor(constructor));
+    });
+  }
+
+  void addConstructorBody(ConstructorBodyEntity constructorBody) {
+    _constructorBodyList ??= <ConstructorBodyEntity>[];
+    _constructorBodyList.add(constructorBody);
+  }
+
+  void forEachConstructorBody(void f(ConstructorBodyEntity constructor)) {
+    _constructorBodyList?.forEach(f);
   }
 }
 
+class ClosureClassEnv implements ClassEnv {
+  final Map<String, MemberEntity> _memberMap;
+
+  ClosureClassEnv(this._memberMap);
+
+  @override
+  void forEachConstructorBody(void f(ConstructorBodyEntity constructor)) {
+    // We do not create constructor bodies for closure classes.
+  }
+
+  @override
+  void forEachConstructor(
+      KernelToElementMap elementMap, void f(ConstructorEntity constructor)) {
+    // We do not create constructors for closure classes.
+  }
+
+  @override
+  ConstructorEntity lookupConstructor(
+      KernelToElementMap elementMap, String name) {
+    // We do not create constructors for closure classes.
+    return null;
+  }
+
+  @override
+  void forEachMember(
+      KernelToElementMap elementMap, void f(MemberEntity member)) {
+    _memberMap.values.forEach(f);
+  }
+
+  @override
+  MemberEntity lookupMember(KernelToElementMap elementMap, String name,
+      {bool setter: false}) {
+    if (setter) {
+      // All closure fields are final.
+      return null;
+    }
+    return _memberMap[name];
+  }
+
+  @override
+  bool get isUnnamedMixinApplication => false;
+
+  @override
+  ir.Class get cls => null;
+}
+
 class ClassData {
-  /// TODO(johnniwinther): Remove this from the [MemberData] interface. Use
+  /// TODO(johnniwinther): Remove this from the [ClassData] interface. Use
   /// `definition.node` instead.
   final ir.Class cls;
   final ClassDefinition definition;
   bool isMixinApplication;
 
   InterfaceType thisType;
   InterfaceType rawType;
   InterfaceType supertype;
   InterfaceType mixedInType;
   List<InterfaceType> interfaces;
   OrderedTypeSet orderedTypeSet;
 
   Iterable<ConstantValue> _metadata;
 
   ClassData(this.cls, this.definition);
 
   Iterable<ConstantValue> getMetadata(KernelToElementMapBase elementMap) {
     return _metadata ??= elementMap.getMetadata(cls.annotations);
   }
 
   ClassData copy() {
     return new ClassData(cls, definition);
   }
 }
 
-class MemberData {
+abstract class MemberData {
+  MemberDefinition get definition;
+
+  Iterable<ConstantValue> getMetadata(KernelToElementMap elementMap);
+}
+
+class MemberDataImpl implements MemberData {
   /// TODO(johnniwinther): Remove this from the [MemberData] interface. Use
   /// `definition.node` instead.
   final ir.Member node;
 
   final MemberDefinition definition;
 
   Iterable<ConstantValue> _metadata;
 
-  MemberData(this.node, this.definition);
+  MemberDataImpl(this.node, this.definition);
 
-  ResolutionImpact getWorldImpact(KernelToElementMapForImpact elementMap) {
-    return buildKernelImpact(node, elementMap);
-  }
-
-  Iterable<ConstantValue> getMetadata(KernelToElementMapBase elementMap) {
+  Iterable<ConstantValue> getMetadata(
+      covariant KernelToElementMapBase elementMap) {
     return _metadata ??= elementMap.getMetadata(node.annotations);
   }
 
   MemberData copy() {
-    return new MemberData(node, definition);
+    return new MemberDataImpl(node, definition);
   }
 }
 
-class FunctionData extends MemberData {
+abstract class FunctionData implements MemberData {
+  FunctionType getFunctionType(KernelToElementMap elementMap);
+
+  void forEachParameter(KernelToElementMapForBuilding elementMap,
+      void f(DartType type, String name, ConstantValue defaultValue));
+}
+
+class FunctionDataImpl extends MemberDataImpl implements FunctionData {
   final ir.FunctionNode functionNode;
   FunctionType _type;
 
-  FunctionData(ir.Member node, this.functionNode, MemberDefinition definition)
+  FunctionDataImpl(
+      ir.Member node, this.functionNode, MemberDefinition definition)
       : super(node, definition);
 
-  FunctionType getFunctionType(KernelToElementMapBase elementMap) {
+  FunctionType getFunctionType(covariant KernelToElementMapBase elementMap) {
     return _type ??= elementMap.getFunctionType(functionNode);
   }
 
   void forEachParameter(KernelToElementMapForBuilding elementMap,
       void f(DartType type, String name, ConstantValue defaultValue)) {
     void handleParameter(ir.VariableDeclaration node, {bool isOptional: true}) {
       DartType type = elementMap.getDartType(node.type);
       String name = node.name;
       ConstantValue defaultValue;
       if (isOptional) {
@@ skipping 10 matching lines @@
       handleParameter(functionNode.positionalParameters[i],
           isOptional: i < functionNode.requiredParameterCount);
     }
     functionNode.namedParameters.toList()
       ..sort(namedOrdering)
       ..forEach(handleParameter);
   }
 
   @override
   FunctionData copy() {
-    return new FunctionData(node, functionNode, definition);
+    return new FunctionDataImpl(node, functionNode, definition);
   }
 }
 
-class ConstructorData extends FunctionData {
+abstract class ConstructorData extends FunctionData {
+  ConstantConstructor getConstructorConstant(
+      KernelToElementMapBase elementMap, ConstructorEntity constructor);
+}
+
+class ConstructorDataImpl extends FunctionDataImpl implements ConstructorData {
   ConstantConstructor _constantConstructor;
   ConstructorBodyEntity constructorBody;
 
-  ConstructorData(
+  ConstructorDataImpl(
       ir.Member node, ir.FunctionNode functionNode, MemberDefinition definition)
       : super(node, functionNode, definition);
 
   ConstantConstructor getConstructorConstant(
       KernelToElementMapBase elementMap, ConstructorEntity constructor) {
     if (_constantConstructor == null) {
       if (node is ir.Constructor && constructor.isConst) {
         _constantConstructor =
             new Constantifier(elementMap).computeConstantConstructor(node);
       } else {
         failedAt(
             constructor,
             "Unexpected constructor $constructor in "
-            "KernelWorldBuilder._getConstructorConstant");
+            "ConstructorDataImpl._getConstructorConstant");
       }
     }
     return _constantConstructor;
   }
 
   @override
   ConstructorData copy() {
-    return new ConstructorData(node, functionNode, definition);
+    return new ConstructorDataImpl(node, functionNode, definition);
   }
 }
 
-class FieldData extends MemberData {
+abstract class FieldData extends MemberData {
+  ConstantExpression getFieldConstant(
+      KernelToElementMapBase elementMap, FieldEntity field);
+}
+
+class FieldDataImpl extends MemberDataImpl implements FieldData {
   ConstantExpression _constant;
 
-  FieldData(ir.Field node, MemberDefinition definition)
+  FieldDataImpl(ir.Field node, MemberDefinition definition)
       : super(node, definition);
 
   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 {
         failedAt(
             field,
             "Unexpected field $field in "
-            "KernelWorldBuilder._getConstructorConstant");
+            "FieldDataImpl.getFieldConstant");
       }
     }
     return _constant;
   }
 
   @override
   FieldData copy() {
-    return new FieldData(node, definition);
+    return new FieldDataImpl(node, definition);
   }
 }