Support forEachClassMember on closure classes

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 '../closure.dart' show BoxLocal;
 import '../common.dart';
@@ skipping 19 matching lines @@
 import '../js_backend/native_data.dart';
 import '../js_backend/no_such_method_registry.dart';
 import '../js_backend/runtime_types.dart';
 import '../js_model/closure.dart';
 import '../js_model/elements.dart';
 import '../native/enqueue.dart';
 import '../native/native.dart' as native;
 import '../native/resolver.dart';
 import '../ordered_typeset.dart';
 import '../options.dart';
+import '../ssa/kernel_impact.dart';
 import '../universe/class_set.dart';
 import '../universe/selector.dart';
 import '../universe/world_builder.dart';
 import '../world.dart';
 import '../util/util.dart' show Link, LinkBuilder;
 import 'element_map.dart';
 import 'element_map_mixins.dart';
 import 'elements.dart';
 import 'env.dart';
 import 'kelements.dart';
@@ skipping 78 matching lines @@
   }
 
   LibraryEntity get _mainLibrary {
     return _env.mainMethod != null
         ? _getLibrary(_env.mainMethod.enclosingLibrary)
         : null;
   }
 
   Iterable<LibraryEntity> get _libraries;
 
-  SourceSpan _getSourceSpanFromTreeNode(ir.TreeNode node) {
-    // TODO(johnniwinther): Use [ir.Location] directly as a [SourceSpan].
-    Uri uri;
-    int offset;
-    while (node != null) {
-      if (node.fileOffset != ir.TreeNode.noOffset) {
-        offset = node.fileOffset;
-        uri = Uri.parse(node.location.file);
-        break;
-      }
-      node = node.parent;
-    }
-    if (uri != null) {
-      return new SourceSpan(uri, offset, offset + 1);
-    }
-    return null;
-  }
-
   SourceSpan getSourceSpan(Spannable spannable, Entity currentElement) {
     SourceSpan fromSpannable(Spannable spannable) {
       if (spannable is IndexedLibrary &&
           spannable.libraryIndex < _libraryEnvs.length) {
         LibraryEnv env = _libraryEnvs[spannable.libraryIndex];
-        return _getSourceSpanFromTreeNode(env.library);
+        return computeSourceSpanFromTreeNode(env.library);
       } else if (spannable is IndexedClass &&
           spannable.classIndex < _classEnvs.length) {
-        ClassEnv env = _classEnvs[spannable.classIndex];
-        return _getSourceSpanFromTreeNode(env.cls);
+        ClassData data = _classData[spannable.classIndex];
+        return data.definition.location;
       } else if (spannable is IndexedMember &&
           spannable.memberIndex < _memberData.length) {
         MemberData data = _memberData[spannable.memberIndex];
-        return _getSourceSpanFromTreeNode(data.node);
+        return data.definition.location;
       }
       return null;
     }
 
     SourceSpan sourceSpan = fromSpannable(spannable);
     sourceSpan ??= fromSpannable(currentElement);
     return sourceSpan;
   }
 
   LibraryEntity lookupLibrary(Uri uri) {
@@ skipping 42 matching lines @@
       if (!classEnv.isUnnamedMixinApplication) {
         f(_getClass(classEnv.cls, classEnv));
       }
     });
   }
 
   MemberEntity lookupClassMember(IndexedClass cls, String name,
       {bool setter: false}) {
     assert(checkFamily(cls));
     ClassEnv classEnv = _classEnvs[cls.classIndex];
-    ir.Member member = classEnv.lookupMember(name, setter: setter);
-    return member != null ? getMember(member) : null;
+    return classEnv.lookupMember(this, name, setter: setter);
   }
 
   ConstructorEntity lookupConstructor(IndexedClass cls, String name) {
     assert(checkFamily(cls));
     ClassEnv classEnv = _classEnvs[cls.classIndex];
-    ir.Member member = classEnv.lookupConstructor(name);
-    return member != null ? getConstructor(member) : null;
+    return classEnv.lookupConstructor(this, name);
   }
 
   @override
   InterfaceType createInterfaceType(
       ir.Class cls, List<ir.DartType> typeArguments) {
     return new InterfaceType(getClass(cls), getDartTypes(typeArguments));
   }
 
   LibraryEntity getLibrary(ir.Library node) => _getLibrary(node);
 
@@ skipping 109 matching lines @@
 
   MemberEntity getSuperMember(ir.Member context, ir.Name name, ir.Member target,
       {bool setter: false}) {
     if (target != null) {
       return getMember(target);
     }
     ClassEntity cls = getMember(context).enclosingClass;
     IndexedClass superclass = _getSuperType(cls)?.element;
     while (superclass != null) {
       ClassEnv env = _classEnvs[superclass.classIndex];
-      ir.Member superMember = env.lookupMember(name.name, setter: setter);
+      MemberEntity superMember =
+          env.lookupMember(this, name.name, setter: setter);
       if (superMember != null) {
-        return getMember(superMember);
+        return superMember;
       }
       superclass = _getSuperType(superclass)?.element;
     }
     throw failedAt(cls, "No super method member found for ${name} in $cls.");
   }
 
   @override
   ConstructorEntity getConstructor(ir.Member node) => _getConstructor(node);
 
   ConstructorEntity _getConstructor(ir.Member node);
 
   ConstructorEntity getSuperConstructor(
       ir.Constructor sourceNode, ir.Member targetNode) {
     ConstructorEntity source = getConstructor(sourceNode);
     ClassEntity sourceClass = source.enclosingClass;
     ConstructorEntity target = getConstructor(targetNode);
     ClassEntity targetClass = target.enclosingClass;
     IndexedClass superClass = _getSuperType(sourceClass)?.element;
     if (superClass == targetClass) {
       return target;
     }
     ClassEnv env = _classEnvs[superClass.classIndex];
-    ir.Member member = env.lookupConstructor(target.name);
-    if (member != null) {
-      return getConstructor(member);
+    ConstructorEntity constructor = env.lookupConstructor(this, target.name);
+    if (constructor != null) {
+      return constructor;
     }
     throw failedAt(source, "Super constructor for $source not found.");
   }
 
   @override
   FunctionEntity getMethod(ir.Procedure node) => _getMethod(node);
 
   FunctionEntity _getMethod(ir.Procedure node);
 
   @override
@@ skipping 115 matching lines @@
       if (data.mixedInType != null) {
         f(data.mixedInType.element);
       }
       cls = data.supertype?.element;
     }
   }
 
   void _forEachConstructor(IndexedClass cls, void f(ConstructorEntity member)) {
     assert(checkFamily(cls));
     ClassEnv env = _classEnvs[cls.classIndex];
-    env.forEachConstructor((ir.Member member) {
-      f(getConstructor(member));
-    });
+    env.forEachConstructor(this, f);
   }
 
   void _forEachConstructorBody(
       IndexedClass cls, void f(ConstructorBodyEntity member)) {
     throw new UnsupportedError(
         'KernelToElementMapBase._forEachConstructorBody');
   }
 
   void _forEachClassMember(
       IndexedClass cls, void f(ClassEntity cls, MemberEntity member)) {
     assert(checkFamily(cls));
     ClassEnv env = _classEnvs[cls.classIndex];
-    env.forEachMember((ir.Member member) {
-      f(cls, getMember(member));
+    env.forEachMember(this, (MemberEntity member) {
+      f(cls, member);
     });
     ClassData data = _classData[cls.classIndex];
     _ensureSupertypes(cls, data);
     if (data.supertype != null) {
       _forEachClassMember(data.supertype.element, f);
     }
   }
 
   ConstantConstructor _getConstructorConstant(IndexedConstructor constructor) {
     assert(checkFamily(constructor));
@@ skipping 35 matching lines @@
   Iterable<InterfaceType> _getInterfaces(IndexedClass cls) {
     assert(checkFamily(cls));
     ClassData data = _classData[cls.classIndex];
     _ensureSupertypes(cls, data);
     return data.interfaces;
   }
 
   Spannable _getSpannable(MemberEntity member, ir.Node node) {
     SourceSpan sourceSpan;
     if (node is ir.TreeNode) {
-      sourceSpan = _getSourceSpanFromTreeNode(node);
+      sourceSpan = computeSourceSpanFromTreeNode(node);
     }
     sourceSpan ??= getSourceSpan(member, null);
     return sourceSpan;
   }
 
   MemberDefinition _getMemberDefinition(covariant IndexedMember member) {
     assert(checkFamily(member));
     return _memberData[member.memberIndex].definition;
   }
 
@@ skipping 138 matching lines @@
             name, _getParameterStructure(functionNode),
             isExternal: isExternal,
             isConst: node.isConst,
             isFromEnvironmentConstructor: isFromEnvironment);
         definition = new RegularMemberDefinition(constructor, node);
       } else {
         // TODO(johnniwinther): Convert `node.location` to a [SourceSpan].
         throw failedAt(
             NO_LOCATION_SPANNABLE, "Unexpected constructor node: ${node}.");
       }
-      _memberData.add(new ConstructorData(node, functionNode, definition));
+      _memberData.add(new ConstructorDataImpl(node, functionNode, definition));
       _memberList.add(constructor);
       return constructor;
     });
   }
 
+  AsyncMarker _getAsyncMarker(ir.FunctionNode node) {
+    switch (node.asyncMarker) {
+      case ir.AsyncMarker.Async:
+        return AsyncMarker.ASYNC;
+      case ir.AsyncMarker.AsyncStar:
+        return AsyncMarker.ASYNC_STAR;
+      case ir.AsyncMarker.Sync:
+        return AsyncMarker.SYNC;
+      case ir.AsyncMarker.SyncStar:
+        return AsyncMarker.SYNC_STAR;
+      case ir.AsyncMarker.SyncYielding:
+      default:
+        throw new UnsupportedError(
+            "Async marker ${node.asyncMarker} is not supported.");
+    }
+  }
+
   FunctionEntity _getMethod(ir.Procedure node) {
     return _methodMap.putIfAbsent(node, () {
       int memberIndex = _memberData.length;
       LibraryEntity library;
       ClassEntity 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;
       bool isAbstract = node.isAbstract;
       IndexedFunction function;
-      AsyncMarker asyncMarker;
-      switch (node.function.asyncMarker) {
-        case ir.AsyncMarker.Async:
-          asyncMarker = AsyncMarker.ASYNC;
-          break;
-        case ir.AsyncMarker.AsyncStar:
-          asyncMarker = AsyncMarker.ASYNC_STAR;
-          break;
-        case ir.AsyncMarker.Sync:
-          asyncMarker = AsyncMarker.SYNC;
-          break;
-        case ir.AsyncMarker.SyncStar:
-          asyncMarker = AsyncMarker.SYNC_STAR;
-          break;
-        case ir.AsyncMarker.SyncYielding:
-          throw new UnsupportedError(
-              "Async marker ${node.function.asyncMarker} is not supported.");
-      }
+      AsyncMarker asyncMarker = _getAsyncMarker(node.function);
       switch (node.kind) {
         case ir.ProcedureKind.Factory:
           throw new UnsupportedError("Cannot create method from factory.");
         case ir.ProcedureKind.Getter:
           function = createGetter(
               memberIndex, library, enclosingClass, name, asyncMarker,
               isStatic: isStatic,
               isExternal: isExternal,
               isAbstract: isAbstract);
           break;
         case ir.ProcedureKind.Method:
         case ir.ProcedureKind.Operator:
           function = createMethod(memberIndex, library, enclosingClass, name,
               _getParameterStructure(node.function), asyncMarker,
               isStatic: isStatic,
               isExternal: isExternal,
               isAbstract: isAbstract);
           break;
         case ir.ProcedureKind.Setter:
           assert(asyncMarker == AsyncMarker.SYNC);
           function = createSetter(
               memberIndex, library, enclosingClass, name.setter,
               isStatic: isStatic,
               isExternal: isExternal,
               isAbstract: isAbstract);
           break;
       }
-      _memberData.add(new FunctionData(
+      _memberData.add(new FunctionDataImpl(
           node, node.function, new RegularMemberDefinition(function, node)));
       _memberList.add(function);
       return function;
     });
   }
 
   FieldEntity _getField(ir.Field node) {
     return _fieldMap.putIfAbsent(node, () {
       int memberIndex = _memberData.length;
       LibraryEntity library;
       ClassEntity 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;
       FieldEntity field = createField(
           memberIndex, library, enclosingClass, name,
           isStatic: isStatic,
           isAssignable: node.isMutable,
           isConst: node.isConst);
-      _memberData
-          .add(new FieldData(node, new RegularMemberDefinition(field, node)));
+      _memberData.add(
+          new FieldDataImpl(node, new RegularMemberDefinition(field, node)));
       _memberList.add(field);
       return field;
     });
   }
 
   ParameterStructure _getParameterStructure(ir.FunctionNode node) {
     // TODO(johnniwinther): Cache the computed function type.
     int requiredParameters = node.requiredParameterCount;
     int positionalParameters = node.positionalParameters.length;
     List<String> namedParameters =
@@ skipping 164 matching lines @@
   /// compilation.
   void addProgram(ir.Program program) {
     _env.addProgram(program);
   }
 
   @override
   native.BehaviorBuilder get nativeBehaviorBuilder =>
       _nativeBehaviorBuilder ??= new KernelBehaviorBuilder(commonElements);
 
   ResolutionImpact computeWorldImpact(KMember member) {
-    return _memberData[member.memberIndex].getWorldImpact(this);
+    return buildKernelImpact(
+        _memberData[member.memberIndex].definition.node, this);
   }
 
   ClosureModel computeClosureModel(KMember member) {
-    ir.Member node = _memberData[member.memberIndex].node;
+    ir.Member node = _memberData[member.memberIndex].definition.node;
     return KernelClosureAnalysis.computeClosureModel(member, node);
   }
 
   /// Returns the kernel [ir.Procedure] node for the [method].
   ir.Procedure _lookupProcedure(KFunction method) {
-    return _memberData[method.memberIndex].node;
+    return _memberData[method.memberIndex].definition.node;
   }
 
   Iterable<ConstantValue> _getClassMetadata(KClass cls) {
     return _classData[cls.classIndex].getMetadata(this);
   }
 
   @override
   Local getLocalFunction(ir.TreeNode node) {
     assert(
         node is ir.FunctionDeclaration || node is ir.FunctionExpression,
@@ skipping 640 matching lines @@
 
   @override
   ElementEnvironment get elementEnvironment => elementMap.elementEnvironment;
 
   @override
   CommonElements get commonElements => elementMap.commonElements;
 
   @override
   native.NativeBehavior computeNativeFieldStoreBehavior(
       covariant KField field) {
-    ir.Field node = elementMap._memberData[field.memberIndex].node;
+    ir.Field node = elementMap._memberData[field.memberIndex].definition.node;
     return elementMap.getNativeBehaviorForFieldStore(node);
   }
 
   @override
   native.NativeBehavior computeNativeFieldLoadBehavior(covariant KField field,
       {bool isJsInterop}) {
-    ir.Field node = elementMap._memberData[field.memberIndex].node;
+    ir.Field node = elementMap._memberData[field.memberIndex].definition.node;
     return elementMap.getNativeBehaviorForFieldLoad(node,
         isJsInterop: isJsInterop);
   }
 
   @override
   native.NativeBehavior computeNativeMethodBehavior(
       covariant KFunction function,
       {bool isJsInterop}) {
-    ir.Member node = elementMap._memberData[function.memberIndex].node;
+    ir.Member node =
+        elementMap._memberData[function.memberIndex].definition.node;
     return elementMap.getNativeBehaviorForMethod(node,
         isJsInterop: isJsInterop);
   }
 
   @override
   bool isNativeMethod(covariant KFunction function) {
     if (!native.maybeEnableNative(function.library.canonicalUri)) return false;
-    ir.Member node = elementMap._memberData[function.memberIndex].node;
+    ir.Member node =
+        elementMap._memberData[function.memberIndex].definition.node;
     return node.isExternal &&
         !elementMap.isForeignLibrary(node.enclosingLibrary);
   }
 
   @override
   bool isJsInteropMember(MemberEntity element) {
     // TODO(redemption): Compute this.
     return false;
   }
 }
@@ skipping 65 matching lines @@
       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];
+      MemberDataImpl 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.copy());
       if (newMember.isField) {
@@ skipping 78 matching lines @@
     return constructor;
   }
 
   FunctionEntity getConstructorBody(ir.Constructor node) {
     ConstructorEntity constructor = getConstructor(node);
     return _getConstructorBody(node, constructor);
   }
 
   FunctionEntity _getConstructorBody(
       ir.Constructor node, covariant IndexedConstructor constructor) {
-    ConstructorData data = _memberData[constructor.memberIndex];
+    ConstructorDataImpl data = _memberData[constructor.memberIndex];
     if (data.constructorBody == null) {
-      data.constructorBody =
+      ConstructorBodyEntity constructorBody = data.constructorBody =
           createConstructorBody(_memberList.length, constructor);
-      _memberList.add(data.constructorBody);
-      _memberData.add(new FunctionData(
+      _memberList.add(constructorBody);
+      _memberData.add(new FunctionDataImpl(
           node,
           node.function,
           new SpecialMemberDefinition(
-              data.constructorBody, node, MemberKind.constructorBody)));
+              constructorBody, node, MemberKind.constructorBody)));
+      IndexedClass cls = constructor.enclosingClass;
+      ClassEnvImpl classEnv = _classEnvs[cls.classIndex];
+      // TODO(johnniwinther): Avoid this by only including live members in the
+      // js-model.
+      classEnv.addConstructorBody(constructorBody);
     }
     return data.constructorBody;
   }
 
   ConstructorBodyEntity createConstructorBody(
       int memberIndex, ConstructorEntity constructor);
 
   @override
   MemberDefinition getMemberDefinition(MemberEntity member) {
     return _getMemberDefinition(member);
   }
 
   @override
   ClassDefinition getClassDefinition(ClassEntity cls) {
     return _getClassDefinition(cls);
   }
 
   @override
   ConstantValue getFieldConstantValue(ir.Field field) {
     // TODO(johnniwinther): Cache the result in [FieldData].
     return getConstantValue(field.initializer,
         requireConstant: field.isConst, implicitNull: !field.isConst);
   }
 
   bool hasConstantFieldInitializer(covariant IndexedField field) {
     FieldData data = _memberData[field.memberIndex];
-    return getFieldConstantValue(data.node) != null;
+    return getFieldConstantValue(data.definition.node) != null;
   }
 
   ConstantValue getConstantFieldInitializer(covariant IndexedField field) {
     FieldData data = _memberData[field.memberIndex];
-    ConstantValue value = getFieldConstantValue(data.node);
+    ConstantValue value = getFieldConstantValue(data.definition.node);
     assert(value != null,
         failedAt(field, "Field $field doesn't have a constant initial value."));
     return value;
   }
 
   void forEachParameter(covariant IndexedFunction function,
       void f(DartType type, String name, ConstantValue defaultValue)) {
     FunctionData data = _memberData[function.memberIndex];
     data.forEachParameter(this, f);
   }
 
   void _forEachConstructorBody(
       IndexedClass cls, void f(ConstructorBodyEntity member)) {
     ClassEnv env = _classEnvs[cls.classIndex];
-    env.forEachConstructor((ir.Member member) {
-      IndexedConstructor constructor = _constructorMap[member];
-      if (constructor == null) {
-        // The constructor is not live.
-        return;
-      }
-      ConstructorData data = _memberData[constructor.memberIndex];
-      if (data.constructorBody != null) {
-        f(data.constructorBody);
-      }
-    });
+    env.forEachConstructorBody(f);
   }
 
   KernelClosureClass constructClosureClass(
       MemberEntity member,
       ir.FunctionNode node,
       JLibrary enclosingLibrary,
       KernelScopeInfo info,
       ir.Location location,
       KernelToLocalsMap localsMap,
       InterfaceType supertype) {
     String name = _computeClosureName(node);
-    KernelClosureClass cls = new KernelClosureClass.fromScopeInfo(node, name,
-        _classEnvs.length, enclosingLibrary, info, location, localsMap);
+    KernelClosureClass cls = new KernelClosureClass.fromScopeInfo(
+        node, name, _classEnvs.length, enclosingLibrary, info, localsMap);
     _classList.add(cls);
-    _classEnvs.add(new ClassEnv.closureClass());
+    Map<String, MemberEntity> memberMap = <String, MemberEntity>{};
+    _classEnvs.add(new ClosureClassEnv(memberMap));
 
     // Create a classData and set up the interfaces and subclass
     // relationships that _ensureSupertypes and _ensureThisAndRawType are doing
-    var closureData =
-        new ClassData(null, new ClosureClassDefinition(cls, cls.location));
+    var closureData = new ClassData(null,
+        new ClosureClassDefinition(cls, computeSourceSpanFromTreeNode(node)));
     closureData
       ..isMixinApplication = false
       ..thisType =
           closureData.rawType = new InterfaceType(cls, const/*<DartType>*/ [])
       ..supertype = supertype
       ..interfaces = const <InterfaceType>[];
     var setBuilder = new _KernelOrderedTypeSetBuilder(this, cls);
     _classData.add(closureData);
     closureData.orderedTypeSet = setBuilder.createOrderedTypeSet(
         closureData.supertype, const Link<InterfaceType>());
 
     int i = 0;
     for (ir.VariableDeclaration variable in info.freeVariables) {
       // Make a corresponding field entity in this closure class for every
       // single freeVariable in the KernelScopeInfo.freeVariable.
-      _constructClosureFields(
-          member, cls, variable, i, info.capturedVariablesAccessor, localsMap);
+      _constructClosureFields(member, cls, memberMap, variable, i,
+          info.capturedVariablesAccessor, localsMap);
       i++;
     }
 
-    cls.callMethod = new JClosureCallMethod(_memberData.length, cls, member);
+    FunctionEntity callMethod = cls.callMethod = new JClosureCallMethod(
+        _memberData.length,
+        cls,
+        _getParameterStructure(node),
+        _getAsyncMarker(node));
     _memberList.add(cls.callMethod);
-    _memberData.add(new MemberData(
-        null,
-        new ClosureMemberDefinition(
-            member, cls.location, MemberKind.closureCall, node.parent)));
 
-    // TODO(efortuna): Does getMetadata get called in ClassData for this object?
+    _memberData.add(new ClosureFunctionData(
+        new ClosureMemberDefinition(callMethod, closureData.definition.location,
+            MemberKind.closureCall, node.parent),
+        getFunctionType(node)));
+    memberMap[cls.callMethod.name] = cls.callMethod;
     return cls;
   }
 
   _constructClosureFields(
       MemberEntity member,
       KernelClosureClass cls,
+      Map<String, MemberEntity> memberMap,
       ir.VariableDeclaration variable,
       int fieldNumber,
       NodeBox box,
       KernelToLocalsMap localsMap) {
     // NOTE: This construction order may be slightly different than the
     // old Element version. The old version did all the boxed items and then
     // all the others.
     Local capturedLocal = localsMap.getLocalVariable(variable);
     if (cls.isBoxed(capturedLocal)) {
-      var boxedField = new JBoxedField(
+      FieldEntity boxedField = new JBoxedField(
           _getClosureVariableName(capturedLocal.name, fieldNumber),
           _memberData.length,
           new BoxLocal(box.name,
               localsMap.getLocalVariable(box.executableContext), member),
           cls,
           variable.isConst,
           variable.isFinal || variable.isConst);
       cls.localToFieldMap[capturedLocal] = boxedField;
       _memberList.add(boxedField);
-      _memberData.add(new MemberData(
-          null,
-          new ClosureMemberDefinition(boxedField, variable.location,
-              MemberKind.closureField, variable)));
+      _memberData.add(new ClosureFieldData(new ClosureMemberDefinition(
+          boxedField,
+          computeSourceSpanFromTreeNode(variable),
+          MemberKind.closureField,
+          variable)));
+      memberMap[boxedField.name] = boxedField;
     } else {
-      var closureField = new JClosureField(
+      FieldEntity closureField = new JClosureField(
           _getClosureVariableName(capturedLocal.name, fieldNumber),
           _memberData.length,
           cls,
           variable.isConst,
           variable.isFinal || variable.isConst);
       cls.localToFieldMap[capturedLocal] = closureField;
       _memberList.add(closureField);
-      _memberData.add(new MemberData(
-          null,
-          new ClosureMemberDefinition(cls.localToFieldMap[capturedLocal],
-              variable.location, MemberKind.closureField, variable)));
+      _memberData.add(new ClosureFieldData(new ClosureMemberDefinition(
+          cls.localToFieldMap[capturedLocal],
+          computeSourceSpanFromTreeNode(variable),
+          MemberKind.closureField,
+          variable)));
+      memberMap[closureField.name] = closureField;
     }
   }
 
   // Returns a non-unique name for the given closure element.
   String _computeClosureName(ir.TreeNode treeNode) {
     var parts = <String>[];
     if (treeNode is ir.Field && treeNode.name.name != "") {
       parts.add(treeNode.name.name);
     } else {
       parts.add('closure');
     }
     ir.TreeNode node = treeNode.parent;
-    while (node != null &&
-        (node is ir.Constructor ||
-            node is ir.Class ||
-            node is ir.FunctionNode ||
-            node is ir.Procedure)) {
+    while (node != null) {
       // TODO(johnniwinther): Simplify computed names.
       if (node is ir.Constructor ||
           node.parent is ir.Constructor ||
           (node is ir.Procedure && node.kind == ir.ProcedureKind.Factory)) {
         FunctionEntity entity;
         if (node.parent is ir.Constructor) {
           entity = getConstructorBody(node);
         } else {
           entity = getMember(node);
         }
         parts.add(utils.reconstructConstructorName(entity));
       } else {
-        String surroundingName = '';
         if (node is ir.Class) {
-          surroundingName = Elements.operatorNameToIdentifier(node.name);
+          parts.add(Elements.operatorNameToIdentifier(node.name));
         } else if (node is ir.Procedure) {
-          surroundingName = Elements.operatorNameToIdentifier(node.name.name);
+          parts.add(Elements.operatorNameToIdentifier(node.name.name));
         }
-        parts.add(surroundingName);
       }
       // A generative constructors's parent is the class; the class name is
       // already part of the generative constructor's name.
       if (node is ir.Constructor) break;
       node = node.parent;
     }
     return parts.reversed.join('_');
   }
 
   /// Generate a unique name for the [id]th closure field, with proposed name
   /// [name].
   ///
   /// The result is used as the name of [ClosureFieldElement]s, and must
   /// therefore be unique to avoid breaking an invariant in the element model
   /// (classes cannot declare multiple fields with the same name).
   ///
   /// Also, the names should be distinct from real field names to prevent
   /// clashes with selectors for those fields.
   ///
   /// These names are not used in generated code, just as element name.
   String _getClosureVariableName(String name, int id) {
     return "_captured_${name}_$id";
   }
 
   String getDeferredUri(ir.LibraryDependency node) {
     throw new UnimplementedError('JsKernelToElementMap.getDeferredUri');
   }
 }