Add ConstructorBodyEntity

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';
 import '../common_elements.dart';
 import '../compiler.dart';
 import '../constants/values.dart'
     show
         ConstantValue,
         InterceptorConstantValue,
         StringConstantValue,
         TypeConstantValue;
-import '../elements/elements.dart';
+import '../elements/elements.dart' show ErroneousElement;
 import '../elements/entities.dart';
 import '../elements/jumps.dart';
-import '../elements/resolution_types.dart';
+import '../elements/resolution_types.dart'
+    show MalformedType, MethodTypeVariableType;
 import '../elements/types.dart';
 import '../io/source_information.dart';
 import '../js/js.dart' as js;
 import '../js_backend/backend.dart' show JavaScriptBackend;
 import '../kernel/element_map.dart';
 import '../native/native.dart' as native;
 import '../resolution/tree_elements.dart';
 import '../tree/nodes.dart' show Node;
 import '../types/masks.dart';
 import '../universe/selector.dart';
 import '../universe/side_effects.dart' show SideEffects;
 import '../universe/use.dart' show DynamicUse;
 import '../universe/world_builder.dart' show CodegenWorldBuilder;
 import '../world.dart';
 import 'graph_builder.dart';
 import 'jump_handler.dart';
 import 'kernel_ast_adapter.dart';
 import 'kernel_string_builder.dart';
 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 bool _targetIsConstructorBody;
   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 14 matching lines @@
   final List<InterfaceType> currentImplicitInstantiations = <InterfaceType>[];
 
   HInstruction rethrowableException;
 
   final Compiler compiler;
 
   @override
   JavaScriptBackend get backend => compiler.backend;
 
   @override
-  TreeElements get elements => astAdapter.elements;
+  TreeElements get elements =>
+      throw new UnsupportedError('KernelSsaGraphBuilder.elements');
 
   SourceInformationBuilder sourceInformationBuilder;
   final KernelToElementMapForBuilding _elementMap;
   final KernelToTypeInferenceMap _typeInferenceMap;
   final KernelToLocalsMap localsMap;
   LoopHandler<ir.Node> loopHandler;
   TypeBuilder typeBuilder;
 
   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,
-      {bool targetIsConstructorBody: false})
-      : this._targetIsConstructorBody = targetIsConstructorBody {
+      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);
   }
 
-  @deprecated // Use [_elementMap] instead.
-  KernelAstAdapter get astAdapter => _elementMap;
-
   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 (_targetIsConstructorBody) {
+        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);
@@ skipping 33 matching lines @@
     return _elementMap.getDartType(type);
   }
 
   /// Pops the most recent instruction from the stack and 'boolifies' it.
   ///
   /// Boolification is checking if the value is '=== true'.
   @override
   HInstruction popBoolified() {
     HInstruction value = pop();
     if (typeBuilder.checkOrTrustTypes) {
-      ResolutionInterfaceType type = commonElements.boolType;
+      InterfaceType type = commonElements.boolType;
       return typeBuilder.potentiallyCheckOrTrustType(value, type,
           kind: HTypeConversion.BOOLEAN_CONVERSION_CHECK);
     }
     HInstruction result = new HBoolify(value, commonMasks.boolType);
     add(result);
     return result;
   }
 
   /// Extend current method parameters with parameters for the class type
   /// parameters.  If the class has type parameters but does not need them, bind
@@ skipping 106 matching lines @@
 
     for (ir.Constructor body in constructorChain.reversed) {
       if (_isEmptyStatement(body.function.body)) continue;
 
       List<HInstruction> bodyCallInputs = <HInstruction>[];
       bodyCallInputs.add(newObject);
 
       // Pass uncaptured arguments first, captured arguments in a box, then type
       // arguments.
 
-      ConstructorElement constructorElement = _elementMap.getConstructor(body);
+      ConstructorEntity constructorElement = _elementMap.getConstructor(body);
 
       void handleParameter(ir.VariableDeclaration node) {
         Local parameter = localsMap.getLocal(node);
         // If [parameter] is boxed, it will be a field in the box passed as the
         // last parameter. So no need to directly pass it.
         if (!localsHandler.isBoxed(parameter)) {
           bodyCallInputs.add(localsHandler.readLocal(parameter));
         }
       }
 
@@ skipping 10 matching lines @@
       if (scopeData.requiresContextBox) {
         bodyCallInputs.add(localsHandler.readLocal(scopeData.context));
       }
 
       // Pass type arguments.
       ir.Class currentClass = body.enclosingClass;
       if (closedWorld.rtiNeed
           .classNeedsRti(_elementMap.getClass(currentClass))) {
         for (ir.DartType typeParameter in currentClass.thisType.typeArguments) {
           HInstruction argument = localsHandler.readLocal(localsHandler
-              .getTypeVariableAsLocal(_elementMap.getDartType(typeParameter)
-                  as ResolutionTypeVariableType));
+              .getTypeVariableAsLocal(_elementMap.getDartType(typeParameter)));
           bodyCallInputs.add(argument);
         }
       }
 
       _invokeConstructorBody(body, bodyCallInputs);
     }
 
     closeAndGotoExit(new HReturn(newObject, null));
     closeFunction();
   }
 
   static bool _isEmptyStatement(ir.Statement body) {
     if (body is ir.EmptyStatement) return true;
     if (body is ir.Block) return body.statements.every(_isEmptyStatement);
     return false;
   }
 
   void _invokeConstructorBody(
       ir.Constructor constructor, List<HInstruction> inputs) {
     // TODO(sra): Inline the constructor body.
-    MemberEntity constructorBody =
-        astAdapter.getConstructorBodyEntity(constructor);
+    MemberEntity constructorBody = _elementMap.getConstructorBody(constructor);
     HInvokeConstructorBody invoke = new HInvokeConstructorBody(
         constructorBody, inputs, commonMasks.nonNullType);
     add(invoke);
   }
 
   /// Sets context for generating code that is the result of inlining
   /// [inlinedTarget].
   inlinedFrom(MemberEntity inlinedTarget, f()) {
     reporter.withCurrentElement(inlinedTarget, () {
       SourceInformationBuilder oldSourceInformationBuilder =
@@ skipping 33 matching lines @@
     }
 
     return fieldValues;
   }
 
   /// Collects field initializers all the way up the inheritance chain.
   void _buildInitializers(
       ir.Constructor constructor,
       List<ir.Constructor> constructorChain,
       Map<FieldEntity, HInstruction> fieldValues) {
-    assert(_elementMap.getConstructor(constructor) == localsMap.currentMember);
+    assert(
+        _elementMap.getConstructor(constructor) == localsMap.currentMember,
+        failedAt(
+            localsMap.currentMember,
+            'Expected ${localsMap.currentMember} '
+            'but found ${_elementMap.getConstructor(constructor)}.'));
     constructorChain.add(constructor);
 
     var foundSuperOrRedirectCall = false;
     for (var initializer in constructor.initializers) {
       if (initializer is ir.FieldInitializer) {
         initializer.value.accept(this);
         fieldValues[_elementMap.getField(initializer.field)] = pop();
       } else if (initializer is ir.SuperInitializer) {
         assert(!foundSuperOrRedirectCall);
         foundSuperOrRedirectCall = true;
@@ skipping 146 matching lines @@
       parameters[parameter] = argument;
       localsHandler.updateLocal(parameter, argument);
     }
 
     constructor.function.positionalParameters.forEach(handleParameter);
     constructor.function.namedParameters.toList()
       ..sort(namedOrdering)
       ..forEach(handleParameter);
 
     // Set the locals handler state as if we were inlining the constructor.
-    ConstructorEntity astElement = _elementMap.getConstructor(constructor);
+    ConstructorEntity element = _elementMap.getConstructor(constructor);
     ClosureRepresentationInfo oldScopeInfo = localsHandler.scopeInfo;
     ClosureRepresentationInfo newScopeInfo =
-        closureDataLookup.getScopeInfo(astElement);
-    if (astElement is ConstructorElement) {
-      // TODO(redemption): Support constructor (body) entities.
-      ResolvedAst resolvedAst = astElement.resolvedAst;
-      localsHandler.scopeInfo = newScopeInfo;
-      if (resolvedAst.kind == ResolvedAstKind.PARSED) {
-        localsHandler.enterScope(closureDataLookup.getClosureScope(astElement),
-            forGenerativeConstructorBody:
-                astElement.isGenerativeConstructorBody);
-      }
-    }
-    inlinedFrom(astElement, () {
+        closureDataLookup.getScopeInfo(element);
+    localsHandler.scopeInfo = newScopeInfo;
+    localsHandler.enterScope(closureDataLookup.getClosureScope(element));
+    inlinedFrom(element, () {
       _buildInitializers(constructor, constructorChain, fieldValues);
     });
     localsHandler.scopeInfo = oldScopeInfo;
   }
 
   /// Builds generative constructor body.
   void buildConstructorBody(ir.Constructor constructor) {
     openFunction(constructor.function);
     _addClassTypeVariablesIfNeeded(constructor);
     constructor.function.body.accept(this);
@@ skipping 68 matching lines @@
     }
 
     HBasicBlock block = graph.addNewBlock();
     open(graph.entry);
 
     localsHandler.startFunction(
         targetElement,
         closureDataLookup.getScopeInfo(targetElement),
         closureDataLookup.getClosureScope(targetElement),
         parameterMap,
-        isGenerativeConstructorBody: _targetIsConstructorBody);
+        isGenerativeConstructorBody: targetElement is ConstructorBodyEntity);
     close(new HGoto()).addSuccessor(block);
 
     open(block);
   }
 
   void closeFunction() {
     if (!isAborted()) closeAndGotoExit(new HGoto());
     graph.finalize();
   }
 
@@ skipping 20 matching lines @@
     push(trap);
   }
 
   /// Returns the current source element. This is used by the type builder.
   ///
   /// The returned element is a declaration element.
   // TODO(efortuna): Update this when we implement inlining.
   // TODO(sra): Re-implement type builder using Kernel types and the
   // `target` for context.
   @override
-  MemberElement get sourceElement => _targetStack.last;
+  MemberEntity get sourceElement => _targetStack.last;
 
   List<MemberEntity> _targetStack = <MemberEntity>[];
 
   @override
   void visitCheckLibraryIsLoaded(ir.CheckLibraryIsLoaded checkLoad) {
     HInstruction prefixConstant =
         graph.addConstantString(checkLoad.import.name, closedWorld);
-    PrefixElement prefixElement = astAdapter.getElement(checkLoad.import);
-    HInstruction uriConstant = graph.addConstantString(
-        prefixElement.deferredImport.uri.toString(), closedWorld);
+    String uri = _elementMap.getDeferredUri(checkLoad.import);
+    HInstruction uriConstant = graph.addConstantString(uri, closedWorld);
     _pushStaticInvocation(
         _commonElements.checkDeferredIsLoaded,
         [prefixConstant, uriConstant],
         _typeInferenceMap
             .getReturnTypeOf(_commonElements.checkDeferredIsLoaded));
   }
 
   @override
   void visitLoadLibrary(ir.LoadLibrary loadLibrary) {
     // TODO(efortuna): Source information!
@@ skipping 584 matching lines @@
   void visitAsExpression(ir.AsExpression asExpression) {
     asExpression.operand.accept(this);
     HInstruction expressionInstruction = pop();
 
     if (asExpression.type is ir.InvalidType) {
       generateTypeError(asExpression, 'invalid type');
       stack.add(expressionInstruction);
       return;
     }
 
-    ResolutionDartType type = _elementMap.getDartType(asExpression.type);
+    DartType type = _elementMap.getDartType(asExpression.type);
     if (type.isMalformed) {
       if (type is MalformedType) {
         ErroneousElement element = type.element;
         generateTypeError(asExpression, element.message);
       } else {
         assert(type is MethodTypeVariableType);
         stack.add(expressionInstruction);
       }
     } else {
       HInstruction converted = typeBuilder.buildTypeConversion(
@@ skipping 710 matching lines @@
     ir.DartType type = typeLiteral.type;
     if (type is ir.InterfaceType || type is ir.DynamicType) {
       ConstantValue constant = _elementMap.getConstantValue(typeLiteral);
       stack.add(graph.addConstant(constant, closedWorld));
       return;
     }
     // For other types (e.g. TypeParameterType, function types from expanded
     // typedefs), look-up or construct a reified type representation and convert
     // to a RuntimeType.
 
-    // TODO(sra): Convert the type logic here to use ir.DartType.
-    ResolutionDartType dartType = _elementMap.getDartType(type);
+    DartType dartType = _elementMap.getDartType(type);
     dartType = localsHandler.substInContext(dartType);
     HInstruction value = typeBuilder
         .analyzeTypeArgument(dartType, sourceElement, sourceInformation: null);
     _pushStaticInvocation(_commonElements.runtimeTypeToString,
         <HInstruction>[value], commonMasks.stringType);
     _pushStaticInvocation(
         _commonElements.createRuntimeType,
         <HInstruction>[pop()],
         _typeInferenceMap.getReturnTypeOf(_commonElements.createRuntimeType));
   }
@@ skipping 1323 matching lines @@
     void pushCondition(ir.Catch catchBlock) {
       // `guard` is often `dynamic`, which generates `true`.
       kernelBuilder.pushIsTest(
           catchBlock.exception, catchBlock.guard, unwrappedException);
     }
 
     void visitThen() {
       ir.Catch catchBlock = tryCatch.catches[catchesIndex];
       catchesIndex++;
       if (catchBlock.exception != null) {
-        LocalVariableElement exceptionVariable =
+        Local exceptionVariable =
             kernelBuilder.localsMap.getLocal(catchBlock.exception);
         kernelBuilder.localsHandler
             .updateLocal(exceptionVariable, unwrappedException);
       }
       if (catchBlock.stackTrace != null) {
         kernelBuilder._pushStaticInvocation(
             kernelBuilder._commonElements.traceFromException,
             [exception],
             kernelBuilder._typeInferenceMap.getReturnTypeOf(
                 kernelBuilder._commonElements.traceFromException));
         HInstruction traceInstruction = kernelBuilder.pop();
-        LocalVariableElement traceVariable =
+        Local traceVariable =
             kernelBuilder.localsMap.getLocal(catchBlock.stackTrace);
         kernelBuilder.localsHandler
             .updateLocal(traceVariable, traceInstruction);
       }
       catchBlock.body.accept(kernelBuilder);
     }
 
     void visitElse() {
       if (catchesIndex >= tryCatch.catches.length) {
         kernelBuilder.closeAndGotoExit(new HThrow(
@@ skipping 40 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }