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));
         }
       }
 
       // Provide the parameters to the generative constructor body.
       body.function.positionalParameters.forEach(handleParameter);
       body.function.namedParameters.toList()
         ..sort(namedOrdering)
         ..forEach(handleParameter);
 
       // If there are locals that escape (i.e. mutated in closures), we pass the
       // box to the constructor.
       ClosureScope scopeData =
           closureDataLookup.getClosureScope(constructorElement);
       if (scopeData.requiresContextBox) {
         bodyCallInputs.add(localsHandler.readLocal(scopeData.context));
       }
 
       // Pass type arguments.
       ir.Class currentClass = body.enclosingClass;
       if (backend.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);

[Siggi Cherem (dart-lang), 2017/07/07 20:00:25]

I think in this case we don't need the extra method in elementMap. We can get
the uri directly from the IR as follows:

  String uri = checkLoad.import.targetLibrary.importUri.toString();

Or even change the next line as well to get better types:

  Uri uri = checkLoad.import.targetLibrary.importUri;
  HInstruction uriConstant = graph.addConstantString('$uri', closedWorld);

[Johnni Winther, 2017/07/10 14:11:34]

They're not the same in rasta :(

Added a TODO on getDeferredUri to resolve this.

[Siggi Cherem (dart-lang), 2017/07/10 16:39:13]

mmm - what is the actual difference? Is it that we used to get the Uri as it
appeared in the import statement, but rasta is giving us the resolved Uri? If
so, I'm guessing that the future front-end will behave like rasta too. I'm
guessing the solution is to use the resolve Uri here as well, correct?

I agree with doing that on a separate CL, but I don't know if there is more to
it than just replacing one Uri for another.

[Johnni Winther, 2017/07/11 08:09:17]

One is relative and one is absolute.

I think long-term we will use the 'importUri' from .dill as the canonical
values.

+    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;
   }
 }