Rename Constant to ConstantValue and ConstExp to ConstantExpression.

sdk/lib/_internal/compiler/implementation/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_nodes.dart' as tree;
 import 'backend_ast_nodes.dart';
 import '../constants/expressions.dart';
-import '../constants/values.dart' as values;
+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.
 Expression emit(tree.FunctionDefinition definition) {
   return new ASTEmitter().emit(definition);
 }
@@ skipping 154 matching lines @@
     return new Parameters(
         signature.requiredParameters.mapToList(emitParameterFromElement),
         signature.optionalParameters.mapToList(emitParameterFromElement),
         signature.optionalParametersAreNamed);
   }
 
   /// Emits parameters that are not nested inside other parameters.
   /// Root parameters can have default values, while inner parameters cannot.
   Parameters emitRootParameters(tree.FunctionDefinition function) {
     FunctionSignature signature = function.element.functionSignature;
-    List<ConstExp> defaults = function.defaultParameterValues;
+    List<ConstantExpression> defaults = function.defaultParameterValues;
     List<Parameter> required =
         signature.requiredParameters.mapToList(emitParameterFromElement);
     List<Parameter> optional = new List<Parameter>(defaults.length);
     for (int i = 0; i < defaults.length; i++) {
       ParameterElement element = signature.orderedOptionalParameters[i];
       optional[i] = emitParameterFromElement(element);
       Expression constant = emitConstant(defaults[i]);
       if (!isNullLiteral(constant)) {
         optional[i].defaultValue = constant;
       }
@@ skipping 218 matching lines @@
   }
 
   void visitWhileTrue(tree.WhileTrue stmt) {
     List<Statement> savedBuffer = statementBuffer;
     tree.Statement savedFallthrough = fallthrough;
     statementBuffer = <Statement>[];
     fallthrough = stmt;
 
     visitStatement(stmt.body);
     Statement body = new Block(statementBuffer);
-    Statement statement = new While(new Literal(new values.TrueConstant()),
+    Statement statement = new While(new Literal(new TrueConstantValue()),
                                     body);
     if (usedLabels.remove(stmt.label)) {
       statement = new LabeledStatement(stmt.label.name, statement);
     }
     savedBuffer.add(statement);
 
     statementBuffer = savedBuffer;
     fallthrough = savedFallthrough;
   }
 
@@ skipping 222 matching lines @@
 
   /// Like [emitType] except the dynamic type is converted to null.
   TypeAnnotation emitOptionalType(DartType type) {
     if (type.treatAsDynamic) {
       return null;
     } else {
       return emitType(type);
     }
   }
 
-  Expression emitConstant(ConstExp exp) => new ConstantEmitter(this).visit(exp);
+  Expression emitConstant(ConstantExpression exp) => new ConstantEmitter(this).visit(exp);

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

Long line

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

Done.

 
 }
 
-class ConstantEmitter extends ConstExpVisitor<Expression> {
+class ConstantEmitter extends ConstantExpressionVisitor<Expression> {
   ASTEmitter parent;
   ConstantEmitter(this.parent);
 
-  Expression handlePrimitiveConstant(values.PrimitiveConstant value) {
+  Expression handlePrimitiveConstant(PrimitiveConstantValue value) {
     // Num constants may be negative, while literals must be non-negative:
     // Literals are non-negative in the specification, and a negated literal
     // parses as a call to unary `-`. The AST unparser assumes literals are
     // non-negative and relies on this to avoid incorrectly generating `--`,
     // the predecrement operator.
     // Translate such constants into their positive value wrapped by
     // the unary minus operator.
     if (value.isNum) {
-      values.NumConstant numConstant = value;
-      if (numConstant.value.isNegative) {
+      NumConstantValue numConstant = value;
+      if (numConstant.primitiveValue.isNegative) {
         return negatedLiteral(numConstant);
       }
     }
     return new Literal(value);
   }
 
   @override
-  Expression visitPrimitive(PrimitiveConstExp exp) {
+  Expression visitPrimitive(PrimitiveConstantExpression exp) {
     return handlePrimitiveConstant(exp.value);
   }
 
   /// Given a negative num constant, returns the corresponding positive
   /// literal wrapped by a unary minus operator.
-  Expression negatedLiteral(values.NumConstant constant) {
-    assert(constant.value.isNegative);
-    values.NumConstant positiveConstant;
+  Expression negatedLiteral(NumConstantValue constant) {
+    assert(constant.primitiveValue.isNegative);
+    NumConstantValue positiveConstant;
     if (constant.isInt) {
-      positiveConstant = new values.IntConstant(-constant.value);
+      positiveConstant = new IntConstantValue(-constant.primitiveValue);
     } else if (constant.isDouble) {
-      positiveConstant = new values.DoubleConstant(-constant.value);
+      positiveConstant = new DoubleConstantValue(-constant.primitiveValue);
     } else {
       throw "Unexpected type of NumConstant: $constant";
     }
     return new UnaryOperator('-', new Literal(positiveConstant));
   }
 
   @override
-  Expression visitList(ListConstExp exp) {
+  Expression visitList(ListConstantExpression exp) {
     return new LiteralList(
         exp.values.map(visit).toList(growable: false),
         isConst: true,
         typeArgument: parent.emitOptionalType(exp.type.typeArguments.single));
   }
 
   @override
-  Expression visitMap(MapConstExp exp) {
+  Expression visitMap(MapConstantExpression exp) {
     List<LiteralMapEntry> entries = new List<LiteralMapEntry>.generate(
         exp.values.length,
         (i) => new LiteralMapEntry(visit(exp.keys[i]),
                                    visit(exp.values[i])));
     List<TypeAnnotation> typeArguments = exp.type.treatAsRaw
         ? null
         : exp.type.typeArguments.map(parent.emitType).toList();
     return new LiteralMap(entries, isConst: true, typeArguments: typeArguments);
   }
 
   @override
-  Expression visitConstructor(ConstructorConstExp exp) {
+  Expression visitConstructor(ConstructedConstantExpresssion exp) {
     int positionalArgumentCount = exp.selector.positionalArgumentCount;
     List<Argument> args = new List<Argument>.generate(
         positionalArgumentCount,
         (i) => visit(exp.arguments[i]));
     for (int i = 0; i < exp.selector.namedArgumentCount; ++i) {
       args.add(new NamedArgument(exp.selector.namedArguments[i],
           visit(exp.arguments[positionalArgumentCount + i])));
     }
 
     FunctionElement constructor = exp.target;
     String name = constructor.name.isEmpty ? null : constructor.name;
     return new CallNew(parent.emitType(exp.type),
                        args,
                        constructorName: name,
                        isConst: true)
                ..constructor = constructor
                ..dartType = exp.type;
   }
 
   @override
-  Expression visitConcatenate(ConcatenateConstExp exp) {
+  Expression visitConcatenate(ConcatenateConstantExpression exp) {
     return new StringConcat(exp.arguments.map(visit).toList(growable: false));
   }
 
   @override
-  Expression visitSymbol(SymbolConstExp exp) {
+  Expression visitSymbol(SymbolConstantExpression exp) {
     return new LiteralSymbol(exp.name);
   }
 
   @override
-  Expression visitType(TypeConstExp exp) {
+  Expression visitType(TypeConstantExpression exp) {
     DartType type = exp.type;
     return new LiteralType(type.name)
                ..type = type;
   }
 
   @override
-  Expression visitVariable(VariableConstExp exp) {
+  Expression visitVariable(VariableConstantExpression exp) {
     Element element = exp.element;
     if (element.kind != ElementKind.VARIABLE) {
       return new Identifier(element.name)..element = element;
     }
     String name = parent.getConstantName(element);
     return new Identifier(name)
                ..element = element;
   }
 
   @override
-  Expression visitFunction(FunctionConstExp exp) {
+  Expression visitFunction(FunctionConstantExpression exp) {
     return new Identifier(exp.element.name)
                ..element = exp.element;
   }
 
   @override
-  Expression visitBinary(BinaryConstExp exp) {
+  Expression visitBinary(BinaryConstantExpression exp) {
     return handlePrimitiveConstant(exp.value);
   }
 
   @override
-  Expression visitConditional(ConditionalConstExp exp) {
+  Expression visitConditional(ConditionalConstantExpression exp) {
     if (exp.condition.value.isTrue) {
       return exp.trueExp.accept(this);
     } else {
       return exp.falseExp.accept(this);
     }
   }
 
   @override
-  Expression visitUnary(UnaryConstExp exp) {
+  Expression visitUnary(UnaryConstantExpression exp) {
     return handlePrimitiveConstant(exp.value);
   }
 }
 
 /// Moves function parameters into a separate variable if one of its uses is
 /// shadowed by an inner function parameter.
 /// This artifact is necessary because function parameters cannot be renamed.
 class UnshadowParameters extends tree.RecursiveVisitor {
 
   /// Maps parameter names to their bindings.
@@ skipping 38 matching lines @@
     }
   }
 
   visitVariable(tree.Variable variable) {
     if (shadowedParameters.contains(variable)) {
       hasShadowedUse.add(variable);
     }
   }
 
 }