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 459 matching lines @@
   }
 
   void _forEachConstructor(IndexedClass cls, void f(ConstructorEntity member)) {
     assert(checkFamily(cls));
     ClassEnv env = _classEnvs[cls.classIndex];
     env.forEachConstructor((ir.Member member) {
       f(getConstructor(member));
     });
   }
 
+  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));
     });
     ClassData data = _classData[cls.classIndex];
     _ensureSupertypes(cls, data);
     if (data.supertype != null) {
@@ skipping 162 matching lines @@
           }
         }
       }
       throw new UnsupportedError('Unsupported type parameter type node $node.');
     });
   }
 
   ConstructorEntity _getConstructor(ir.Member node) {
     return _constructorMap.putIfAbsent(node, () {
       int memberIndex = _memberData.length;
-      KConstructor constructor;
-      KClass enclosingClass = _getClass(node.enclosingClass);
+      ConstructorEntity constructor;
+      ClassEntity 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 = createGenerativeConstructor(memberIndex, enclosingClass,
             name, _getParameterStructure(functionNode),
             isExternal: isExternal, isConst: node.isConst);
       } else if (node is ir.Procedure) {
@@ skipping 472 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 644 matching lines @@
     return function;
   }*/
 
   @override
   ConstructorEntity _getConstructor(ir.Member node) {
     ConstructorEntity constructor = _constructorMap[node];
     assert(constructor != null, "No constructor entity for $node");
     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];
+    if (data.constructorBody == null) {
+      data.constructorBody =
+          createConstructorBody(_memberList.length, constructor);
+      _memberList.add(data.constructorBody);
+      _memberData.add(new FunctionData(node, node.function));
+    }
+    return data.constructorBody;
+  }
+
+  ConstructorBodyEntity createConstructorBody(
+      int memberIndex, ConstructorEntity constructor);
+
   @override
   ir.Member getMemberNode(MemberEntity member) {
     return _getMemberNode(member);
   }
 
   @override
   ir.Class getClassNode(ClassEntity cls) {
     return _getClassNode(cls);
   }
 
@@ skipping 15 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);
   }
+
+  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);
+      }
+    });
+  }
+
+  String getDeferredUri(ir.LibraryDependency node) {
+    throw new UnimplementedError('JsKernelToElementMap.getDeferredUri');
+  }
 }