Replace ResolvedNode by ConstantExpression.

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 12 matching lines @@
 /// For instance, multiple `const` constructors may be used to create the same
 /// object, and different `const` variables may hold the same value.
 abstract class ConstantExpression {
   /// Returns the value of this constant expression.
   ConstantValue get value;
 
   // TODO(johnniwinther): Unify precedence handled between constants, front-end
   // and back-end.
   int get precedence => 16;
 
-  accept(ConstantExpressionVisitor visitor);
+  accept(ConstantExpressionVisitor visitor, [context]);
 
   String getText() {
     ConstExpPrinter printer = new ConstExpPrinter();
     accept(printer);
     return printer.toString();
   }
 
   String toString() {
     assertDebugMode('Use ConstantExpression.getText() instead of '
                     'ConstantExpression.toString()');
     return getText();
   }
 }
 
 /// Boolean, int, double, string, or null constant.
 class PrimitiveConstantExpression extends ConstantExpression {
   final PrimitiveConstantValue value;
 
   PrimitiveConstantExpression(this.value) {
     assert(value != null);
   }
 
-  accept(ConstantExpressionVisitor visitor) => visitor.visitPrimitive(this);
+  accept(ConstantExpressionVisitor visitor, [context]) {
+    return visitor.visitPrimitive(this, context);
+  }
 }
 
 /// Literal list constant.
 class ListConstantExpression extends ConstantExpression {
   final ListConstantValue value;
   final InterfaceType type;
   final List<ConstantExpression> values;
 
   ListConstantExpression(this.value, this.type, this.values);
 
-  accept(ConstantExpressionVisitor visitor) => visitor.visitList(this);
+  accept(ConstantExpressionVisitor visitor, [context]) {
+    return visitor.visitList(this, context);
+  }
 }
 
 /// Literal map constant.
 class MapConstantExpression extends ConstantExpression {
   final MapConstantValue value;
   final InterfaceType type;
   final List<ConstantExpression> keys;
   final List<ConstantExpression> values;
 
   MapConstantExpression(this.value, this.type, this.keys, this.values);
 
-  accept(ConstantExpressionVisitor visitor) => visitor.visitMap(this);
+  accept(ConstantExpressionVisitor visitor, [context]) {
+    return visitor.visitMap(this, context);
+  }
 }
 
 /// Invocation of a const constructor.
 class ConstructedConstantExpresssion extends ConstantExpression {
   final ConstantValue value;
   final InterfaceType type;
   final FunctionElement target;
   final Selector selector;
   final List<ConstantExpression> arguments;
 
   ConstructedConstantExpresssion(this.value,
                       this.type,
                       this.target,
                       this.selector,
                       this.arguments) {
     assert(type.element == target.enclosingClass);
   }
 
-  accept(ConstantExpressionVisitor visitor) => visitor.visitConstructor(this);
+  accept(ConstantExpressionVisitor visitor, [context]) {
+    return visitor.visitConstructed(this, context);
+  }
 }
 
 /// String literal with juxtaposition and/or interpolations.
 // TODO(johnniwinther): Do we need this?
 class ConcatenateConstantExpression extends ConstantExpression {
   final StringConstantValue value;
   final List<ConstantExpression> arguments;
 
   ConcatenateConstantExpression(this.value, this.arguments);
 
-  accept(ConstantExpressionVisitor visitor) => visitor.visitConcatenate(this);
+  accept(ConstantExpressionVisitor visitor, [context]) {
+    return visitor.visitConcatenate(this, context);
+  }
 }
 
 /// Symbol literal.
 class SymbolConstantExpression extends ConstantExpression {
   final ConstructedConstantValue value;
   final String name;
 
   SymbolConstantExpression(this.value, this.name);
 
-  accept(ConstantExpressionVisitor visitor) => visitor.visitSymbol(this);
+  accept(ConstantExpressionVisitor visitor, [context]) {
+    return visitor.visitSymbol(this, context);
+  }
 }
 
 /// Type literal.
 class TypeConstantExpression extends ConstantExpression {
   final TypeConstantValue value;
   /// Either [DynamicType] or a raw [GenericType].
   final DartType type;
 
   TypeConstantExpression(this.value, this.type) {
     assert(type is GenericType || type is DynamicType);
   }
 
-  accept(ConstantExpressionVisitor visitor) => visitor.visitType(this);
+  accept(ConstantExpressionVisitor visitor, [context]) {
+    return visitor.visitType(this, context);
+  }
 }
 
 /// Reference to a constant local, top-level, or static variable.
 class VariableConstantExpression extends ConstantExpression {
   final ConstantValue value;
   final VariableElement element;
 
   VariableConstantExpression(this.value, this.element);
 
-  accept(ConstantExpressionVisitor visitor) => visitor.visitVariable(this);
+  accept(ConstantExpressionVisitor visitor, [context]) {
+    return visitor.visitVariable(this, context);
+  }
 }
 
 /// Reference to a top-level or static function.
 class FunctionConstantExpression extends ConstantExpression {
   final FunctionConstantValue value;
   final FunctionElement element;
 
   FunctionConstantExpression(this.value, this.element);
 
-  accept(ConstantExpressionVisitor visitor) => visitor.visitFunction(this);
+  accept(ConstantExpressionVisitor visitor, [context]) {
+    return visitor.visitFunction(this, context);
+  }
 }
 
 /// A constant binary expression like `a * b` or `identical(a, b)`.
 class BinaryConstantExpression extends ConstantExpression {
   final ConstantValue value;
   final ConstantExpression left;
   final String operator;
   final ConstantExpression right;
 
   BinaryConstantExpression(this.value, this.left, this.operator, this.right) {
     assert(PRECEDENCE_MAP[operator] != null);
   }
 
-  accept(ConstantExpressionVisitor visitor) => visitor.visitBinary(this);
+  accept(ConstantExpressionVisitor visitor, [context]) {
+    return visitor.visitBinary(this, context);
+  }
 
   int get precedence => PRECEDENCE_MAP[operator];
 
   static const Map<String, int> PRECEDENCE_MAP = const {
     'identical': 15,
     '==': 6,
     '!=': 6,
     '&&': 5,
     '||': 4,
     '^': 9,
@@ skipping 17 matching lines @@
 /// A unary constant expression like `-a`.
 class UnaryConstantExpression extends ConstantExpression {
   final ConstantValue value;
   final String operator;
   final ConstantExpression expression;
 
   UnaryConstantExpression(this.value, this.operator, this.expression) {
     assert(PRECEDENCE_MAP[operator] != null);
   }
 
-  accept(ConstantExpressionVisitor visitor) => visitor.visitUnary(this);
+  accept(ConstantExpressionVisitor visitor, [context]) {
+    return visitor.visitUnary(this, context);
+  }
 
   int get precedence => PRECEDENCE_MAP[operator];
 
   static const Map<String, int> PRECEDENCE_MAP = const {
     '!': 14,
     '~': 14,
     '-': 14,
   };
 }
 
 /// A constant conditional expression like `a ? b : c`.
 class ConditionalConstantExpression extends ConstantExpression {
   final ConstantValue value;
   final ConstantExpression condition;
   final ConstantExpression trueExp;
   final ConstantExpression falseExp;
 
   ConditionalConstantExpression(this.value,
                                 this.condition,
                                 this.trueExp,
                                 this.falseExp);
 
-  accept(ConstantExpressionVisitor visitor) => visitor.visitConditional(this);
+  accept(ConstantExpressionVisitor visitor, [context]) {
+    return visitor.visitConditional(this, context);
+  }
 
   int get precedence => 3;
 }
 
-abstract class ConstantExpressionVisitor<T> {
-  T visit(ConstantExpression constant) => constant.accept(this);
+abstract class ConstantExpressionVisitor<C, R> {
+  const ConstantExpressionVisitor();
 
-  T visitPrimitive(PrimitiveConstantExpression exp);
-  T visitList(ListConstantExpression exp);
-  T visitMap(MapConstantExpression exp);
-  T visitConstructor(ConstructedConstantExpresssion exp);
-  T visitConcatenate(ConcatenateConstantExpression exp);
-  T visitSymbol(SymbolConstantExpression exp);
-  T visitType(TypeConstantExpression exp);
-  T visitVariable(VariableConstantExpression exp);
-  T visitFunction(FunctionConstantExpression exp);
-  T visitBinary(BinaryConstantExpression exp);
-  T visitUnary(UnaryConstantExpression exp);
-  T visitConditional(ConditionalConstantExpression exp);
+  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]);
 }
 
 /// 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 {

[sigurdm, 2014/11/12 12:10:23]

Shouldn't there be type arguments here also?

[Johnni Winther, 2014/11/13 10:16:42]

I prefer not adding type arguments here. It should be something like <Null,
Void> or <Void, Void> which we don't have anyway.

   final StringBuffer sb = new StringBuffer();
 
   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) {
     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) {
+  visitPrimitive(PrimitiveConstantExpression exp, [_]) {
     sb.write(exp.value.unparse());
   }
 
-  visitList(ListConstantExpression exp) {
+  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) {
+  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('}');
   }
 
-  visitConstructor(ConstructedConstantExpresssion exp) {
+  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) {
+  visitConcatenate(ConcatenateConstantExpression exp, [_]) {
     sb.write(exp.value.unparse());
   }
 
-  visitSymbol(SymbolConstantExpression exp) {
+  visitSymbol(SymbolConstantExpression exp, [_]) {
     sb.write('#');
     sb.write(exp.name);
   }
 
-  visitType(TypeConstantExpression exp) {
+  visitType(TypeConstantExpression exp, [_]) {
     sb.write(exp.type.name);
   }
 
-  visitVariable(VariableConstantExpression exp) {
+  visitVariable(VariableConstantExpression exp, [_]) {
     if (exp.element.isStatic) {
       sb.write(exp.element.enclosingClass.name);
       sb.write('.');
     }
     sb.write(exp.element.name);
   }
 
-  visitFunction(FunctionConstantExpression exp) {
+  visitFunction(FunctionConstantExpression exp, [_]) {
     if (exp.element.isStatic) {
       sb.write(exp.element.enclosingClass.name);
       sb.write('.');
     }
     sb.write(exp.element.name);
   }
 
-  visitBinary(BinaryConstantExpression exp) {
+  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) {
+  visitUnary(UnaryConstantExpression exp, [_]) {
     sb.write(exp.operator);
     write(exp, exp.expression);
   }
 
-  visitConditional(ConditionalConstantExpression exp) {
+  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();
 }