Add Class/MemberDefinition to handle synthesized classes/members

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 583 matching lines @@
 
   Spannable _getSpannable(MemberEntity member, ir.Node node) {
     SourceSpan sourceSpan;
     if (node is ir.TreeNode) {
       sourceSpan = _getSourceSpanFromTreeNode(node);
     }
     sourceSpan ??= getSourceSpan(member, null);
     return sourceSpan;
   }
 
-  ir.Member _getMemberNode(covariant IndexedMember member) {
+  MemberDefinition _getMemberDefinition(covariant IndexedMember member) {
     assert(checkFamily(member));
-    return _memberData[member.memberIndex].node;
+    return _memberData[member.memberIndex].definition;
   }
 
-  ir.Class _getClassNode(covariant IndexedClass cls) {
+  ClassDefinition _getClassDefinition(covariant IndexedClass cls) {
     assert(checkFamily(cls));
-    return _classEnvs[cls.classIndex].cls;
+    return _classData[cls.classIndex].definition;
   }
 }
 
 /// Mixin that implements the abstract methods in [KernelToElementMapBase].
 abstract class ElementCreatorMixin {
   ProgramEnv get _env;
   List<LibraryEntity> get _libraryList;
   List<LibraryEnv> get _libraryEnvs;
   List<LibraryData> get _libraryData;
   List<ClassEntity> get _classList;
@@ skipping 39 matching lines @@
         name = path.substring(path.lastIndexOf('/') + 1);
       }
       LibraryEntity library =
           createLibrary(_libraryMap.length, name, canonicalUri);
       _libraryList.add(library);
       _libraryData.add(new LibraryData(node));
       return library;
     });
   }
 
+  // TODO(johnniwinther,efortuna): Create the class index and data together with
+  // the [KernelClosureClass].
   void addClosureClass(KernelClosureClass cls, InterfaceType supertype) {
     cls.classIndex = _classEnvs.length;
     _classEnvs.add(new ClassEnv.closureClass());
     _classList.add(cls);
 
     // Create a classData and set up the interfaces and subclass
     // relationships that _ensureSupertypes and _ensureThisAndRawType are doing
-    var closureData = new ClassData(null);
+    var closureData =
+        new ClassData(null, new ClosureClassDefinition(cls, cls.location));
     closureData
       ..isMixinApplication = false
       ..thisType =
           closureData.rawType = new InterfaceType(cls, const/*<DartType>*/ [])
       ..supertype = supertype
       ..interfaces = const <InterfaceType>[];
     var setBuilder =
         new _KernelOrderedTypeSetBuilder((this as KernelToElementMapBase), cls);
     _classData.add(closureData);
     closureData.orderedTypeSet = setBuilder.createOrderedTypeSet(
         closureData.supertype, const Link<InterfaceType>());
     // TODO(efortuna): Does getMetadata get called in ClassData for this object?
   }
 
   ClassEntity _getClass(ir.Class node, [ClassEnv classEnv]) {
     return _classMap.putIfAbsent(node, () {
       KLibrary library = _getLibrary(node.enclosingLibrary);
       if (classEnv == null) {
         classEnv = _libraryEnvs[library.libraryIndex].lookupClass(node.name);
       }
       _classEnvs.add(classEnv);
-      _classData.add(new ClassData(node));
       ClassEntity cls = createClass(library, _classList.length, node.name,
           isAbstract: node.isAbstract);
+      _classData
+          .add(new ClassData(node, new RegularClassDefinition(cls, node)));
       _classList.add(cls);
       return cls;
     });
   }
 
   TypeVariableEntity _getTypeVariable(ir.TypeParameter node) {
     return _typeVariableMap.putIfAbsent(node, () {
       if (node.parent is ir.Class) {
         int typeVariableIndex = _typeVariableList.length;
         ir.Class cls = node.parent;
@@ skipping 31 matching lines @@
 
   ConstructorEntity _getConstructor(ir.Member node) {
     return _constructorMap.putIfAbsent(node, () {
       int memberIndex = _memberData.length;
       ConstructorEntity constructor;
       ClassEntity enclosingClass = _getClass(node.enclosingClass);
       Name name = getName(node.name);
       bool isExternal = node.isExternal;
 
       ir.FunctionNode functionNode;
+      MemberDefinition definition;
       if (node is ir.Constructor) {
         functionNode = node.function;
         constructor = createGenerativeConstructor(memberIndex, enclosingClass,
             name, _getParameterStructure(functionNode),
             isExternal: isExternal, isConst: node.isConst);
+        definition = new SpecialMemberDefinition(
+            constructor, node, MemberKind.constructor);
       } else if (node is ir.Procedure) {
         functionNode = node.function;
         bool isFromEnvironment = isExternal &&
             name.text == 'fromEnvironment' &&
             const ['int', 'bool', 'String'].contains(enclosingClass.name);
         constructor = createFactoryConstructor(memberIndex, enclosingClass,
             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));
+      _memberData.add(new ConstructorData(node, functionNode, definition));
       _memberList.add(constructor);
       return constructor;
     });
   }
 
   FunctionEntity _getMethod(ir.Procedure node) {
     return _methodMap.putIfAbsent(node, () {
       int memberIndex = _memberData.length;
       LibraryEntity library;
       ClassEntity enclosingClass;
@@ skipping 46 matching lines @@
           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(node, node.function));
+      _memberData.add(new FunctionData(
+          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;
-      _memberData.add(new FieldData(node));
       FieldEntity field = createField(
           memberIndex, library, enclosingClass, name,
           isStatic: isStatic,
           isAssignable: node.isMutable,
           isConst: node.isConst);
+      _memberData
+          .add(new FieldData(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 1066 matching lines @@
     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));
+      _memberData.add(new FunctionData(
+          node,
+          node.function,
+          new SpecialMemberDefinition(
+              data.constructorBody, node, MemberKind.constructorBody)));
     }
     return data.constructorBody;
   }
 
   ConstructorBodyEntity createConstructorBody(
       int memberIndex, ConstructorEntity constructor);
 
   @override
-  ir.Member getMemberNode(MemberEntity member) {
-    return _getMemberNode(member);
+  MemberDefinition getMemberDefinition(MemberEntity member) {
+    return _getMemberDefinition(member);
   }
 
   @override
-  ir.Class getClassNode(ClassEntity cls) {
-    return _getClassNode(cls);
+  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) {
@@ skipping 28 matching lines @@
       if (data.constructorBody != null) {
         f(data.constructorBody);
       }
     });
   }
 
   String getDeferredUri(ir.LibraryDependency node) {
     throw new UnimplementedError('JsKernelToElementMap.getDeferredUri');
   }
 }