Support compilation of Hello World

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

 // Copyright (c) 2012, 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 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 1164 matching lines @@
       compiler.options.trustTypeAnnotations;
 
   /// Build the graph for [target].
   HGraph build() {
     assert(invariant(target, target.isImplementation));
     HInstruction.idCounter = 0;
     // TODO(sigmund): remove `result` and return graph directly, need to ensure
     // that it can never be null (see result in buildFactory for instance).
     var result;
     if (target.isGenerativeConstructor) {
-      result = buildFactory(target);
+      result = buildFactory(resolvedAst);
     } else if (target.isGenerativeConstructorBody ||
         target.isFactoryConstructor ||
         target.isFunction ||
         target.isGetter ||
         target.isSetter) {
       result = buildMethod(target);
     } else if (target.isField) {
       if (target.isInstanceMember) {
         assert(compiler.options.enableTypeAssertions);
         result = buildCheckedSetter(target);
@@ skipping 336 matching lines @@
             currentNode);
       }
       List<HInstruction> compiledArguments = completeSendArgumentsList(
           function, selector, providedArguments, currentNode);
       enterInlinedMethod(function, functionResolvedAst, compiledArguments,
           instanceType: instanceType);
       inlinedFrom(function, () {
         if (!isReachable) {
           emitReturn(graph.addConstantNull(compiler), null);
         } else {
-          doInline(function);
+          doInline(functionResolvedAst);
         }
       });
       leaveInlinedMethod();
     }
 
     if (meetsHardConstraints() && heuristicSayGoodToGo()) {
       doInlining();
       infoReporter?.reportInlined(element,
           inliningStack.isEmpty ? target : inliningStack.last.function);
       return true;
@@ skipping 213 matching lines @@
         sourceInformationBuilder.buildReturn(sendSet.assignmentOperator)));
     return closeFunction();
   }
 
   /**
    * Returns the constructor body associated with the given constructor or
    * creates a new constructor body, if none can be found.
    *
    * Returns [:null:] if the constructor does not have a body.
    */
-  ConstructorBodyElement getConstructorBody(FunctionElement constructor) {
+  ConstructorBodyElement getConstructorBody(
+      ResolvedAst constructorResolvedAst) {
+    ConstructorElement constructor =
+        constructorResolvedAst.element.implementation;
     assert(constructor.isGenerativeConstructor);
-    assert(invariant(constructor, constructor.isImplementation));
-    if (constructor.isSynthesized) return null;
-    ast.FunctionExpression node = constructor.node;
+    if (constructorResolvedAst.kind != ResolvedAstKind.PARSED) return null;
+
+    ast.FunctionExpression node = constructorResolvedAst.node;
     // If we know the body doesn't have any code, we don't generate it.
     if (!node.hasBody) return null;
     if (node.hasEmptyBody) return null;
     ClassElement classElement = constructor.enclosingClass;
     ConstructorBodyElement bodyElement;
     classElement.forEachBackendMember((Element backendMember) {
       if (backendMember.isGenerativeConstructorBody) {
         ConstructorBodyElement body = backendMember;
         if (body.constructor == constructor) {
           // TODO(kasperl): Find a way of stopping the iteration
@@ skipping 90 matching lines @@
     inTryStatement = state.inTryStatement;
     resolvedAst = state.oldResolvedAst;
     returnType = state.oldReturnType;
     assert(stack.isEmpty);
     stack = state.oldStack;
   }
 
   /**
    * Run this builder on the body of the [function] to be inlined.
    */
-  void visitInlinedFunction(FunctionElement function) {
-    potentiallyCheckInlinedParameterTypes(function);
+  void visitInlinedFunction(ResolvedAst resolvedAst) {
+    potentiallyCheckInlinedParameterTypes(resolvedAst.element.implementation);
 
-    if (function.isGenerativeConstructor) {
-      buildFactory(function);
+    if (resolvedAst.element.isGenerativeConstructor) {
+      buildFactory(resolvedAst);
     } else {
-      ast.FunctionExpression functionNode = function.node;
+      ast.FunctionExpression functionNode = resolvedAst.node;
       functionNode.body.accept(this);
     }
   }
 
   addInlinedInstantiation(DartType type) {
     if (type != null) {
       currentInlinedInstantiations.add(type);
     }
   }
 
@@ skipping 26 matching lines @@
       potentiallyCheckOrTrustType(argument, parameter.type);
     });
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [constructors] must contain only implementation elements.
    */
   void inlineSuperOrRedirect(
-      ConstructorElement callee,
+      ResolvedAst constructorRecolvedAst,
       List<HInstruction> compiledArguments,
-      List<FunctionElement> constructors,
+      List<ResolvedAst> constructorResolvedAsts,
       Map<Element, HInstruction> fieldValues,
       FunctionElement caller) {
-    callee = callee.implementation;
+    ConstructorElement callee = constructorRecolvedAst.element.implementation;
     reporter.withCurrentElement(callee, () {
-      constructors.add(callee);
+      constructorResolvedAsts.add(constructorRecolvedAst);
       ClassElement enclosingClass = callee.enclosingClass;
       if (backend.classNeedsRti(enclosingClass)) {
         // If [enclosingClass] needs RTI, we have to give a value to its
         // type parameters.
         ClassElement currentClass = caller.enclosingClass;
         // For a super constructor call, the type is the supertype of
         // [currentClass]. For a redirecting constructor, the type is
         // the current type. [InterfaceType.asInstanceOf] takes care
         // of both.
         InterfaceType type = currentClass.thisType.asInstanceOf(enclosingClass);
@@ skipping 50 matching lines @@
       // Build the initializers in the context of the new constructor.
       ResolvedAst oldResolvedAst = resolvedAst;
       resolvedAst = backend.frontend.getResolvedAst(callee);
       ClosureClassMap oldClosureData = localsHandler.closureData;
       ClosureClassMap newClosureData = compiler.closureToClassMapper
           .computeClosureToClassMapping(resolvedAst);
       localsHandler.closureData = newClosureData;
       if (resolvedAst.kind == ResolvedAstKind.PARSED) {
         localsHandler.enterScope(resolvedAst.node, callee);
       }
-      buildInitializers(callee, constructors, fieldValues);
+      buildInitializers(callee, constructorResolvedAsts, fieldValues);
       localsHandler.closureData = oldClosureData;
       resolvedAst = oldResolvedAst;
     });
   }
 
   void buildInitializers(
       ConstructorElement constructor,
-      List<FunctionElement> constructors,
+      List<ResolvedAst> constructorResolvedAsts,
       Map<Element, HInstruction> fieldValues) {
     assert(invariant(
         constructor, resolvedAst.element == constructor.declaration,
         message: "Expected ResolvedAst for $constructor, found $resolvedAst"));
     if (resolvedAst.kind == ResolvedAstKind.PARSED) {
-      buildParsedInitializers(constructor, constructors, fieldValues);
+      buildParsedInitializers(
+          constructor, constructorResolvedAsts, fieldValues);
     } else {
       buildSynthesizedConstructorInitializers(
-          constructor, constructors, fieldValues);
+          constructor, constructorResolvedAsts, fieldValues);
     }
   }
 
   void buildSynthesizedConstructorInitializers(
       ConstructorElement constructor,
-      List<FunctionElement> constructors,
+      List<ResolvedAst> constructorResolvedAsts,
       Map<Element, HInstruction> fieldValues) {
-    assert(invariant(constructor, constructor.isSynthesized));
+    assert(invariant(constructor, constructor.isSynthesized,
+        message: "Unexpected unsynthesized constructor: $constructor"));
     List<HInstruction> arguments = <HInstruction>[];
     HInstruction compileArgument(ParameterElement parameter) {
       return localsHandler.readLocal(parameter);
     }
 
     Element target = constructor.definingConstructor.implementation;
     bool match = !target.isMalformed &&
         CallStructure.addForwardingElementArgumentsToList(
             constructor,
             arguments,
             target,
             compileArgument,
             handleConstantForOptionalParameter);
     if (!match) {
       if (compiler.elementHasCompileTimeError(constructor)) {
         return;
       }
       // If this fails, the selector we constructed for the call to a
       // forwarding constructor in a mixin application did not match the
       // constructor (which, for example, may happen when the libraries are
       // not compatible for private names, see issue 20394).
       reporter.internalError(
           constructor, 'forwarding constructor call does not match');
     }
-    inlineSuperOrRedirect(
-        target, arguments, constructors, fieldValues, constructor);
+    inlineSuperOrRedirect(backend.frontend.getResolvedAst(target), arguments,
+        constructorResolvedAsts, fieldValues, constructor);
   }
 
   /**
    * Run through the initializers and inline all field initializers. Recursively
    * inlines super initializers.
    *
    * The constructors of the inlined initializers is added to [constructors]
    * with sub constructors having a lower index than super constructors.
    *
    * Invariant: The [constructor] and elements in [constructors] must all be
    * implementation elements.
    */
   void buildParsedInitializers(
       ConstructorElement constructor,
-      List<FunctionElement> constructors,
+      List<ResolvedAst> constructorResolvedAsts,
       Map<Element, HInstruction> fieldValues) {
+    assert(
+        invariant(constructor, resolvedAst.element == constructor.declaration));
     assert(invariant(constructor, constructor.isImplementation));
     assert(invariant(constructor, !constructor.isSynthesized,
         message: "Unexpected synthesized constructor: $constructor"));
-    ast.FunctionExpression functionNode = constructor.node;
+    ast.FunctionExpression functionNode = resolvedAst.node;
 
     bool foundSuperOrRedirect = false;
     if (functionNode.initializers != null) {
       Link<ast.Node> initializers = functionNode.initializers.nodes;
       for (Link<ast.Node> link = initializers;
           !link.isEmpty;
           link = link.tail) {
         assert(link.head is ast.Send);
         if (link.head is! ast.SendSet) {
           // A super initializer or constructor redirection.
           foundSuperOrRedirect = true;
           ast.Send call = link.head;
           assert(ast.Initializers.isSuperConstructorCall(call) ||
               ast.Initializers.isConstructorRedirect(call));
           FunctionElement target = elements[call].implementation;
           CallStructure callStructure =
               elements.getSelector(call).callStructure;
           Link<ast.Node> arguments = call.arguments;
           List<HInstruction> compiledArguments;
           inlinedFrom(constructor, () {
             compiledArguments =
                 makeStaticArgumentList(callStructure, arguments, target);
           });
-          inlineSuperOrRedirect(target, compiledArguments, constructors,
-              fieldValues, constructor);
+          inlineSuperOrRedirect(
+              backend.frontend.getResolvedAst(target.declaration),
+              compiledArguments,
+              constructorResolvedAsts,
+              fieldValues,
+              constructor);
         } else {
           // A field initializer.
           ast.SendSet init = link.head;
           Link<ast.Node> arguments = init.arguments;
           assert(!arguments.isEmpty && arguments.tail.isEmpty);
           inlinedFrom(constructor, () {
             visit(arguments.head);
           });
           fieldValues[elements[init]] = pop();
         }
@@ skipping 13 matching lines @@
         if (target == null) {
           reporter.internalError(
               superClass, "No default constructor available.");
         }
         List<HInstruction> arguments = CallStructure.NO_ARGS.makeArgumentsList(
             const Link<ast.Node>(),
             target.implementation,
             null,
             handleConstantForOptionalParameter);
         inlineSuperOrRedirect(
-            target, arguments, constructors, fieldValues, constructor);
+            backend.frontend.getResolvedAst(target.declaration),
+            arguments,
+            constructorResolvedAsts,
+            fieldValues,
+            constructor);
       }
     }
   }
 
   /**
    * Run through the fields of [cls] and add their potential
    * initializers.
    *
    * Invariant: [classElement] must be an implementation element.
    */
   void buildFieldInitializers(
       ClassElement classElement, Map<Element, HInstruction> fieldValues) {
     assert(invariant(classElement, classElement.isImplementation));
     classElement.forEachInstanceField(
-        (ClassElement enclosingClass, VariableElement member) {
+        (ClassElement enclosingClass, FieldElement member) {
       if (compiler.elementHasCompileTimeError(member)) return;
       reporter.withCurrentElement(member, () {
-        ast.Node node = member.node;
-        ast.Expression initializer = member.initializer;
+        ResolvedAst fieldResolvedAst = backend.frontend.getResolvedAst(member);
+        ast.Node node = fieldResolvedAst.node;
+        ast.Expression initializer = fieldResolvedAst.body;
         if (initializer == null) {
           // Unassigned fields of native classes are not initialized to
           // prevent overwriting pre-initialized native properties.
           if (!backend.isNativeOrExtendsNative(classElement)) {
             fieldValues[member] = graph.addConstantNull(compiler);
           }
         } else {
           ast.Node right = initializer;
           ResolvedAst savedResolvedAst = resolvedAst;
-          resolvedAst = backend.frontend.getResolvedAst(member);
+          resolvedAst = fieldResolvedAst;
           // In case the field initializer uses closures, run the
           // closure to class mapper.
           compiler.closureToClassMapper
               .computeClosureToClassMapping(resolvedAst);
           inlinedFrom(member, () => right.accept(this));
           resolvedAst = savedResolvedAst;
           fieldValues[member] = pop();
         }
       });
     });
   }
 
   /**
    * Build the factory function corresponding to the constructor
    * [functionElement]:
    *  - Initialize fields with the values of the field initializers of the
    *    current constructor and super constructors or constructors redirected
    *    to, starting from the current constructor.
    *  - Call the constructor bodies, starting from the constructor(s) in the
    *    super class(es).
    */
-  HGraph buildFactory(ConstructorElement functionElement) {
+  HGraph buildFactory(ResolvedAst resolvedAst) {
+    ConstructorElement functionElement = resolvedAst.element;
     functionElement = functionElement.implementation;
     ClassElement classElement = functionElement.enclosingClass.implementation;
     bool isNativeUpgradeFactory =
         backend.isNativeOrExtendsNative(classElement) &&
             !backend.isJsInterop(classElement);
-    ast.FunctionExpression function = functionElement.node;
+    ast.FunctionExpression function;
+    if (resolvedAst.kind == ResolvedAstKind.PARSED) {
+      function = resolvedAst.node;
+    }
+
     // Note that constructors (like any other static function) do not need
     // to deal with optional arguments. It is the callers job to provide all
     // arguments as if they were positional.
 
     if (inliningStack.isEmpty) {
       // The initializer list could contain closures.
       openFunction(functionElement, function);
     }
 
     Map<Element, HInstruction> fieldValues = new Map<Element, HInstruction>();
@@ skipping 12 matching lines @@
         // If the [element] is a field-parameter then
         // initialize the field element with its value.
         InitializingFormalElement fieldParameter = parameter;
         HInstruction parameterValue = localsHandler.readLocal(fieldParameter);
         fieldValues[fieldParameter.fieldElement] = parameterValue;
       }
     });
 
     // Analyze the constructor and all referenced constructors and collect
     // initializers and constructor bodies.
-    List<FunctionElement> constructors = <FunctionElement>[functionElement];
-    buildInitializers(functionElement, constructors, fieldValues);
+    List<ResolvedAst> constructorResolvedAsts = <ResolvedAst>[resolvedAst];
+    buildInitializers(functionElement, constructorResolvedAsts, fieldValues);
 
     // Call the JavaScript constructor with the fields as argument.
     List<HInstruction> constructorArguments = <HInstruction>[];
     List<Element> fields = <Element>[];
 
     classElement.forEachInstanceField(
         (ClassElement enclosingClass, VariableElement member) {
       HInstruction value = fieldValues[member];
       if (value == null) {
         // Uninitialized native fields are pre-initialized by the native
@@ skipping 108 matching lines @@
       if (source != null && allIndexed && remainingTypeVariables == 0) {
         copyRuntimeTypeInfo(source, newObject);
       } else {
         newObject =
             callSetRuntimeTypeInfo(classElement, typeArguments, newObject);
       }
     }
 
     // Generate calls to the constructor bodies.
     HInstruction interceptor = null;
-    for (int index = constructors.length - 1; index >= 0; index--) {
-      FunctionElement constructor = constructors[index];
-      assert(invariant(functionElement, constructor.isImplementation));
-      ConstructorBodyElement body = getConstructorBody(constructor);
+    for (int index = constructorResolvedAsts.length - 1; index >= 0; index--) {
+      ResolvedAst constructorResolvedAst = constructorResolvedAsts[index];
+      ConstructorBodyElement body = getConstructorBody(constructorResolvedAst);
       if (body == null) continue;
 
       List bodyCallInputs = <HInstruction>[];
       if (isNativeUpgradeFactory) {
         if (interceptor == null) {
           ConstantValue constant =
               new InterceptorConstantValue(classElement.thisType);
           interceptor = graph.addConstant(constant, compiler);
         }
         bodyCallInputs.add(interceptor);
       }
       bodyCallInputs.add(newObject);
-      ResolvedAst resolvedAst = backend.frontend.getResolvedAst(constructor);
-      ast.Node node = resolvedAst.node;
+      ast.Node node = constructorResolvedAst.node;
       ClosureClassMap parameterClosureData =
           compiler.closureToClassMapper.getMappingForNestedFunction(node);
 
       FunctionSignature functionSignature = body.functionSignature;
       // Provide the parameters to the generative constructor body.
       functionSignature.orderedForEachParameter((ParameterElement parameter) {
         // 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));
         }
       });
 
       // If there are locals that escape (ie mutated in closures), we
       // pass the box to the constructor.
       // The box must be passed before any type variable.
       ClosureScope scopeData = parameterClosureData.capturingScopes[node];
       if (scopeData != null) {
         bodyCallInputs.add(localsHandler.readLocal(scopeData.boxElement));
       }
 
       // Type variables arguments must come after the box (if there is one).
+      ConstructorElement constructor =
+          constructorResolvedAst.element.implementation;
       ClassElement currentClass = constructor.enclosingClass;
       if (backend.classNeedsRti(currentClass)) {
         // If [currentClass] needs RTI, we add the type variables as
         // parameters of the generative constructor body.
         currentClass.typeVariables.forEach((TypeVariableType argument) {
           // TODO(johnniwinther): Substitute [argument] with
           // `localsHandler.substInContext(argument)`.
           bodyCallInputs.add(localsHandler
               .readLocal(localsHandler.getTypeVariableAsLocal(argument)));
         });
@@ skipping 5484 matching lines @@
         instanceType: instanceType);
   }
 
   void leaveInlinedMethod() {
     HInstruction result = localsHandler.readLocal(returnLocal);
     AstInliningState state = inliningStack.removeLast();
     restoreState(state);
     stack.add(result);
   }
 
-  void doInline(FunctionElement function) {
-    visitInlinedFunction(function);
+  void doInline(ResolvedAst resolvedAst) {
+    visitInlinedFunction(resolvedAst);
   }
 
   void emitReturn(HInstruction value, ast.Node node) {
     if (inliningStack.isEmpty) {
       closeAndGotoExit(
           new HReturn(value, sourceInformationBuilder.buildReturn(node)));
     } else {
       localsHandler.updateLocal(returnLocal, value);
     }
   }
@@ skipping 647 matching lines @@
   const _LoopTypeVisitor();
   int visitNode(ast.Node node) => HLoopBlockInformation.NOT_A_LOOP;
   int visitWhile(ast.While node) => HLoopBlockInformation.WHILE_LOOP;
   int visitFor(ast.For node) => HLoopBlockInformation.FOR_LOOP;
   int visitDoWhile(ast.DoWhile node) => HLoopBlockInformation.DO_WHILE_LOOP;
   int visitAsyncForIn(ast.AsyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSyncForIn(ast.SyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSwitchStatement(ast.SwitchStatement node) =>
       HLoopBlockInformation.SWITCH_CONTINUE_LOOP;
 }