Add Class/MemberDefinition to handle synthesized classes/members

pkg/compiler/lib/src/js_model/closure.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 '../common/tasks.dart';
 import '../elements/entities.dart';
 import '../kernel/element_map.dart';
 import '../world.dart';
 import 'elements.dart';
 import 'closure_visitors.dart';
 import 'locals.dart';
 
 /// Closure conversion code using our new Entity model. Closure conversion is
 /// necessary because the semantics of closures are slightly different in Dart
@@ skipping 41 matching lines @@
   void convertClosures(Iterable<MemberEntity> processedEntities,
       ClosedWorldRefiner closedWorldRefiner) {
     var closuresToGenerate = <ir.TreeNode, ScopeInfo>{};
     processedEntities.forEach((MemberEntity kEntity) {
       MemberEntity entity = kEntity;
       if (_kToJElementMap != null) {
         entity = _kToJElementMap.toBackendMember(kEntity);
       }
       if (entity.isAbstract) return;
       if (entity.isField && !entity.isInstanceMember) {
-        ir.Field field = _elementMap.getMemberNode(entity);
+        MemberDefinition definition = _elementMap.getMemberDefinition(entity);
+        assert(definition.kind == MemberKind.regular,
+            failedAt(entity, "Unexpected member definition $definition"));
+        ir.Field field = definition.node;
         // Skip top-level/static fields without an initializer.
         if (field.initializer == null) return;
       }
       _buildClosureModel(entity, closuresToGenerate, closedWorldRefiner);
     });
 
     for (ir.TreeNode node in closuresToGenerate.keys) {
       _produceSyntheticElements(
           node, closuresToGenerate[node], closedWorldRefiner);
     }
   }
 
   /// Inspect members and mark if those members capture any state that needs to
   /// be marked as free variables.
   void _buildClosureModel(
       MemberEntity entity,
       Map<ir.TreeNode, ScopeInfo> closuresToGenerate,
       ClosedWorldRefiner closedWorldRefiner) {
     if (_scopeMap.keys.contains(entity)) return;
-    ir.Node node = _elementMap.getMemberNode(entity);
+    MemberDefinition definition = _elementMap.getMemberDefinition(entity);
+    switch (definition.kind) {
+      case MemberKind.regular:
+      case MemberKind.constructor:
+        break;
+      default:
+        failedAt(entity, "Unexpected member definition $definition");
+    }
+    ir.Node node = definition.node;
     if (_scopesCapturedInClosureMap.keys.contains(node)) return;
     CapturedScopeBuilder translator = new CapturedScopeBuilder(
         _scopesCapturedInClosureMap,
         _scopeMap,
         entity,
         closuresToGenerate,
         _globalLocalsMap.getLocalsMap(entity),
         _elementMap);
     if (entity.isField) {
       if (node is ir.Field && node.initializer != null) {
         translator.translateLazyInitializer(node);
       }
     } else {
       assert(node is ir.Procedure || node is ir.Constructor);
       translator.translateConstructorOrProcedure(node);
     }
   }
 
   /// Given what variables are captured at each point, construct closure classes
   /// with fields containing the captured variables to replicate the Dart
   /// closure semantics in JS.
   void _produceSyntheticElements(
       ir.TreeNode /* ir.Field | ir.FunctionNode */ node,
       ScopeInfo info,
       ClosedWorldRefiner closedWorldRefiner) {
     Entity entity;
     KernelClosureClass closureClass =
-        new KernelClosureClass.fromScopeInfo(info);
+        new KernelClosureClass.fromScopeInfo(info, node.location);
     if (node is ir.FunctionNode) {
       // We want the original declaration where that function is used to point
       // to the correct closure class.
       // TODO(efortuna): entity equivalent of element.declaration?
       node = (node as ir.FunctionNode).parent;
       _closureRepresentationMap[closureClass.callMethod] = closureClass;
     }
 
     if (node is ir.Member) {
       entity = _elementMap.getMember(node);
@@ skipping 18 matching lines @@
       ConstructorBodyEntity constructorBody = entity;
       entity = constructorBody.constructor;
     }
 
     return _scopeMap[entity] ?? getClosureRepresentationInfo(entity);
   }
 
   // TODO(efortuna): Eventually scopesCapturedInClosureMap[node] should always
   // be non-null, and we should just test that with an assert.
   @override
-  CapturedScope getCapturedScope(MemberEntity entity) =>
-      _scopesCapturedInClosureMap[_elementMap.getMemberNode(entity)] ??
-      const CapturedScope();
+  CapturedScope getCapturedScope(MemberEntity entity) {
+    MemberDefinition definition = _elementMap.getMemberDefinition(entity);
+    switch (definition.kind) {
+      case MemberKind.regular:
+      case MemberKind.constructor:
+      case MemberKind.constructorBody:
+        return _scopesCapturedInClosureMap[definition.node] ??
+            const CapturedScope();
+      default:
+        throw failedAt(entity, "Unexpected member definition $definition");
+    }
+  }
 
   @override
   // TODO(efortuna): Eventually scopesCapturedInClosureMap[node] should always
   // be non-null, and we should just test that with an assert.
   CapturedLoopScope getCapturedLoopScope(ir.Node loopNode) =>
       _scopesCapturedInClosureMap[loopNode] ?? const CapturedLoopScope();
 
   @override
   // TODO(efortuna): Eventually closureRepresentationMap[node] should always be
   // non-null, and we should just test that with an assert.
@@ skipping 59 matching lines @@
   KernelCapturedLoopScope(Set<Local> boxedVariables, this.boxedLoopVariables,
       Local context, Local thisLocal)
       : super(boxedVariables, context, thisLocal);
 
   bool get hasBoxedLoopVariables => boxedLoopVariables.isNotEmpty;
 }
 
 // TODO(johnniwinther): Add unittest for the computed [ClosureClass].
 class KernelClosureClass extends KernelScopeInfo
     implements ClosureRepresentationInfo, JClass {
+  final ir.Location location;
+
   // TODO(efortuna): Generate unique name for each closure class.
   final String name = 'ClosureClass';
 
   /// Index into the classData, classList and classEnvironment lists where this
   /// entity is stored in [JsToFrontendMapImpl].
   int classIndex;
 
   final Map<Local, JField> localToFieldMap = new Map<Local, JField>();
 
-  KernelClosureClass.fromScopeInfo(KernelScopeInfo info)
+  KernelClosureClass.fromScopeInfo(KernelScopeInfo info, this.location)
       : super.from(info.thisLocal, info);
 
   // TODO(efortuna): Implement.
   Local get closureEntity => null;
 
   ClassEntity get closureClassEntity => this;
 
   // TODO(efortuna): Implement.
   FunctionEntity get callMethod => null;
 
@@ skipping 23 matching lines @@
   // that (and the subsequent adjustment here) will follow soon.
   bool get isClosure => false;
 
   bool get isAbstract => false;
 
   // TODO(efortuna): Talk to Johnni.
   JLibrary get library => null;
 
   String toString() => '${jsElementPrefix}class($name)';
 }
+
+class ClosureClassDefinition implements ClassDefinition {
+  final ClassEntity cls;
+  final ir.Location location;
+
+  ClosureClassDefinition(this.cls, this.location);
+
+  ClassKind get kind => ClassKind.closure;
+
+  ir.Node get node =>
+      throw new UnsupportedError('ClosureClassDefinition.node for $cls');
+
+  String toString() =>
+      'ClosureClassDefinition(kind:$kind,cls:$cls,location:$location)';
+}