Overhaul tree IR visitor and rename IR classes.

pkg/compiler/lib/src/dart_backend/backend_ast_emitter.dart

 // Copyright (c) 2014, 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 backend_ast_emitter;
 
 import '../tree_ir/tree_ir_nodes.dart' as tree;
 import 'backend_ast_nodes.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart' as modelx;
 import '../universe/universe.dart';
 import '../tree/tree.dart' as tree show Modifiers;
 
 /// Translates the dart_tree IR to Dart backend AST.
-ExecutableDefinition emit(tree.ExecutableDefinition definition) {
-  return new ASTEmitter().emit(definition, new BuilderContext<Statement>());
+RootNode emit(tree.RootNode root) {
+  return new ASTEmitter().emit(root);
 }
 
 // TODO(johnniwinther): Split into function/block state.
 class BuilderContext<T> {
   /// Builder context for the enclosing function, or null if the current
   /// function is not a local function.
   BuilderContext<T> _parent;
 
   /// Variables to be hoisted at the top of the current function.
   final List<VariableDeclaration> variables = <VariableDeclaration>[];
@@ skipping 166 matching lines @@
 
   /// Add [statement] to the current block.
   void addStatement(T statement) {
     _statementBuffer.add(statement);
   }
 
   /// The statements in the current block.
   Iterable<T> get statements => _statementBuffer;
 }
 
-
 /// Translates the dart_tree IR to Dart backend AST.
 /// An instance of this class should only be used once; a fresh emitter
 /// must be created for each function to be emitted.
 class ASTEmitter
-    extends tree.Visitor1<dynamic, Expression, BuilderContext<Statement>> {
+  extends tree.StatementVisitor1<dynamic, BuilderContext<Statement>>
+     with tree.ExpressionVisitor1<Expression, BuilderContext<Statement>>,
+          tree.RootVisitor1<RootNode, BuilderContext<Statement>>,
+          tree.InitializerVisitor1<Initializer, BuilderContext<Statement>> {
 
-  ExecutableDefinition emit(tree.ExecutableDefinition definition,
-                            BuilderContext<Statement> context) {
-    if (definition is tree.FieldDefinition) {
-      return emitField(definition, context);
-    } else if (definition is tree.ConstructorDefinition) {
-      return emitConstructor(definition, context);
-    }
-    assert(definition is tree.FunctionDefinition);
-    return emitFunction(definition, context);
+  RootNode emit(tree.RootNode node) {
+    return visitRootNode(node, new BuilderContext<Statement>());
   }
 
-  FieldDefinition emitField(tree.FieldDefinition definition,
-                            BuilderContext<Statement> context) {
+  @override
+  FieldDefinition visitFieldDefinition(tree.FieldDefinition definition,
+                                       BuilderContext<Statement> context) {
     context.currentElement = definition.element;
     Expression initializer;
-    if (definition.hasInitializer) {
+    if (!definition.isEmpty) {
       visitStatement(definition.body, context);
       List<Statement> bodyParts;
       for (tree.Variable variable in context.variableNames.keys) {
         if (!context.declaredVariables.contains(variable)) {
           context.addDeclaration(variable);
         }
       }
       if (context.variables.length > 0) {
         bodyParts = new List<Statement>();
         bodyParts.add(new VariableDeclarations(context.variables));
@@ skipping 27 matching lines @@
   bool _recognizeTrailingReturn(Statement statement) {
     if (statement is Return) {
       Expression expr = statement.expression;
       if (expr == null || expr is Literal && expr.value.isNull) {
         return true;
       }
     }
     return false;
   }
 
-  FunctionExpression emitConstructor(tree.ConstructorDefinition definition,
-                                     BuilderContext<Statement> context) {
+  @override
+  FunctionExpression visitConstructorDefinition(
+        tree.ConstructorDefinition definition,
+        BuilderContext<Statement> context) {
     context.currentElement = definition.element;
 
-    Parameters parameters = emitRootParameters(definition, context);
+    Parameters parameters = emitRootParameters(
+        definition, definition.defaultParameterValues, context);
 
     // Declare parameters.
     for (tree.Variable param in definition.parameters) {
       context.variableNames[param] = param.element.name;
       context.usedVariableNames.add(param.element.name);
       context.declaredVariables.add(param);
     }
 
-    List<Expression> initializers;
+    List<Initializer> initializers;
     Statement body;
 
-    if (!definition.isAbstract) {
+    if (!definition.isEmpty) {
       initializers =
           definition.initializers.map((tree.Initializer initializer) {
-        return visitExpression(initializer, context);
+        return visitInitializer(initializer, context);
       }).toList();
 
       context.firstStatement = definition.body;
       visitStatement(definition.body, context);
       context.removeTrailingReturn(_recognizeTrailingReturn);
 
       // Some of the variable declarations have already been added
       // if their first assignment could be pulled into the initializer.
       // Add the remaining variable declarations now.
       for (tree.Variable variable in context.variableNames.keys) {
@@ skipping 31 matching lines @@
     FunctionType functionType = context.currentElement.type;
 
     return new ConstructorDefinition(
         parameters,
         body,
         initializers,
         context.currentElement.name, definition.element.isConst)
         ..element = context.currentElement;
   }
 
-  FunctionExpression emitFunction(tree.FunctionDefinition definition,
-                                  BuilderContext<Statement> context) {
+  @override
+  FunctionExpression visitFunctionDefinition(
+        tree.FunctionDefinition definition,
+        BuilderContext<Statement> context) {
     context.currentElement = definition.element;
 
-    Parameters parameters = emitRootParameters(definition, context);
+    Parameters parameters = emitRootParameters(
+        definition, definition.defaultParameterValues, context);
 
     // Declare parameters.
     for (tree.Variable param in definition.parameters) {
       context.variableNames[param] = param.element.name;
       context.usedVariableNames.add(param.element.name);
       context.declaredVariables.add(param);
     }
 
     Statement body;
-    if (definition.isAbstract) {
+    if (definition.isEmpty) {
       body = new EmptyStatement();
     } else {
       context.firstStatement = definition.body;
       visitStatement(definition.body, context);
       context.removeTrailingReturn(_recognizeTrailingReturn);
 
       // Some of the variable declarations have already been added
       // if their first assignment could be pulled into the initializer.
       // Add the remaining variable declarations now.
       for (tree.Variable variable in context.variableNames.keys) {
@@ skipping 35 matching lines @@
         body,
         name: context.currentElement.name,
         returnType: TypeGenerator.createOptionalType(functionType.returnType),
         isGetter: context.currentElement.isGetter,
         isSetter: context.currentElement.isSetter)
         ..element = context.currentElement;
   }
 
   /// Emits parameters that are not nested inside other parameters.
   /// Root parameters can have default values, while inner parameters cannot.
-  Parameters emitRootParameters(tree.FunctionDefinition function,
+  Parameters emitRootParameters(tree.RootNode function,
+                                List<ConstantExpression> defaults,
                                 BuilderContext<Statement> context) {
     FunctionType functionType = function.element.type;
     List<Parameter> required = TypeGenerator.createParameters(
         functionType.parameterTypes,
         context: context,
         elements: function.parameters.map((p) => p.element));
     bool optionalParametersAreNamed = !functionType.namedParameters.isEmpty;
     List<Parameter> optional = TypeGenerator.createParameters(
         optionalParametersAreNamed
             ? functionType.namedParameterTypes
             : functionType.optionalParameterTypes,
         context: context,
-        defaultValues: function.defaultParameterValues,
+        defaultValues: defaults,
         elements: function.parameters.skip(required.length)
             .map((p) => p.element));
     return new Parameters(required, optional, optionalParametersAreNamed);
   }
 
   /// True if the two expressions are a reference to the same variable.
   bool isSameVariable(Receiver e1, Receiver e2) {
     return e1 is Identifier &&
            e2 is Identifier &&
            e1.element is VariableElement &&
@@ skipping 429 matching lines @@
   }
 
   @override
   Expression visitVariableUse(tree.VariableUse exp,
                               BuilderContext<Statement> context) {
     return context.makeVariableAccess(exp.variable);
   }
 
   FunctionExpression makeSubFunction(tree.FunctionDefinition function,
                                      BuilderContext<Statement> context) {
-    return emit(function, new BuilderContext<Statement>.inner(context));
+    return visitFunctionDefinition(function,
+        new BuilderContext<Statement>.inner(context));
   }
 
   @override
   Expression visitFunctionExpression(tree.FunctionExpression exp,
                                      BuilderContext<Statement> context) {
     return makeSubFunction(exp.definition, context)..name = null;
   }
 
   @override
   void visitFunctionDeclaration(tree.FunctionDeclaration node,
@@ skipping 23 matching lines @@
       bodyParts = new List<Statement>();
       bodyParts.add(new VariableDeclarations(inner.variables));
       bodyParts.addAll(inner.statements);
     } else {
       bodyParts = inner.statements;
     }
     return bodyParts;
   }
 
   @override
-  Expression visitFieldInitializer(tree.FieldInitializer node,
+  Initializer visitFieldInitializer(tree.FieldInitializer node,
                                    BuilderContext<Statement> context) {
     return new FieldInitializer(node.element,
         ensureExpression(buildInInitializerContext(node.body, context)));
   }
 
   @override
-  Expression visitSuperInitializer(tree.SuperInitializer node,
+  Initializer visitSuperInitializer(tree.SuperInitializer node,
                                    BuilderContext<Statement> context) {
     List<Argument> arguments = node.arguments.map((tree.Statement argument) {
       return ensureExpression(buildInInitializerContext(argument, context));
     }).toList();
     return new SuperInitializer(node.target,
                                 emitArguments(arguments, node.selector));
   }
 
   @override
   Expression visitTypeExpression(tree.TypeExpression node, arg) {
@@ skipping 309 matching lines @@
 
   /// Maps parameter names to their bindings.
   Map<String, tree.Variable> environment = <String, tree.Variable>{};
 
   /// Parameters that are currently shadowed by another parameter.
   Set<tree.Variable> shadowedParameters = new Set<tree.Variable>();
 
   /// Parameters that are used in a context where it is shadowed.
   Set<tree.Variable> hasShadowedUse = new Set<tree.Variable>();
 
-  void unshadow(tree.ExecutableDefinition definition) {
-    // Fields have no parameters.
-    if (definition is tree.FieldDefinition) return;
-    visitFunctionDefinition(definition);
+  void unshadow(tree.RootNode definition) {
+    if (definition.isEmpty) return;
+    unshadowFunction(definition);
   }
 
-  visitFunctionDefinition(tree.FunctionDefinition definition) {
-    if (definition.isAbstract) return;
+  void unshadowFunction(tree.RootNode definition) {
     var oldShadow = shadowedParameters;
     var oldEnvironment = environment;
     environment = new Map<String, tree.Variable>.from(environment);
     shadowedParameters = new Set<tree.Variable>.from(shadowedParameters);
     for (tree.Variable param in definition.parameters) {
       tree.Variable oldVariable = environment[param.element.name];
       if (oldVariable != null) {
         shadowedParameters.add(oldVariable);
       }
       environment[param.element.name] = param;
     }
-    visitStatement(definition.body);
+    definition.forEachBody(visitStatement);
     environment = oldEnvironment;
     shadowedParameters = oldShadow;
 
     for (int i=0; i<definition.parameters.length; i++) {
       tree.Variable param = definition.parameters[i];
       if (hasShadowedUse.remove(param)) {
         tree.Variable newParam = new tree.Variable(definition.element,
             param.element);
         definition.parameters[i] = newParam;
-        definition.body = new tree.Assign(param, new tree.VariableUse(newParam),
-            definition.body);
+        definition.replaceEachBody((tree.Statement body) {
+          return new tree.Assign(param, new tree.VariableUse(newParam), body);
+        });
         newParam.writeCount = 1; // Being a parameter counts as a write.
         param.writeCount--; // Not a parameter anymore.
       }
     }
   }
 
   @override
+  void visitInnerFunction(tree.FunctionDefinition definition) {
+    unshadowFunction(definition);
+  }
+
+  @override
   visitVariable(tree.Variable variable) {
     if (shadowedParameters.contains(variable)) {
       hasShadowedUse.add(variable);
     }
   }
 
 }
 
 // TODO(johnniwinther): Remove this when the dart `backend_ast` does not need
 // [Element] for entities.
 class _SyntheticLocalVariableElement extends modelx.VariableElementX
     implements LocalVariableElement {
 
   _SyntheticLocalVariableElement(String name,
                                  ExecutableElement enclosingElement,
                                  modelx.VariableList variables)
       : super(name, ElementKind.VARIABLE, enclosingElement, variables, null);
 
   ExecutableElement get executableContext => enclosingElement;
 
   ExecutableElement get memberContext => executableContext.memberContext;
 
   bool get isLocal => true;
 
   LibraryElement get implementationLibrary => enclosingElement.library;
 }