dart2js cps: Remove dart2dart from cps pipeline and clean up.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, 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.
 
 library dart2js.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 22 matching lines @@
  * used in the rest of the compilation. This is ensured by setting the element's
  * cached tree to `null` and also breaking the token stream to crash future
  * attempts to parse.
  *
  * The type inferrer works on either IR nodes or tree nodes. The IR nodes are
  * then translated into the SSA form for optimizations and code generation.
  * Long-term, once the IR supports the full language, the backend can be
  * re-implemented to work directly on the IR.
  */
 class IrBuilderTask extends CompilerTask {
-  final Map<Element, ir.RootNode> nodes = <Element, ir.RootNode>{};
+  final Map<Element, ir.FunctionDefinition> nodes =
+      <Element, ir.FunctionDefinition>{};
   final SourceInformationFactory sourceInformationFactory;
 
   String bailoutMessage = null;
 
   IrBuilderTask(Compiler compiler, this.sourceInformationFactory)
       : super(compiler);
 
   String get name => 'IR builder';
 
   bool hasIr(Element element) => nodes.containsKey(element.implementation);
 
-  ir.RootNode getIr(ExecutableElement element) {
+  ir.FunctionDefinition getIr(ExecutableElement element) {
     return nodes[element.implementation];
   }
 
-  ir.RootNode buildNode(AstElement element) {
+  ir.FunctionDefinition buildNode(AstElement element) {
     return measure(() => _buildNode(element));
   }
 
-  ir.RootNode _buildNode(AstElement element) {
+  ir.FunctionDefinition _buildNode(AstElement element) {
     bailoutMessage = null;
-    if (!canBuild(element)) {
-      bailoutMessage = 'unsupported element ${element.name}:${element.kind}';
-      return null;
-    }
 
     TreeElements elementsMapping = element.resolvedAst.elements;
     element = element.implementation;
     return compiler.withCurrentElement(element, () {
       SourceInformationBuilder sourceInformationBuilder =
           sourceInformationFactory.forContext(element);
 
       IrBuilderVisitor builder =
-          compiler.backend is JavaScriptBackend
-          ? new JsIrBuilderVisitor(
-              elementsMapping, compiler, sourceInformationBuilder)
-          : new DartIrBuilderVisitor(
+          new JsIrBuilderVisitor(
               elementsMapping, compiler, sourceInformationBuilder);
-      ir.RootNode irNode = builder.buildExecutable(element);
+      ir.FunctionDefinition irNode = builder.buildExecutable(element);
       if (irNode == null) {
         bailoutMessage = builder.bailoutMessage;
       } else {
         nodes[element] = irNode;
       }
       return irNode;
     });
   }
 
   void buildNodes() {
     measure(() {
       Set<Element> resolved = compiler.enqueuer.resolution.resolvedElements;
       resolved.forEach(buildNode);
     });
   }
 
-  bool canBuild(Element element) {
-    // If using JavaScript backend, don't try to bail out early.
-    if (compiler.backend is JavaScriptBackend) return true;
-
-    if (element is TypedefElement) return false;
-    if (element is FunctionElement) {
-      // TODO(sigurdm): Support native functions for dart2js.
-      assert(invariant(element, !element.isNative));
-
-      if (element is ConstructorElement) {
-        if (!element.isGenerativeConstructor) {
-          // TODO(kmillikin,sigurdm): Support constructors.
-          return false;
-        }
-        if (element.isSynthesized) {
-          // Do generate CPS for synthetic constructors.
-          return true;
-        }
-      }
-    } else if (element is! FieldElement) {
-      compiler.internalError(element, "Unexpected element type $element");
-    }
-    return compiler.backend.shouldOutput(element);
-  }
-
   bool get inCheckedMode {
     bool result = false;
     assert((result = true));
     return result;
   }
 
 }
 
 /**
  * A tree visitor that builds [IrNodes]. The visit methods add statements using
@@ skipping 50 matching lines @@
 
   String bailoutMessage = null;
 
   @override
   ir.Primitive apply(ast.Node node, _) => node.accept(this);
 
   @override
   SemanticSendVisitor get sendVisitor => this;
 
   /**
-   * Builds the [ir.RootNode] for an executable element. In case the
+   * Builds the [ir.FunctionDefinition] for an executable element. In case the
    * function uses features that cannot be expressed in the IR, this element
    * returns `null`.
    */
-  ir.RootNode buildExecutable(ExecutableElement element);
+  ir.FunctionDefinition buildExecutable(ExecutableElement element);
 
   ClosureClassMap get closureClassMap;
   ClosureScope getClosureScopeForNode(ast.Node node);
   ClosureEnvironment getClosureEnvironment();
 
   /// Normalizes the argument list to a static invocation (i.e. where the target
   /// element is known).
   ///
   /// For the JS backend, inserts default arguments and normalizes order of
   /// named arguments.
@@ skipping 32 matching lines @@
       return newSelector;
     }
   }
 
   /// Like [useSelectorType], except the original typed selector is obtained
   /// from the [node].
   Selector useSelectorTypeOfNode(Selector newSelector, ast.Send node) {
     return useSelectorType(newSelector, elements.getSelector(node));
   }
 
-  ir.RootNode _makeFunctionBody(FunctionElement element,
-                                ast.FunctionExpression node) {
+  ir.FunctionDefinition _makeFunctionBody(FunctionElement element,
+                                          ast.FunctionExpression node) {
     FunctionSignature signature = element.functionSignature;
     List<ParameterElement> parameters = [];
     signature.orderedForEachParameter(parameters.add);
 
     irBuilder.buildFunctionHeader(parameters,
                                   closureScope: getClosureScopeForNode(node),
                                   env: getClosureEnvironment());
 
-    List<ConstantExpression> defaults = new List<ConstantExpression>();
-    signature.orderedOptionalParameters.forEach((ParameterElement element) {
-      defaults.add(getConstantForVariable(element));
-    });
-
-    List<ir.Initializer> initializers;
-    if (element.isSynthesized) {
-      assert(element is ConstructorElement);
-      return irBuilder.makeConstructorDefinition(const <ConstantExpression>[],
-          const <ir.Initializer>[]);
-    } else if (element.isGenerativeConstructor) {
-      if (element.isExternal) {
-        return irBuilder.makeAbstractConstructorDefinition(defaults);
-      } else {
-        initializers = buildConstructorInitializers(node, element);
-        visit(node.body);
-        return irBuilder.makeConstructorDefinition(defaults, initializers);
-      }
-    } else {
-      visit(node.body);
-      return irBuilder.makeFunctionDefinition(defaults);
-    }
-  }
-
-  List<ir.Initializer> buildConstructorInitializers(
-      ast.FunctionExpression function, ConstructorElement element) {
-    List<ir.Initializer> result = <ir.Initializer>[];
-    FunctionSignature signature = element.functionSignature;
-
-    void tryAddInitializingFormal(ParameterElement parameterElement) {
-      if (parameterElement.isInitializingFormal) {
-        InitializingFormalElement initializingFormal = parameterElement;
-        withBuilder(irBuilder.makeInitializerBuilder(), () {
-          ir.Primitive value =
-              irBuilder.buildLocalVariableGet(parameterElement);
-          result.add(irBuilder.makeFieldInitializer(
-              initializingFormal.fieldElement,
-              irBuilder.makeBody(value)));
-        });
-      }
-    }
-
-    // TODO(sigurdm): Preserve initializing formals as initializing formals.
-    signature.orderedForEachParameter(tryAddInitializingFormal);
-
-    if (function.initializers == null) return result;
-    bool explicitSuperInitializer = false;
-    for(ast.Node initializer in function.initializers) {
-      if (initializer is ast.SendSet) {
-        // Field initializer.
-        FieldElement field = elements[initializer];
-        withBuilder(irBuilder.makeInitializerBuilder(), () {
-          ir.Primitive value = visit(initializer.arguments.head);
-          ir.Body body = irBuilder.makeBody(value);
-          result.add(irBuilder.makeFieldInitializer(field, body));
-        });
-      } else if (initializer is ast.Send) {
-        // Super or this initializer.
-        if (ast.Initializers.isConstructorRedirect(initializer)) {
-          giveup(initializer, "constructor redirect (this) initializer");
-        }
-        ConstructorElement constructor = elements[initializer].implementation;
-        Selector selector = elements.getSelector(initializer);
-        List<ir.Body> arguments =
-            initializer.arguments.mapToList((ast.Node argument) {
-          return withBuilder(irBuilder.makeInitializerBuilder(), () {
-            ir.Primitive value = visit(argument);
-            return irBuilder.makeBody(value);
-          });
-        });
-        result.add(irBuilder.makeSuperInitializer(constructor,
-                                                  arguments,
-                                                  selector));
-        explicitSuperInitializer = true;
-      } else {
-        compiler.internalError(initializer,
-                               "Unexpected initializer type $initializer");
-      }
-
-    }
-    if (!explicitSuperInitializer) {
-      // No super initializer found. Try to find the default constructor if
-      // the class is not Object.
-      ClassElement enclosingClass = element.enclosingClass;
-      if (!enclosingClass.isObject) {
-        ClassElement superClass = enclosingClass.superclass;
-        FunctionElement target = superClass.lookupDefaultConstructor();
-        if (target == null) {
-          compiler.internalError(superClass,
-              "No default constructor available.");
-        }
-        Selector selector = new Selector.callDefaultConstructor();
-        result.add(irBuilder.makeSuperInitializer(target,
-                                                  <ir.Body>[],
-                                                  selector));
-      }
-    }
-    return result;
+    visit(node.body);
+    return irBuilder.makeFunctionDefinition();
   }
 
   ir.Primitive visit(ast.Node node) => node.accept(this);
 
   // ## Statements ##
   visitBlock(ast.Block node) {
     irBuilder.buildBlock(node.statements.nodes, build);
   }
 
   ir.Primitive visitBreakStatement(ast.BreakStatement node) {
@@ skipping 1547 matching lines @@
       CallStructure callStructure, _) {
     List<ir.Primitive> args =
         translateDynamicArguments(arguments, callStructure);
     Name name = new Name(setter.name, setter.library);
     Selector selector = useSelectorTypeOfNode(
         new Selector(SelectorKind.CALL, name, callStructure),
         node);
     return buildInstanceNoSuchMethod(selector, args);
   }
 
-  ir.RootNode nullIfGiveup(ir.RootNode action()) {
+  ir.FunctionDefinition nullIfGiveup(ir.FunctionDefinition action()) {
     try {
       return action();
     } catch(e) {
       if (e == ABORT_IRNODE_BUILDER) {
         return null;
       }
       rethrow;
     }
   }
 
@@ skipping 166 matching lines @@
         // In the closure conversion pass we check for isInitializingFormal,
         // but I'm not sure it can arise.
         assert(!local.isInitializingFormal);
         tryNestingStack.last.declared.add(local);
       }
     }
     node.visitChildren(this);
   }
 }
 
-/// IR builder specific to the Dart backend, coupled to the [DartIrBuilder].
-class DartIrBuilderVisitor extends IrBuilderVisitor {
-  /// Promote the type of [irBuilder] to [DartIrBuilder].
-  DartIrBuilder get irBuilder => super.irBuilder;
-
-  DartIrBuilderVisitor(TreeElements elements,
-                       Compiler compiler,
-                       SourceInformationBuilder sourceInformationBuilder)
-      : super(elements, compiler, sourceInformationBuilder);
-
-  DartIrBuilder makeIRBuilder(ExecutableElement element,
-                              Set<Local> capturedVariables) {
-    return new DartIrBuilder(compiler.backend.constantSystem,
-                             element,
-                             capturedVariables);
-  }
-
-  DartCapturedVariables _analyzeCapturedVariables(ExecutableElement element,
-                                                  ast.Node node) {
-    DartCapturedVariables variables = new DartCapturedVariables(elements);
-    if (!element.isSynthesized) {
-      try {
-        variables.analyze(node);
-      } catch (e) {
-        bailoutMessage = variables.bailoutMessage;
-        rethrow;
-      }
-    }
-    return variables;
-  }
-
-  /// Recursively builds the IR for the given nested function.
-  ir.FunctionDefinition makeSubFunction(ast.FunctionExpression node) {
-    FunctionElement element = elements[node];
-    assert(invariant(element, element.isImplementation));
-
-    IrBuilder builder = irBuilder.makeInnerFunctionBuilder(element);
-
-    return withBuilder(builder, () => _makeFunctionBody(element, node));
-  }
-
-  ir.Primitive visitFunctionExpression(ast.FunctionExpression node) {
-    return irBuilder.buildFunctionExpression(makeSubFunction(node));
-  }
-
-  visitFunctionDeclaration(ast.FunctionDeclaration node) {
-    LocalFunctionElement element = elements[node.function];
-    Object inner = makeSubFunction(node.function);
-    irBuilder.declareLocalFunction(element, inner);
-  }
-
-  ClosureClassMap get closureClassMap => null;
-  ClosureScope getClosureScopeForNode(ast.Node node) => null;
-  ClosureEnvironment getClosureEnvironment() => null;
-
-  ir.RootNode buildExecutable(ExecutableElement element) {
-    return nullIfGiveup(() {
-      ir.RootNode root;
-      if (element is FieldElement) {
-        root = buildField(element);
-      } else if (element is FunctionElement || element is ConstructorElement) {
-        root = buildFunction(element);
-      } else {
-        compiler.internalError(element, "Unexpected element type $element");
-      }
-      new CleanupPass().visit(root);
-      return root;
-    });
-  }
-
-  /// Returns a [ir.FieldDefinition] describing the initializer of [element].
-  ir.FieldDefinition buildField(FieldElement element) {
-    assert(invariant(element, element.isImplementation));
-    ast.VariableDefinitions definitions = element.node;
-    ast.Node fieldDefinition = definitions.definitions.nodes.first;
-    if (definitions.modifiers.isConst) {
-      // TODO(sigurdm): Just return const value.
-    }
-    assert(fieldDefinition != null);
-    assert(elements[fieldDefinition] != null);
-
-    DartCapturedVariables variables =
-        _analyzeCapturedVariables(element, fieldDefinition);
-    tryStatements = variables.tryStatements;
-    IrBuilder builder = makeIRBuilder(element, variables.capturedVariables);
-
-    return withBuilder(builder, () {
-      builder.buildFieldInitializerHeader(
-          closureScope: getClosureScopeForNode(fieldDefinition));
-      ir.Primitive initializer;
-      if (fieldDefinition is ast.SendSet) {
-        ast.SendSet sendSet = fieldDefinition;
-        initializer = visit(sendSet.arguments.first);
-      }
-      return builder.makeFieldDefinition(initializer);
-    });
-  }
-
-  ir.RootNode buildFunction(FunctionElement element) {
-    assert(invariant(element, element.isImplementation));
-    ast.FunctionExpression node = element.node;
-    if (element.asyncMarker != AsyncMarker.SYNC) {
-      giveup(null, 'cannot handle async-await');
-    }
-
-    if (!element.isSynthesized) {
-      assert(node != null);
-      assert(elements[node] != null);
-    } else {
-      SynthesizedConstructorElementX constructor = element;
-      if (!constructor.isDefaultConstructor) {
-        giveup(null, 'cannot handle synthetic forwarding constructors');
-      }
-    }
-
-    DartCapturedVariables variables =
-        _analyzeCapturedVariables(element, node);
-    tryStatements = variables.tryStatements;
-    IrBuilder builder = makeIRBuilder(element, variables.capturedVariables);
-
-    return withBuilder(builder, () => _makeFunctionBody(element, node));
-  }
-
-  List<ir.Primitive> normalizeStaticArguments(
-      CallStructure callStructure,
-      FunctionElement target,
-      List<ir.Primitive> arguments) {
-    return arguments;
-  }
-
-  List<ir.Primitive> normalizeDynamicArguments(
-      CallStructure callStructure,
-      List<ir.Primitive> arguments) {
-    return arguments;
-  }
-
-  @override
-  ir.Primitive handleConstructorInvoke(
-      ast.NewExpression node,
-      ConstructorElement constructor,
-      DartType type,
-      ast.NodeList arguments,
-      CallStructure callStructure, _) {
-    List<ir.Primitive> arguments =
-        node.send.arguments.mapToList(visit, growable:false);
-    return irBuilder.buildConstructorInvocation(
-        constructor,
-        callStructure,
-        type,
-        arguments);
-  }
-
-  @override
-  ir.Primitive buildStaticNoSuchMethod(Selector selector,
-                                       List<ir.Primitive> arguments) {
-    return giveup(null, 'Static noSuchMethod');
-  }
-
-  @override
-  ir.Primitive buildInstanceNoSuchMethod(Selector selector,
-                                         List<ir.Primitive> arguments) {
-    return giveup(null, 'Instance noSuchMethod');
-  }
-
-  @override
-  ir.Primitive buildRuntimeError(String message) {
-    return giveup(null, 'Build runtime error: $message');
-  }
-
-  @override
-  ir.Primitive buildAbstractClassInstantiationError(ClassElement element) {
-    return giveup(null, 'Abstract class instantiation: ${element.name}');
-  }
-
-  ir.Primitive buildStaticFieldGet(FieldElement field, SourceInformation src) {
-    return irBuilder.buildStaticFieldLazyGet(field, src);
-  }
-}
-
 /// The [IrBuilder]s view on the information about the program that has been
 /// computed in resolution and and type interence.
 class GlobalProgramInformation {
   final Compiler _compiler;
   JavaScriptBackend get _backend => _compiler.backend;
 
   GlobalProgramInformation(this._compiler);
 
   /// Returns [true], if the analysis could not determine that the type
   /// arguments for the class [cls] are never used in the program.
@@ skipping 101 matching lines @@
             function,
             function.node,
             elements);
     closurelib.ClosureScope scope = map.capturingScopes[function.node];
     if (scope == null) return null;
     return new ClosureScope(scope.boxElement,
                             mapValues(scope.capturedVariables, getLocation),
                             scope.boxedLoopVariables);
   }
 
-  ir.RootNode buildExecutable(ExecutableElement element) {
+  ir.FunctionDefinition buildExecutable(ExecutableElement element) {
     return nullIfGiveup(() {
-      ir.RootNode root;
+      ir.FunctionDefinition root;
       switch (element.kind) {
         case ElementKind.GENERATIVE_CONSTRUCTOR:
           root = buildConstructor(element);
           break;
 
         case ElementKind.GENERATIVE_CONSTRUCTOR_BODY:
           root = buildConstructorBody(element);
           break;
 
         case ElementKind.FUNCTION:
@@ skipping 25 matching lines @@
     if (!backend.constants.lazyStatics.contains(element)) {
       return null; // Nothing to do.
     }
     closureClassMap =
         compiler.closureToClassMapper.computeClosureToClassMapping(
             element,
             element.node,
             elements);
     IrBuilder builder = getBuilderFor(element);
     return withBuilder(builder, () {
+      irBuilder.buildFunctionHeader(<Local>[]);
       ir.Primitive initialValue = visit(element.initializer);
       irBuilder.buildReturn(initialValue);
-      return irBuilder.makeLazyFieldInitializer();
+      return irBuilder.makeFunctionDefinition();
     });
   }
 
   /// Builds the IR for an [expression] taken from a different [context].
   ///
   /// Such expressions need to be compiled with a different [sourceFile] and
   /// [elements] mapping.
   ir.Primitive inlineExpression(AstElement context, ast.Expression expression) {
     JsIrBuilderVisitor visitor = new JsIrBuilderVisitor(
         context.resolvedAst.elements,
@@ skipping 115 matching lines @@
         List<ir.Primitive> bodyArguments = <ir.Primitive>[];
         for (Local param in getConstructorBodyParameters(bodyElement)) {
           bodyArguments.add(irBuilder.environment.lookup(param));
         }
         irBuilder.buildInvokeDirectly(bodyElement, instance, bodyArguments);
       }
 
       // --- step 4: return the created object ----
       irBuilder.buildReturn(instance);
 
-      return irBuilder.makeFunctionDefinition([]);
+      return irBuilder.makeFunctionDefinition();
     });
   }
 
   /// Evaluates all field initializers on [constructor] and all constructors
   /// invoked through `this()` or `super()` ("superconstructors").
   ///
   /// The resulting field values will be available in [fieldValues]. The values
   /// are not stored in any fields.
   ///
   /// This procedure assumes that the parameters to [constructor] are available
@@ skipping 263 matching lines @@
     // TODO(kmillikin): We should combine closure conversion and try/catch
     // variable analysis in some way.
     DartCapturedVariables variables = _analyzeCapturedVariables(node);
     tryStatements = variables.tryStatements;
     JsIrBuilder builder = getBuilderFor(body);
 
     return withBuilder(builder, () {
       irBuilder.buildConstructorBodyHeader(getConstructorBodyParameters(body),
                                            getClosureScopeForNode(node));
       visit(node.body);
-      return irBuilder.makeFunctionDefinition([]);
+      return irBuilder.makeFunctionDefinition();
     });
   }
 
   ir.FunctionDefinition buildFunction(FunctionElement element) {
     assert(invariant(element, element.isImplementation));
     ast.FunctionExpression node = element.node;
 
     assert(!element.isSynthesized);
     assert(node != null);
     assert(elements[node] != null);
@@ skipping 76 matching lines @@
     for (int i=0; i < callStructure.positionalArgumentCount; i++) {
       result.add(arguments[i]);
     }
     for (String argName in callStructure.getOrderedNamedArguments()) {
       int nameIndex = callStructure.namedArguments.indexOf(argName);
       int translatedIndex = callStructure.positionalArgumentCount + nameIndex;
       result.add(arguments[translatedIndex]);
     }
     return result;
   }
+
   @override
   ir.Primitive handleConstructorInvoke(
       ast.NewExpression node,
       ConstructorElement constructor,
       DartType type,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     List<ir.Primitive> arguments =
         node.send.arguments.mapToList(visit, growable:false);
@@ skipping 81 matching lines @@
     if (expression != null && expression is ir.LetPrim) {
       ir.Primitive primitive = expression.primitive;
       if (primitive is ir.NonTailThrow) {
         _remover.visit(expression);
         return new ir.Throw(primitive.value.definition);
       }
     }
     return expression;
   }
 
+  processFunctionDefinition(ir.FunctionDefinition node) {
+    node.body = replacementFor(node.body);
+  }
+
   processLetPrim(ir.LetPrim node) {
     node.body = replacementFor(node.body);
   }
 
   processLetCont(ir.LetCont node) {
     node.body = replacementFor(node.body);
   }
 
   processLetHandler(ir.LetHandler node) {
     node.body = replacementFor(node.body);
   }
 
   processLetMutable(ir.LetMutable node) {
     node.body = replacementFor(node.body);
   }
 
   processSetMutableVariable(ir.SetMutableVariable node) {
     node.body = replacementFor(node.body);
   }
 
-  processDeclareFunction(ir.DeclareFunction node) {
-    node.body = replacementFor(node.body);
-  }
-
   processSetField(ir.SetField node) {
     node.body = replacementFor(node.body);
   }
 
   processSetStatic(ir.SetStatic node) {
     node.body = replacementFor(node.body);
   }
 
   processContinuation(ir.Continuation node) {
     node.body = replacementFor(node.body);
   }
-
-  processBody(ir.Body node) {
-    node.body = replacementFor(node.body);
-  }
 }
 
 /// Visit a just-deleted subterm and unlink all [Reference]s in it.
 class RemovalVisitor extends ir.RecursiveVisitor {
   processReference(ir.Reference reference) {
     reference.unlink();
   }
 }