Add ConstructorBodyEntity

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 290 matching lines @@
     }
     throw new SpannableAssertionFailure(
         cls, "No super method member found for ${name} in $cls.");
   }
 
   @override
   ConstructorEntity getConstructor(ir.Member node) => _getConstructor(node);
 
   ConstructorEntity _getConstructor(ir.Member node);
 
+  FunctionEntity getConstructorBody(ir.Constructor node) {
+    ConstructorEntity constructor = getConstructor(node);
+    return _getConstructorBody(node, constructor);
+  }
+
+  FunctionEntity _getConstructorBody(
+      ir.Constructor node, ConstructorEntity constructor);
+
   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;
     }
@@ skipping 124 matching lines @@
     }
   }
 
   void _forEachConstructor(IndexedClass cls, void f(ConstructorEntity member)) {
     ClassEnv env = _classEnvs[cls.classIndex];
     env.forEachConstructor((ir.Member member) {
       f(getConstructor(member));
     });
   }
 
+  void _forEachConstructorBody(
+      IndexedClass cls, void f(ConstructorBodyEntity member)) {
+    ClassEnv env = _classEnvs[cls.classIndex];
+    env.forEachConstructor((ir.Member member) {
+      IndexedConstructor constructor = getConstructor(member);
+      ConstructorData data = _memberData[constructor.memberIndex];
+      if (data.constructorBody != null) {
+        f(data.constructorBody);
+      }
+    });
+  }
+
   void _forEachClassMember(
       IndexedClass cls, void f(ClassEntity cls, MemberEntity member)) {
     ClassEnv env = _classEnvs[cls.classIndex];
     env.forEachMember((ir.Member member) {
       f(cls, getMember(member));
     });
     ClassData data = _classData[cls.classIndex];
     _ensureSupertypes(cls, data);
     if (data.supertype != null) {
       _forEachClassMember(data.supertype.element, f);
@@ skipping 176 matching lines @@
         // TODO(johnniwinther): Convert `node.location` to a [SourceSpan].
         throw new SpannableAssertionFailure(
             NO_LOCATION_SPANNABLE, "Unexpected constructor node: ${node}.");
       }
       _memberData.add(new ConstructorData(node, functionNode));
       _memberList.add(constructor);
       return constructor;
     });
   }
 
+  FunctionEntity _getConstructorBody(
+      ir.Constructor node, covariant IndexedConstructor constructor) {
+    ConstructorData data = _memberData[constructor.memberIndex];
+    if (data.constructorBody == null) {
+      data.constructorBody =
+          createConstructorBody(_memberList.length, constructor);
+      _memberList.add(data.constructorBody);
+      _memberData.add(new FunctionData(node, node.function));
+    }
+    return data.constructorBody;
+  }
+
   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);
@@ skipping 138 matching lines @@
 
   IndexedConstructor createFactoryConstructor(
       int memberIndex,
       ClassEntity enclosingClass,
       Name name,
       ParameterStructure parameterStructure,
       {bool isExternal,
       bool isConst,
       bool isFromEnvironmentConstructor});
 
+  ConstructorBodyEntity createConstructorBody(
+      int memberIndex, ConstructorEntity constructor);
+
   IndexedFunction createGetter(int memberIndex, LibraryEntity library,
       ClassEntity enclosingClass, Name name, AsyncMarker asyncMarker,
       {bool isStatic, bool isExternal, bool isAbstract});
 
   IndexedFunction createMethod(
       int memberIndex,
       LibraryEntity library,
       ClassEntity enclosingClass,
       Name name,
       ParameterStructure parameterStructure,
@@ skipping 51 matching lines @@
       {bool isExternal,
       bool isConst,
       bool isFromEnvironmentConstructor}) {
     return new KFactoryConstructor(
         memberIndex, enclosingClass, name, parameterStructure,
         isExternal: isExternal,
         isConst: isConst,
         isFromEnvironmentConstructor: isFromEnvironmentConstructor);
   }
 
+  @override
+  ConstructorBodyEntity createConstructorBody(
+      int memberIndex, ConstructorEntity constructor) {
+    return new KConstructorBody(memberIndex, constructor);

[Siggi Cherem (dart-lang), 2017/07/07 20:00:25]

I thought we didn't need to have one on the K model?

If we do, I'd intead store in the closure-task the body as a key and only fetch
the original constructor in order to get a hold of the internal ir of the ctor
body.

[Johnni Winther, 2017/07/10 14:11:33]

Now, we don't. [getConstructorBody], [_getConstructorBody] and
[createConstructorBody] are moved from [KernelToElementMapBase] to
[JsKernelToElementMap].

+  }
+
   IndexedFunction createGetter(int memberIndex, LibraryEntity library,
       ClassEntity enclosingClass, Name name, AsyncMarker asyncMarker,
       {bool isStatic, bool isExternal, bool isAbstract}) {
     return new KGetter(memberIndex, library, enclosingClass, name, asyncMarker,
         isStatic: isStatic, isExternal: isExternal, isAbstract: isAbstract);
   }
 
   IndexedFunction createMethod(
       int memberIndex,
       LibraryEntity library,
@@ skipping 104 matching lines @@
     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);
   }
+
+  String getDeferredUri(ir.LibraryDependency node) {
+    throw new UnimplementedError(
+        'KernelToElementMapForBuildingFromBaseMixin.getDeferredUri');
+  }
 }
 
 /// Element builder used for creating elements and types corresponding to Kernel
 /// IR nodes.
 // TODO(johnniwinther): Use this in the JsStrategy
 class KernelToElementMapForBuildingImpl extends KernelToElementMapBase
     with
         KernelToElementMapForBuildingMixin,
         KernelToElementMapForBuildingFromBaseMixin,
         ElementCreatorMixin,
@@ skipping 175 matching lines @@
     elementMap._forEachClassMember(cls, f);
   }
 
   @override
   void forEachConstructor(
       ClassEntity cls, void f(ConstructorEntity constructor)) {
     elementMap._forEachConstructor(cls, f);
   }
 
   @override
+  void forEachConstructorBody(
+      ClassEntity cls, void f(ConstructorBodyEntity constructor)) {
+    elementMap._forEachConstructorBody(cls, f);
+  }
+
+  @override
   void forEachLibraryMember(
       LibraryEntity library, void f(MemberEntity member)) {
     elementMap._forEachLibraryMember(library, f);
   }
 
   @override
   MemberEntity lookupLibraryMember(LibraryEntity library, String name,
       {bool setter: false, bool required: false}) {
     MemberEntity member =
         elementMap.lookupLibraryMember(library, name, setter: setter);
@@ skipping 612 matching lines @@
   @override
   ir.Member getMemberNode(MemberEntity member) {
     return _getMemberNode(member);
   }
 
   @override
   ir.Class getClassNode(ClassEntity cls) {
     return _getClassNode(cls);
   }
 }