Rename Constant to ConstantValue and ConstExp to ConstantExpression.

sdk/lib/_internal/compiler/implementation/dart_backend/tree_ir_nodes.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 tree_ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values;
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
 import '../dart_types.dart' show DartType, GenericType;
@@ skipping 148 matching lines @@
 }
 
 /**
  * Call to a factory or generative constructor.
  */
 class InvokeConstructor extends Expression implements Invoke {
   final DartType type;
   final FunctionElement target;
   final List<Expression> arguments;
   final Selector selector;
-  final values.Constant constant;
+  final values.ConstantValue constant;
 
   InvokeConstructor(this.type, this.target, this.selector, this.arguments,
       [this.constant]);
 
   ClassElement get targetClass => target.enclosingElement;
 
   accept(ExpressionVisitor visitor) => visitor.visitInvokeConstructor(this);
 }
 
 /// Calls [toString] on each argument and concatenates the results.
 class ConcatenateStrings extends Expression {
   final List<Expression> arguments;
-  final values.Constant constant;
+  final values.ConstantValue constant;
 
   ConcatenateStrings(this.arguments, [this.constant]);
 
   accept(ExpressionVisitor visitor) => visitor.visitConcatenateStrings(this);
 }
 
 /**
  * A constant.
  */
 class Constant extends Expression {
-  final ConstExp expression;
+  final ConstantExpression expression;
 
   Constant(this.expression);
 
-  Constant.primitive(values.PrimitiveConstant primitiveValue)
-      : expression = new PrimitiveConstExp(primitiveValue);
+  Constant.primitive(values.PrimitiveConstantValue primitiveValue)
+      : expression = new PrimitiveConstantExpression(primitiveValue);
 
   accept(ExpressionVisitor visitor) => visitor.visitConstant(this);
 
-  values.Constant get value => expression.value;
+  values.ConstantValue get value => expression.value;
 }
 
 class This extends Expression {
   accept(ExpressionVisitor visitor) => visitor.visitThis(this);
 }
 
 class ReifyTypeVar extends Expression {
   TypeVariableElement typeVariable;
 
   ReifyTypeVar(this.typeVariable);
@@ skipping 228 matching lines @@
   accept(StatementVisitor visitor) => visitor.visitAssign(this);
 }
 
 /**
  * A return exit from the function.
  *
  * In contrast to the CPS-based IR, the return value is an arbitrary
  * expression.
  */
 class Return extends Statement {
-  /// Should not be null. Use [Constant] with [NullConstant] for void returns.
+  /// Should not be null. Use [Constant] with [NullConstantValue] for void returns.

[sigurdm, 2014/10/01 07:46:47]

Long line

[Johnni Winther, 2014/10/01 08:21:23]

Done.

   Expression value;
 
   Statement get next => null;
   void set next(Statement s) => throw 'UNREACHABLE';
 
   Return(this.value);
 
   accept(StatementVisitor visitor) => visitor.visitReturn(this);
 }
 
@@ skipping 20 matching lines @@
   ExpressionStatement(this.expression, this.next);
 
   accept(StatementVisitor visitor) => visitor.visitExpressionStatement(this);
 }
 
 class FunctionDefinition extends Node {
   final FunctionElement element;
   final List<Variable> parameters;
   Statement body;
   final List<ConstDeclaration> localConstants;
-  final List<ConstExp> defaultParameterValues;
+  final List<ConstantExpression> defaultParameterValues;
 
   FunctionDefinition(this.element, this.parameters, this.body,
       this.localConstants, this.defaultParameterValues);
 
   /// Returns `true` if this function is abstract.
   ///
   /// If `true` [body] is `null` and [localConstants] is empty.
   bool get isAbstract => body == null;
 }
 
@@ skipping 143 matching lines @@
   visitFunctionDeclaration(FunctionDeclaration node) {
     visitFunctionDefinition(node.definition);
     visitStatement(node.next);
   }
 
   visitExpressionStatement(ExpressionStatement node) {
     visitExpression(node.expression);
     visitStatement(node.next);
   }
 }