Extract BuilderContext from ASTEmitter

pkg/compiler/lib/src/constants/expressions.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 dart2js.constants.expressions;
 
 import '../dart2jslib.dart' show assertDebugMode;
 import '../dart_types.dart';
 import '../elements/elements.dart' show
     Element,
@@ skipping 238 matching lines @@
   accept(ConstantExpressionVisitor visitor, [context]) {
     return visitor.visitConditional(this, context);
   }
 
   int get precedence => 3;
 }
 
 abstract class ConstantExpressionVisitor<C, R> {
   const ConstantExpressionVisitor();
 
-  R visit(ConstantExpression constant, [C context]) {
+  R visit(ConstantExpression constant, C context) {
     return constant.accept(this, context);
   }
 
-  R visitPrimitive(PrimitiveConstantExpression exp, [C context]);
-  R visitList(ListConstantExpression exp, [C context]);
-  R visitMap(MapConstantExpression exp, [C context]);
-  R visitConstructed(ConstructedConstantExpresssion exp, [C context]);
-  R visitConcatenate(ConcatenateConstantExpression exp, [C context]);
-  R visitSymbol(SymbolConstantExpression exp, [C context]);
-  R visitType(TypeConstantExpression exp, [C context]);
-  R visitVariable(VariableConstantExpression exp, [C context]);
-  R visitFunction(FunctionConstantExpression exp, [C context]);
-  R visitBinary(BinaryConstantExpression exp, [C context]);
-  R visitUnary(UnaryConstantExpression exp, [C context]);
-  R visitConditional(ConditionalConstantExpression exp, [C context]);
+  R visitPrimitive(PrimitiveConstantExpression exp, C context);
+  R visitList(ListConstantExpression exp, C context);
+  R visitMap(MapConstantExpression exp, C context);
+  R visitConstructed(ConstructedConstantExpresssion exp, C context);
+  R visitConcatenate(ConcatenateConstantExpression exp, C context);
+  R visitSymbol(SymbolConstantExpression exp, C context);
+  R visitType(TypeConstantExpression exp, C context);
+  R visitVariable(VariableConstantExpression exp, C context);
+  R visitFunction(FunctionConstantExpression exp, C context);
+  R visitBinary(BinaryConstantExpression exp, C context);
+  R visitUnary(UnaryConstantExpression exp, C context);
+  R visitConditional(ConditionalConstantExpression exp, C context);
 }
 
 /// Represents the declaration of a constant [element] with value [expression].
 // TODO(johnniwinther): Where does this class belong?
 class ConstDeclaration {
   final VariableElement element;
   final ConstantExpression expression;
 
   ConstDeclaration(this.element, this.expression);
 }
 
 class ConstExpPrinter extends ConstantExpressionVisitor {
   final StringBuffer sb = new StringBuffer();
 
-  write(ConstantExpression parent,
+  void write(ConstantExpression parent,
         ConstantExpression child,
         {bool leftAssociative: true}) {
     if (child.precedence < parent.precedence ||
         !leftAssociative && child.precedence == parent.precedence) {
       sb.write('(');
       child.accept(this);
       sb.write(')');
     } else {
       child.accept(this);
     }
   }
 
-  writeTypeArguments(InterfaceType type) {
+  void writeTypeArguments(InterfaceType type) {
     if (type.treatAsRaw) return;
     sb.write('<');
     bool needsComma = false;
     for (DartType value in type.typeArguments) {
       if (needsComma) {
         sb.write(', ');
       }
       sb.write(value);
       needsComma = true;
     }
     sb.write('>');
   }
 
-  visitPrimitive(PrimitiveConstantExpression exp, [_]) {
+  @override
+  void visit(ConstantExpression constant, [_]) {
+    return constant.accept(this, null);
+  }
+
+  @override
+  void visitPrimitive(PrimitiveConstantExpression exp, [_]) {
     sb.write(exp.value.unparse());
   }
 
-  visitList(ListConstantExpression exp, [_]) {
+  @override
+  void visitList(ListConstantExpression exp, [_]) {
     sb.write('const ');
     writeTypeArguments(exp.type);
     sb.write('[');
     bool needsComma = false;
     for (ConstantExpression value in exp.values) {
       if (needsComma) {
         sb.write(', ');
       }
       visit(value);
       needsComma = true;
     }
     sb.write(']');
   }
 
-  visitMap(MapConstantExpression exp, [_]) {
+  @override
+  void visitMap(MapConstantExpression exp, [_]) {
     sb.write('const ');
     writeTypeArguments(exp.type);
     sb.write('{');
     for (int index = 0; index < exp.keys.length; index++) {
       if (index > 0) {
         sb.write(', ');
       }
       visit(exp.keys[index]);
       sb.write(': ');
       visit(exp.values[index]);
     }
     sb.write('}');
   }
 
-  visitConstructed(ConstructedConstantExpresssion exp, [_]) {
+  @override
+  void visitConstructed(ConstructedConstantExpresssion exp, [_]) {
     sb.write('const ');
     sb.write(exp.target.enclosingClass.name);
     if (exp.target.name != '') {
       sb.write('.');
       sb.write(exp.target.name);
     }
     writeTypeArguments(exp.type);
     sb.write('(');
     bool needsComma = false;
 
@@ skipping 10 matching lines @@
         sb.write(', ');
       }
       sb.write(exp.selector.namedArguments[index]);
       sb.write(': ');
       visit(exp.arguments[namedOffset + index]);
       needsComma = true;
     }
     sb.write(')');
   }
 
-  visitConcatenate(ConcatenateConstantExpression exp, [_]) {
+  @override
+  void visitConcatenate(ConcatenateConstantExpression exp, [_]) {
     sb.write(exp.value.unparse());
   }
 
-  visitSymbol(SymbolConstantExpression exp, [_]) {
+  @override
+  void visitSymbol(SymbolConstantExpression exp, [_]) {
     sb.write('#');
     sb.write(exp.name);
   }
 
-  visitType(TypeConstantExpression exp, [_]) {
+  @override
+  void visitType(TypeConstantExpression exp, [_]) {
     sb.write(exp.type.name);
   }
 
-  visitVariable(VariableConstantExpression exp, [_]) {
+  @override
+  void visitVariable(VariableConstantExpression exp, [_]) {
     if (exp.element.isStatic) {
       sb.write(exp.element.enclosingClass.name);
       sb.write('.');
     }
     sb.write(exp.element.name);
   }
 
-  visitFunction(FunctionConstantExpression exp, [_]) {
+  @override
+  void visitFunction(FunctionConstantExpression exp, [_]) {
     if (exp.element.isStatic) {
       sb.write(exp.element.enclosingClass.name);
       sb.write('.');
     }
     sb.write(exp.element.name);
   }
 
-  visitBinary(BinaryConstantExpression exp, [_]) {
+  @override
+  void visitBinary(BinaryConstantExpression exp, [_]) {
     if (exp.operator == 'identical') {
       sb.write('identical(');
       visit(exp.left);
       sb.write(', ');
       visit(exp.right);
       sb.write(')');
     } else {
       write(exp, exp.left);
       sb.write(' ');
       sb.write(exp.operator);
       sb.write(' ');
       write(exp, exp.right);
     }
   }
 
-  visitUnary(UnaryConstantExpression exp, [_]) {
+  @override
+  void visitUnary(UnaryConstantExpression exp, [_]) {
     sb.write(exp.operator);
     write(exp, exp.expression);
   }
 
-  visitConditional(ConditionalConstantExpression exp, [_]) {
+  @override
+  void visitConditional(ConditionalConstantExpression exp, [_]) {
     write(exp, exp.condition, leftAssociative: false);
     sb.write(' ? ');
     write(exp, exp.trueExp);
     sb.write(' : ');
     write(exp, exp.falseExp);
   }
 
   String toString() => sb.toString();
 }