Add Class/MemberDefinition to handle synthesized classes/members

pkg/compiler/lib/src/ssa/builder_kernel.dart

 // Copyright (c) 2016, 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/codegen.dart' show CodegenRegistry;
 import '../common/names.dart';
@@ skipping 31 matching lines @@
 import 'locals_handler.dart';
 import 'loop_handler.dart';
 import 'nodes.dart';
 import 'ssa.dart';
 import 'ssa_branch_builder.dart';
 import 'switch_continue_analysis.dart';
 import 'type_builder.dart';
 
 class KernelSsaGraphBuilder extends ir.Visitor
     with GraphBuilder, SsaBuilderFieldMixin {
-  final ir.Node target;
   final MemberEntity targetElement;
 
   /// The root node of [targetElement]. This is used as the key into the
   /// [startFunction] of the locals handler.
   // TODO(johnniwinther,efortuna): Avoid the need for AST nodes in the locals
   // handler.
   final Node functionNode;
   final ClosedWorld closedWorld;
   final CodegenWorldBuilder _worldBuilder;
   final CodegenRegistry registry;
@@ skipping 34 matching lines @@
   final Map<ir.VariableDeclaration, HInstruction> letBindings =
       <ir.VariableDeclaration, HInstruction>{};
 
   /// True if we are visiting the expression of a throw statement; we assume
   /// this is a slow path.
   bool _inExpressionOfThrow = false;
 
   KernelSsaGraphBuilder(
       this.targetElement,
       ClassEntity contextClass,
-      this.target,
       this.compiler,
       this._elementMap,
       this._typeInferenceMap,
       this.localsMap,
       this.closedWorld,
       this._worldBuilder,
       this.registry,
       this.closureDataLookup,
       // TODO(het): Should sourceInformationBuilder be in GraphBuilder?
       this.sourceInformationBuilder,
       this.functionNode) {
     this.loopHandler = new KernelLoopHandler(this);
     typeBuilder = new TypeBuilder(this);
     graph.element = targetElement;
     graph.sourceInformation =
         sourceInformationBuilder.buildVariableDeclaration();
     this.localsHandler = new LocalsHandler(this, targetElement, targetElement,
         contextClass, null, nativeData, interceptorData);
     _targetStack.add(targetElement);
   }
 
   CommonElements get _commonElements => _elementMap.commonElements;
 
   HGraph build() {
     return reporter.withCurrentElement(localsMap.currentMember, () {
       // TODO(het): no reason to do this here...
       HInstruction.idCounter = 0;
-      if (target is ir.Procedure) {
-        _targetFunction = (target as ir.Procedure).function;
-        buildFunctionNode(_targetFunction);
-      } else if (target is ir.Field) {
-        if (handleConstantField(targetElement, registry, closedWorld)) {
-          // No code is generated for `targetElement`: All references inline the
-          // constant value.
-          return null;
-        } else if (targetElement.isStatic || targetElement.isTopLevel) {
-          backend.constants.registerLazyStatic(targetElement);
-        }
-        buildField(target);
-      } else if (target is ir.Constructor) {
-        if (targetElement is ConstructorBodyEntity) {
-          buildConstructorBody(target);
-        } else {
-          buildConstructor(target);
-        }
-      } else if (target is ir.FunctionExpression) {
-        _targetFunction = (target as ir.FunctionExpression).function;
-        buildFunctionNode(_targetFunction);
-      } else if (target is ir.FunctionDeclaration) {
-        _targetFunction = (target as ir.FunctionDeclaration).function;
-        buildFunctionNode(_targetFunction);
-      } else {
-        throw 'No case implemented to handle target: '
-            '$target for $targetElement';
+      MemberDefinition definition =
+          _elementMap.getMemberDefinition(targetElement);
+
+      switch (definition.kind) {
+        case MemberKind.regular:
+        case MemberKind.closureCall:
+          ir.Node target = definition.node;
+          if (target is ir.Procedure) {
+            _targetFunction = target.function;
+            buildFunctionNode(_targetFunction);
+          } else if (target is ir.Field) {
+            if (handleConstantField(targetElement, registry, closedWorld)) {
+              // No code is generated for `targetElement`: All references inline the
+              // constant value.
+              return null;
+            } else if (targetElement.isStatic || targetElement.isTopLevel) {
+              backend.constants.registerLazyStatic(targetElement);
+            }
+            buildField(target);
+          } else if (target is ir.FunctionExpression) {
+            _targetFunction = target.function;
+            buildFunctionNode(_targetFunction);
+          } else if (target is ir.FunctionDeclaration) {
+            _targetFunction = target.function;
+            buildFunctionNode(_targetFunction);
+          } else {
+            throw 'No case implemented to handle target: '
+                '$target for $targetElement';
+          }
+          break;
+        case MemberKind.constructor:
+          buildConstructor(definition.node);
+          break;
+        case MemberKind.constructorBody:
+          buildConstructorBody(definition.node);
+          break;
       }
       assert(graph.isValid());
       return graph;
     });
   }
 
   @override
   ConstantValue getFieldInitialConstantValue(FieldEntity field) {
     assert(field == targetElement);
-    return _elementMap.getFieldConstantValue(target);
+    MemberDefinition definition = _elementMap.getMemberDefinition(field);
+    assert(definition.kind == MemberKind.regular,
+        failedAt(field, "Unexpected member definition: $definition"));
+    return _elementMap.getFieldConstantValue(definition.node);
   }
 
   void buildField(ir.Field field) {
     openFunction();
     if (field.initializer != null) {
       field.initializer.accept(this);
       HInstruction fieldValue = pop();
       HInstruction checkInstruction = typeBuilder.potentiallyCheckOrTrustType(
           fieldValue, _getDartTypeIfValid(field.type));
       stack.add(checkInstruction);
@@ skipping 3334 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }