Overhaul tree IR visitor and rename IR classes.

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 23 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.ExecutableDefinition> nodes =
-      <Element, ir.ExecutableDefinition>{};
+  final Map<Element, ir.RootNode> nodes = <Element, ir.RootNode>{};
   final bool generateSourceMap;
 
   IrBuilderTask(Compiler compiler, {this.generateSourceMap: true})
       : super(compiler);
 
   String get name => 'IR builder';
 
   bool hasIr(Element element) => nodes.containsKey(element.implementation);
 
-  ir.ExecutableDefinition getIr(ExecutableElement element) {
+  ir.RootNode getIr(ExecutableElement element) {
     return nodes[element.implementation];
   }
 
-  ir.ExecutableDefinition buildNode(AstElement element) {
+  ir.RootNode buildNode(AstElement element) {
     if (!canBuild(element)) return null;
 
     TreeElements elementsMapping = element.resolvedAst.elements;
     element = element.implementation;
     return compiler.withCurrentElement(element, () {
       SourceInformationBuilder sourceInformationBuilder = generateSourceMap
           ? new PositionSourceInformationBuilder(element)
           : const SourceInformationBuilder();
 
       IrBuilderVisitor builder =
           compiler.backend is JavaScriptBackend
           ? new JsIrBuilderVisitor(
               elementsMapping, compiler, sourceInformationBuilder)
           : new DartIrBuilderVisitor(
               elementsMapping, compiler, sourceInformationBuilder);
-      ir.ExecutableDefinition definition =
-            builder.buildExecutable(element);
-      if (definition != null) {
-        nodes[element] = definition;
+      ir.RootNode irNode = builder.buildExecutable(element);
+      if (irNode != null) {
+        nodes[element] = irNode;
       }
-      return definition;
+      return irNode;
     });
   }
 
   void buildNodes() {
     measure(() {
       Set<Element> resolved = compiler.enqueuer.resolution.resolvedElements;
       resolved.forEach(buildNode);
     });
   }
 
@@ skipping 72 matching lines @@
   @override
   bulkHandleNode(ast.Node node, String message, _) => giveup(node, message);
 
   @override
   ir.Primitive apply(ast.Node node, _) => node.accept(this);
 
   @override
   SemanticSendVisitor get sendVisitor => this;
 
   /**
-   * Builds the [ir.ExecutableDefinition] for an executable element. In case the
+   * Builds the [ir.RootNode] for an executable element. In case the
    * function uses features that cannot be expressed in the IR, this element
    * returns `null`.
    */
-  ir.ExecutableDefinition buildExecutable(ExecutableElement element);
+  ir.RootNode buildExecutable(ExecutableElement element);
 
   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.
   ///
   /// For the Dart backend, returns [arguments].
   List<ir.Primitive> normalizeStaticArguments(
       CallStructure callStructure,
       FunctionElement target,
       List<ir.Primitive> arguments);
 
   /// Normalizes the argument list of a dynamic invocation (i.e. where the
   /// target element is unknown).
   ///
   /// For the JS backend, normalizes order of named arguments.
   ///
   /// For the Dart backend, returns [arguments].
   List<ir.Primitive> normalizeDynamicArguments(
       Selector selector,
       List<ir.Primitive> arguments);
 
-  ir.FunctionDefinition _makeFunctionBody(FunctionElement element,
-                                          ast.FunctionExpression node) {
+  ir.RootNode _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) {
@@ skipping 24 matching lines @@
     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.buildLocalGet(parameterElement);
           result.add(irBuilder.makeFieldInitializer(
               initializingFormal.fieldElement,
-              irBuilder.makeRunnableBody(value)));
+              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.RunnableBody body = irBuilder.makeRunnableBody(value);
+          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.RunnableBody> arguments =
+        List<ir.Body> arguments =
             initializer.arguments.mapToList((ast.Node argument) {
           return withBuilder(irBuilder.makeInitializerBuilder(), () {
             ir.Primitive value = visit(argument);
-            return irBuilder.makeRunnableBody(value);
+            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.RunnableBody>[],
+                                                  <ir.Body>[],
                                                   selector));
       }
     }
     return result;
   }
 
   ir.Primitive visit(ast.Node node) => node.accept(this);
 
   // ## Statements ##
   visitBlock(ast.Block node) {
@@ skipping 1425 matching lines @@
       arguments.add(visitLiteralString(part.string));
     }
     return irBuilder.buildStringConcatenation(arguments);
   }
 
   ir.Primitive translateConstant(ast.Node node) {
     assert(irBuilder.isOpen);
     return irBuilder.buildConstantLiteral(getConstantForNode(node));
   }
 
-  ir.ExecutableDefinition nullIfGiveup(ir.ExecutableDefinition action()) {
+  ir.RootNode nullIfGiveup(ir.RootNode action()) {
     try {
       return action();
     } catch(e, tr) {
       if (e == ABORT_IRNODE_BUILDER) {
         return null;
       }
       rethrow;
     }
   }
 
@@ skipping 189 matching lines @@
 
   visitFunctionDeclaration(ast.FunctionDeclaration node) {
     LocalFunctionElement element = elements[node.function];
     Object inner = makeSubFunction(node.function);
     irBuilder.declareLocalFunction(element, inner);
   }
 
   ClosureScope getClosureScopeForNode(ast.Node node) => null;
   ClosureEnvironment getClosureEnvironment() => null;
 
-  ir.ExecutableDefinition buildExecutable(ExecutableElement element) {
+  ir.RootNode buildExecutable(ExecutableElement element) {
     return nullIfGiveup(() {
       if (element is FieldElement) {
         return buildField(element);
-      } else if (element is FunctionElement) {
+      } else if (element is FunctionElement || element is ConstructorElement) {
         return buildFunction(element);
       } else {
         compiler.internalError(element, "Unexpected element type $element");
       }
     });
   }
 
   /// Returns a [ir.FieldDefinition] describing the initializer of [element].
   ir.FieldDefinition buildField(FieldElement element) {
     assert(invariant(element, element.isImplementation));
@@ skipping 12 matching lines @@
           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.FunctionDefinition buildFunction(FunctionElement element) {
+  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 {
@@ skipping 140 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.ExecutableDefinition buildExecutable(ExecutableElement element) {
+  ir.RootNode buildExecutable(ExecutableElement element) {
     return nullIfGiveup(() {
       switch (element.kind) {
         case ElementKind.GENERATIVE_CONSTRUCTOR:
           return buildConstructor(element);
 
         case ElementKind.GENERATIVE_CONSTRUCTOR_BODY:
           return buildConstructorBody(element);
 
         case ElementKind.FUNCTION:
         case ElementKind.GETTER:
@@ skipping 489 matching lines @@
   SourceInformation buildCall(ast.Node node) {
     return new PositionSourceInformation(
         new TokenSourceLocation(sourceFile, node.getBeginToken(), name));
   }
 
   @override
   SourceInformationBuilder forContext(AstElement element) {
     return new PositionSourceInformationBuilder(element);
   }
 }