Add Class/MemberDefinition to handle synthesized classes/members

pkg/compiler/lib/src/kernel/element_map.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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../constants/values.dart';
 import '../common_elements.dart';
@@ skipping 146 matching lines @@
 
 /// Interface that translates between Kernel IR nodes and entities used for
 /// global type inference and building the SSA graph for members.
 abstract class KernelToElementMapForBuilding implements KernelToElementMap {
   /// [ElementEnvironment] for library, class and member lookup.
   ElementEnvironment get elementEnvironment;
 
   /// Returns the list of [DartType]s corresponding to [types].
   List<DartType> getDartTypes(List<ir.DartType> types);
 
-  /// Returns the kernel IR node that defines the [member].
-  ir.Node getMemberNode(covariant MemberEntity member);
+  /// Returns the definition information for [member].
+  MemberDefinition getMemberDefinition(covariant MemberEntity member);
 
-  /// Returns the kernel IR node that defines the [cls].
-  ir.Class getClassNode(covariant ClassEntity cls);
+  /// Returns the definition information for [cls].
+  ClassDefinition getClassDefinition(covariant ClassEntity cls);
 
   /// Returns the [LibraryEntity] corresponding to the library [node].
   LibraryEntity getLibrary(ir.Library node);
 
   /// Returns the [js.Template] for the `JsBuiltin` [constant] value.
   js.Template getJsBuiltinTemplate(
       ConstantValue constant, CodeEmitterTask emitter);
 
   /// Return the [ConstantValue] the initial value of [field] or `null` if
   /// the initializer is not a constant expression.
   ConstantValue getFieldConstantValue(ir.Field field);
 
   /// Returns the `noSuchMethod` [FunctionEntity] call from a
   /// `super.noSuchMethod` invocation within [cls].
   FunctionEntity getSuperNoSuchMethod(ClassEntity cls);
 
   /// Returns a [Spannable] for a message pointing to the IR [node] in the
   /// context of [member].
   Spannable getSpannable(MemberEntity member, ir.Node node);
 
   /// Returns the constructor body entity corresponding to [constructor].
   FunctionEntity getConstructorBody(ir.Constructor node);
 
   /// Returns the uri for the deferred import [node].
   // TODO(johnniwinther): Avoid this method by deriving the uri directly from
   // the node.
   String getDeferredUri(ir.LibraryDependency node);
 }
 
+// TODO(johnniwinther,efortuna): Add more when needed.
+// TODO(johnniwinther): Should we split regular into method, field, etc.?
+enum MemberKind {
+  // A regular member defined by an [ir.Node].
+  regular,
+  // A constructor whose initializer is defined by an [ir.Constructor] node.
+  constructor,
+  // A constructor whose body is defined by an [ir.Constructor] node.
+  constructorBody,
+  // A closure class `call` method whose body is defined by an
+  // [ir.FunctionExpression].
+  closureCall,
+}
+
+/// Definition information for a [MemberEntity].
+abstract class MemberDefinition {
+  /// The defined member.
+  MemberEntity get member;
+
+  /// The kind of the defined member. This determines the semantics of [node].
+  MemberKind get kind;
+
+  /// The defining [ir.Node] for this member, if supported by its [kind].
+  ir.Node get node;
+
+  /// The canonical location of [member]. This is used for sorting the members
+  /// in the emitted code.
+  ir.Location get location;
+}
+
+enum ClassKind {
+  regular,
+  closure,
+}
+
+/// A member directly defined by its [ir.Member] node.
+class RegularMemberDefinition implements MemberDefinition {
+  final MemberEntity member;
+  final ir.Member node;
+
+  RegularMemberDefinition(this.member, this.node);
+
+  ir.Location get location => node.location;
+
+  MemberKind get kind => MemberKind.regular;
+
+  String toString() => 'RegularMemberDefinition(kind:$kind,member:$member,'
+      'node:$node,location:$location)';
+}
+
+/// The definition of a special kind of member
+class SpecialMemberDefinition implements MemberDefinition {
+  final MemberEntity member;
+  final ir.TreeNode node;
+  final MemberKind kind;
+
+  SpecialMemberDefinition(this.member, this.node, this.kind);
+
+  ir.Location get location => node.location;
+
+  String toString() => 'SpecialMemberDefinition(kind:$kind,member:$member,'
+      'node:$node,location:$location)';
+}
+
+/// Definition information for a [ClassEntity].
+abstract class ClassDefinition {
+  /// The defined class.
+  ClassEntity get cls;
+
+  /// The kind of the defined class. This determines the semantics of [node].
+  ClassKind get kind;
+
+  /// The defining [ir.Node] for this class, if supported by its [kind].
+  ir.Node get node;

[Emily Fortuna, 2017/07/19 21:38:58]

why not ir.Class here? Is this so that node can be a functionNode for closures?
If so, might want to just clarify that in the comment.

[Johnni Winther, 2017/07/21 07:47:57]

Done.

+
+  /// The canonical location of [cls]. This is used for sorting the classes
+  /// in the emitted code.
+  ir.Location get location;
+}
+
+/// A class directly defined by its [ir.Class] node.
+class RegularClassDefinition implements ClassDefinition {
+  final ClassEntity cls;
+  final ir.Class node;
+
+  RegularClassDefinition(this.cls, this.node);
+
+  ir.Location get location => node.location;
+
+  ClassKind get kind => ClassKind.regular;
+
+  String toString() => 'RegularClassDefinition(kind:$kind,cls:$cls,'
+      'node:$node,location:$location)';
+}
+
 /// Kinds of foreign functions.
 enum ForeignKind {
   JS,
   JS_BUILTIN,
   JS_EMBEDDED_GLOBAL,
   JS_INTERCEPTOR_CONSTANT,
   NONE,
 }
 
 /// Interface for type inference results for kernel IR nodes.
@@ skipping 108 matching lines @@
   /// [closureClassMaps].
   CapturedLoopScope getCapturedLoopScope(
       ClosureDataLookup closureLookup, ir.TreeNode node);
 }
 
 /// Comparator for the canonical order or named arguments.
 // TODO(johnniwinther): Remove this when named parameters are sorted in dill.
 int namedOrdering(ir.VariableDeclaration a, ir.VariableDeclaration b) {
   return a.name.compareTo(b.name);
 }