Rename Constant to ConstantValue and ConstExp to ConstantExpression.

sdk/lib/_internal/compiler/implementation/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 /// A synthetic local variable only used with the SSA graph.
 ///
 /// For instance used for holding return value of function or the exception of a
 /// try-catch statement.
@@ skipping 40 matching lines @@
           }
         } else {
           compiler.internalError(element, 'Unexpected element kind $kind.');
         }
         assert(graph.isValid());
         if (!identical(kind, ElementKind.FIELD)) {
           FunctionElement function = element;
           FunctionSignature signature = function.functionSignature;
           signature.forEachOptionalParameter((ParameterElement parameter) {
             // This ensures the default value will be computed.
-            Constant constant =
+            ConstantValue constant =
                 backend.constants.getConstantForVariable(parameter).value;
             CodegenRegistry registry = work.registry;
             registry.registerCompileTimeConstant(constant);
           });
         }
         if (compiler.tracer.isEnabled) {
           String name;
           if (element.isClassMember) {
             String className = element.enclosingClass.name;
             String memberName = element.name;
@@ skipping 1267 matching lines @@
     return compiler.withCurrentElement(element, () {
       // The [sourceElementStack] contains declaration elements.
       sourceElementStack.add(element.declaration);
       var result = f();
       sourceElementStack.removeLast();
       return result;
     });
   }
 
   HInstruction handleConstantForOptionalParameter(Element parameter) {
-    ConstExp constant =
+    ConstantExpression constant =
         backend.constants.getConstantForVariable(parameter);
     assert(invariant(parameter, constant != null,
         message: 'No constant computed for $parameter'));
     return graph.addConstant(constant.value, compiler);
   }
 
   Element get currentNonClosureClass {
     ClassElement cls = sourceElement.enclosingClass;
     if (cls != null && cls.isClosure) {
       var closureClass = cls;
@@ skipping 18 matching lines @@
   // types of the type variables in an environment (like the [LocalsHandler]).
   final List<DartType> currentInlinedInstantiations = <DartType>[];
 
   final List<AstInliningState> inliningStack = <AstInliningState>[];
 
   Local returnLocal;
   DartType returnType;
 
   bool inTryStatement = false;
 
-  Constant getConstantForNode(ast.Node node) {
-    ConstExp constant =
+  ConstantValue getConstantForNode(ast.Node node) {
+    ConstantExpression constant =
         backend.constants.getConstantForNode(node, elements);
     assert(invariant(node, constant != null,
         message: 'No constant computed for $node'));
     return constant.value;
   }
 
   HInstruction addConstant(ast.Node node) {
     return graph.addConstant(getConstantForNode(node), compiler);
   }
 
   bool isLazilyInitialized(VariableElement element) {
-    ConstExp initialValue =
+    ConstantExpression initialValue =
         backend.constants.getConstantForVariable(element);
     return initialValue == null;
   }
 
   TypeMask cachedTypeOfThis;
 
   TypeMask getTypeOfThis() {
     TypeMask result = cachedTypeOfThis;
     if (result == null) {
       ThisLocal local = localsHandler.closureData.thisLocal;
@@ skipping 640 matching lines @@
           remainingTypeVariables = contextClass.typeVariables.length;
         } else {
           assert(source == newSource);
         }
         // If there are no more type variables, then there are more type
         // arguments for the new object than the source has, and it can't be
         // a copy.  Otherwise remove one argument.
         if (remainingTypeVariables == 0) return false;
         remainingTypeVariables--;
         // Check that the index is the one we expect.
-        IntConstant constant = index.constant;
-        return constant.value == expectedIndex++;
+        IntConstantValue constant = index.constant;
+        return constant.primitiveValue == expectedIndex++;
       }
 
       List<HInstruction> typeArguments = <HInstruction>[];
       classElement.typeVariables.forEach((TypeVariableType typeVariable) {
         HInstruction argument = localsHandler.readLocal(
             localsHandler.getTypeVariableAsLocal(typeVariable));
         if (allIndexed && !isIndexedTypeArgumentGet(argument)) {
           allIndexed = false;
         }
         typeArguments.add(argument);
@@ skipping 11 matching lines @@
     HInstruction interceptor = null;
     for (int index = constructors.length - 1; index >= 0; index--) {
       FunctionElement constructor = constructors[index];
       assert(invariant(functionElement, constructor.isImplementation));
       ConstructorBodyElement body = getConstructorBody(constructor);
       if (body == null) continue;
 
       List bodyCallInputs = <HInstruction>[];
       if (isNativeUpgradeFactory) {
         if (interceptor == null) {
-          Constant constant = new InterceptorConstant(classElement.thisType);
+          ConstantValue constant =
+              new InterceptorConstantValue(classElement.thisType);
           interceptor = graph.addConstant(constant, compiler);
         }
         bodyCallInputs.add(interceptor);
       }
       bodyCallInputs.add(newObject);
       ResolvedAst resolvedAst = constructor.resolvedAst;
       TreeElements elements = resolvedAst.elements;
       ast.Node node = resolvedAst.node;
       ClosureClassMap parameterClosureData =
           compiler.closureToClassMapper.getMappingForNestedFunction(node);
@@ skipping 886 matching lines @@
   void visitUnary(ast.Send node, ast.Operator op) {
     assert(node.argumentsNode is ast.Prefix);
     visit(node.receiver);
     assert(!identical(op.token.kind, PLUS_TOKEN));
     HInstruction operand = pop();
 
     // See if we can constant-fold right away. This avoids rewrites later on.
     if (operand is HConstant) {
       UnaryOperation operation = constantSystem.lookupUnary(op.source);
       HConstant constant = operand;
-      Constant folded = operation.fold(constant.constant);
+      ConstantValue folded = operation.fold(constant.constant);
       if (folded != null) {
         stack.add(graph.addConstant(folded, compiler));
         return;
       }
     }
 
     pushInvokeDynamic(node, elements.getSelector(node), [operand]);
   }
 
   void visitBinary(HInstruction left,
@@ skipping 62 matching lines @@
       Element helper = backend.getCheckDeferredIsLoaded();
       pushInvokeStatic(node, helper, [loadIdConstant, uriConstant]);
       pop();
     }
   }
 
   void generateGetter(ast.Send send, Element element) {
     if (element != null && element.isForeign(backend)) {
       visitForeignGetter(send);
     } else if (Elements.isStaticOrTopLevelField(element)) {
-      ConstExp constant;
+      ConstantExpression constant;
       if (element.isField && !element.isAssignable) {
         // A static final or const. Get its constant value and inline it if
         // the value can be compiled eagerly.
         constant = backend.constants.getConstantForVariable(element);
       }
       if (constant != null) {
-        Constant value = constant.value;
+        ConstantValue value = constant.value;
         HConstant instruction;
         // Constants that are referred via a deferred prefix should be referred
         // by reference.
         PrefixElement prefix = compiler.deferredLoadTask
             .deferredPrefixElement(send, elements);
         if (prefix != null) {
           instruction = graph.addDeferredConstant(value, prefix, compiler);
         } else {
           instruction = graph.addConstant(value, compiler);
         }
@@ skipping 532 matching lines @@
     visit(arguments[1]);
     HInstruction globalNameHNode = pop();
     if (!globalNameHNode.isConstantString()) {
       compiler.reportError(
           arguments[1], MessageKind.GENERIC,
           {'text': 'Error: Expected String as second argument '
                    'to JS_EMBEDDED_GLOBAL.'});
       return;
     }
     HConstant hConstant = globalNameHNode;
-    StringConstant constant = hConstant.constant;
-    String globalName = constant.value.slowToString();
+    StringConstantValue constant = hConstant.constant;
+    String globalName = constant.primitiveValue.slowToString();
     js.Template expr = js.js.expressionTemplateYielding(
         backend.emitter.generateEmbeddedGlobalAccess(globalName));
     native.NativeBehavior nativeBehavior =
         compiler.enqueuer.resolution.nativeEnqueuer.getNativeBehaviorOf(node);
     TypeMask ssaType =
         TypeMaskFactory.fromNativeBehavior(nativeBehavior, compiler);
     push(new HForeign(expr, ssaType, const []));
   }
 
   void handleJsInterceptorConstant(ast.Send node) {
     // Single argument must be a TypeConstant which is converted into a
     // InterceptorConstant.
     if (!node.arguments.isEmpty && node.arguments.tail.isEmpty) {
       ast.Node argument = node.arguments.head;
       visit(argument);
       HInstruction argumentInstruction = pop();
       if (argumentInstruction is HConstant) {
-        Constant argumentConstant = argumentInstruction.constant;
-        if (argumentConstant is TypeConstant) {
-          Constant constant =
-              new InterceptorConstant(argumentConstant.representedType);
+        ConstantValue argumentConstant = argumentInstruction.constant;
+        if (argumentConstant is TypeConstantValue) {
+          ConstantValue constant =
+              new InterceptorConstantValue(argumentConstant.representedType);
           HInstruction instruction = graph.addConstant(constant, compiler);
           stack.add(instruction);
           return;
         }
       }
     }
     compiler.reportError(node,
         MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
     stack.add(graph.addConstantNull(compiler));
   }
@@ skipping 202 matching lines @@
         && element.enclosingElement.declaration != compiler.objectClass) {
       // Register the call as dynamic if [noSuchMethod] on the super
       // class is _not_ the default implementation from [Object], in
       // case the [noSuchMethod] implementation calls
       // [JSInvocationMirror._invokeOn].
       registry.registerSelectorUse(selector.asUntyped);
     }
     String publicName = name;
     if (selector.isSetter) publicName += '=';
 
-    Constant nameConstant = constantSystem.createString(
+    ConstantValue nameConstant = constantSystem.createString(
         new ast.DartString.literal(publicName));
 
     String internalName = backend.namer.invocationName(selector);
-    Constant internalNameConstant =
+    ConstantValue internalNameConstant =
         constantSystem.createString(new ast.DartString.literal(internalName));
 
     Element createInvocationMirror = backend.getCreateInvocationMirror();
     var argumentsInstruction = buildLiteralList(arguments);
     add(argumentsInstruction);
 
     var argumentNames = new List<HInstruction>();
     for (String argumentName in selector.namedArguments) {
-      Constant argumentNameConstant =
+      ConstantValue argumentNameConstant =
           constantSystem.createString(new ast.DartString.literal(argumentName));
       argumentNames.add(graph.addConstant(argumentNameConstant, compiler));
     }
     var argumentNamesInstruction = buildLiteralList(argumentNames);
     add(argumentNamesInstruction);
 
-    Constant kindConstant =
+    ConstantValue kindConstant =
         constantSystem.createInt(selector.invocationMirrorKind);
 
     pushInvokeStatic(null,
                      createInvocationMirror,
                      [graph.addConstant(nameConstant, compiler),
                       graph.addConstant(internalNameConstant, compiler),
                       graph.addConstant(kindConstant, compiler),
                       argumentsInstruction,
                       argumentNamesInstruction],
                       backend.dynamicType);
@@ skipping 324 matching lines @@
         inputs[0] = conversion;
       }
       js.Template code = js.js.parseForeignJS('Array(#)');
       var behavior = new native.NativeBehavior();
       behavior.typesReturned.add(expectedType);
       // The allocation can throw only if the given length is a double
       // or negative.
       bool canThrow = true;
       if (inputs[0].isInteger(compiler) && inputs[0] is HConstant) {
         var constant = inputs[0];
-        if (constant.constant.value >= 0) canThrow = false;
+        if (constant.constant.primitiveValue >= 0) canThrow = false;
       }
       HForeign foreign = new HForeign(
           code, elementType, inputs, nativeBehavior: behavior,
           canThrow: canThrow);
       push(foreign);
       TypesInferrer inferrer = compiler.typesTask.typesInferrer;
       if (inferrer.isFixedArrayCheckedForGrowable(send)) {
         js.Template code = js.js.parseForeignJS(r'#.fixed$length = init');
         // We set the instruction as [canThrow] to avoid it being dead code.
         // We need a finer grained side effect.
@@ skipping 168 matching lines @@
       addDynamicSendArgumentsToList(node, inputs);
       Selector closureSelector = new Selector.callClosureFrom(selector);
       pushWithPosition(
           new HInvokeClosure(closureSelector, inputs, backend.dynamicType),
           node);
     }
   }
 
   HConstant addConstantString(String string) {
     ast.DartString dartString = new ast.DartString.literal(string);
-    Constant constant = constantSystem.createString(dartString);
+    ConstantValue constant = constantSystem.createString(dartString);
     return graph.addConstant(constant, compiler);
   }
 
   visitTypePrefixSend(ast.Send node) {
     compiler.internalError(node, "visitTypePrefixSend should not be called.");
   }
 
   visitTypeLiteralSend(ast.Send node) {
     DartType type = elements.getTypeLiteralType(node);
     if (type.isInterfaceType || type.isTypedef || type.isDynamic) {
@@ skipping 60 matching lines @@
                   message,
                   backend.getThrowAbstractClassInstantiationError());
   }
 
   void generateThrowNoSuchMethod(ast.Node diagnosticNode,
                                  String methodName,
                                  {Link<ast.Node> argumentNodes,
                                   List<HInstruction> argumentValues,
                                   List<String> existingArguments}) {
     Element helper = backend.getThrowNoSuchMethod();
-    Constant receiverConstant =
+    ConstantValue receiverConstant =
         constantSystem.createString(new ast.DartString.empty());
     HInstruction receiver = graph.addConstant(receiverConstant, compiler);
     ast.DartString dartString = new ast.DartString.literal(methodName);
-    Constant nameConstant = constantSystem.createString(dartString);
+    ConstantValue nameConstant = constantSystem.createString(dartString);
     HInstruction name = graph.addConstant(nameConstant, compiler);
     if (argumentValues == null) {
       argumentValues = <HInstruction>[];
       argumentNodes.forEach((argumentNode) {
         visit(argumentNode);
         HInstruction value = pop();
         argumentValues.add(value);
       });
     }
     HInstruction arguments = buildLiteralList(argumentValues);
@@ skipping 49 matching lines @@
             node.send,
             noSuchMethodTargetSymbolString(error, 'constructor'),
             argumentNodes: node.send.arguments);
       } else {
         Message message = error.messageKind.message(error.messageArguments);
         generateRuntimeError(node.send, message.toString());
       }
     } else if (node.isConst) {
       stack.add(addConstant(node));
       if (isSymbolConstructor) {
-        ConstructedConstant symbol = getConstantForNode(node);
-        StringConstant stringConstant = symbol.fields.single;
+        ConstructedConstantValue symbol = getConstantForNode(node);
+        StringConstantValue stringConstant = symbol.fields.single;
         String nameString = stringConstant.toDartString().slowToString();
         registry.registerConstSymbol(nameString);
       }
     } else {
       handleNewSend(node);
     }
   }
 
   void pushInvokeDynamic(ast.Node node,
                          Selector selector,
@@ skipping 750 matching lines @@
 
   visitLiteralMapEntry(ast.LiteralMapEntry node) {
     visit(node.value);
     visit(node.key);
   }
 
   visitNamedArgument(ast.NamedArgument node) {
     visit(node.expression);
   }
 
-  Map<ast.CaseMatch, Constant> buildSwitchCaseConstants(ast.SwitchStatement node) {
-    Map<ast.CaseMatch, Constant> constants = new Map<ast.CaseMatch, Constant>();
+  Map<ast.CaseMatch, ConstantValue> buildSwitchCaseConstants(
+      ast.SwitchStatement node) {
+
+    Map<ast.CaseMatch, ConstantValue> constants =
+        new Map<ast.CaseMatch, ConstantValue>();
     for (ast.SwitchCase switchCase in node.cases) {
       for (ast.Node labelOrCase in switchCase.labelsAndCases) {
         if (labelOrCase is ast.CaseMatch) {
           ast.CaseMatch match = labelOrCase;
-          Constant constant = getConstantForNode(match.expression);
+          ConstantValue constant = getConstantForNode(match.expression);
           constants[labelOrCase] = constant;
         }
       }
     }
     return constants;
   }
 
   visitSwitchStatement(ast.SwitchStatement node) {
-    Map<ast.CaseMatch, Constant> constants = buildSwitchCaseConstants(node);
+    Map<ast.CaseMatch, ConstantValue> constants =
+        buildSwitchCaseConstants(node);
 
     // The switch case indices must match those computed in
     // [SwitchCaseJumpHandler].
     bool hasContinue = false;
     Map<ast.SwitchCase, int> caseIndex = new Map<ast.SwitchCase, int>();
     int switchIndex = 1;
     bool hasDefault = false;
     for (ast.SwitchCase switchCase in node.cases) {
       for (ast.Node labelOrCase in switchCase.labelsAndCases) {
         ast.Node label = labelOrCase.asLabel();
@@ skipping 17 matching lines @@
     } else {
       buildComplexSwitchStatement(node, constants, caseIndex, hasDefault);
     }
   }
 
   /**
    * Builds a simple switch statement which does not handle uses of continue
    * statements to labeled switch cases.
    */
   void buildSimpleSwitchStatement(ast.SwitchStatement node,
-                                  Map<ast.CaseMatch, Constant> constants) {
+                                  Map<ast.CaseMatch, ConstantValue> constants) {
     JumpHandler jumpHandler = createJumpHandler(node, isLoopJump: false);
     HInstruction buildExpression() {
       visit(node.expression);
       return pop();
     }
-    Iterable<Constant> getConstants(ast.SwitchCase switchCase) {
-      List<Constant> constantList = <Constant>[];
+    Iterable<ConstantValue> getConstants(ast.SwitchCase switchCase) {
+      List<ConstantValue> constantList = <ConstantValue>[];
       for (ast.Node labelOrCase in switchCase.labelsAndCases) {
         if (labelOrCase is ast.CaseMatch) {
           constantList.add(constants[labelOrCase]);
         }
       }
       return constantList;
     }
     bool isDefaultCase(ast.SwitchCase switchCase) {
       return switchCase.isDefaultCase;
     }
     void buildSwitchCase(ast.SwitchCase node) {
       visit(node.statements);
     }
     handleSwitch(node,
                  jumpHandler,
                  buildExpression,
                  node.cases,
                  getConstants,
                  isDefaultCase,
                  buildSwitchCase);
     jumpHandler.close();
   }
 
   /**
    * Builds a switch statement that can handle arbitrary uses of continue
    * statements to labeled switch cases.
    */
   void buildComplexSwitchStatement(ast.SwitchStatement node,
-                                   Map<ast.CaseMatch, Constant> constants,
+                                   Map<ast.CaseMatch, ConstantValue> constants,
                                    Map<ast.SwitchCase, int> caseIndex,
                                    bool hasDefault) {
     // If the switch statement has switch cases targeted by continue
     // statements we create the following encoding:
     //
     //   switch (e) {
     //     l_1: case e0: s_1; break;
     //     l_2: case e1: s_2; continue l_i;
     //     ...
     //     l_n: default: s_n; continue l_j;
@@ skipping 26 matching lines @@
     if (!hasDefault) {
       // Use [:null:] as the marker for a synthetic default clause.
       // The synthetic default is added because otherwise, there would be no
       // good place to give a default value to the local.
       switchCases = node.cases.nodes.toList()..add(null);
     }
     HInstruction buildExpression() {
       visit(node.expression);
       return pop();
     }
-    Iterable<Constant> getConstants(ast.SwitchCase switchCase) {
-      List<Constant> constantList = <Constant>[];
+    Iterable<ConstantValue> getConstants(ast.SwitchCase switchCase) {
+      List<ConstantValue> constantList = <ConstantValue>[];
       if (switchCase != null) {
         for (ast.Node labelOrCase in switchCase.labelsAndCases) {
           if (labelOrCase is ast.CaseMatch) {
             constantList.add(constants[labelOrCase]);
           }
         }
       }
       return constantList;
     }
     bool isDefaultCase(ast.SwitchCase switchCase) {
@@ skipping 21 matching lines @@
                  buildSwitchCase);
     jumpHandler.close();
 
     HInstruction buildCondition() =>
         graph.addConstantBool(true, compiler);
 
     void buildSwitch() {
       HInstruction buildExpression() {
         return localsHandler.readLocal(switchTarget);
       }
-      Iterable<Constant> getConstants(ast.SwitchCase switchCase) {
-        return <Constant>[constantSystem.createInt(caseIndex[switchCase])];
+      Iterable<ConstantValue> getConstants(ast.SwitchCase switchCase) {
+        return <ConstantValue>[constantSystem.createInt(caseIndex[switchCase])];
       }
       void buildSwitchCase(ast.SwitchCase switchCase) {
         visit(switchCase.statements);
         if (!isAborted()) {
           // Ensure that we break the loop if the case falls through. (This
           // is only possible for the last case.)
           jumpTargets[switchTarget].generateBreak();
         }
       }
       // Pass a [NullJumpHandler] because the target for the contained break
@@ skipping 34 matching lines @@
    *
    * [jumpHandler] is the [JumpHandler] for the created switch statement.
    * [buildExpression] creates the switch expression.
    * [switchCases] must be either an [Iterable] of [ast.SwitchCase] nodes or
    *   a [Link] or a [ast.NodeList] of [ast.SwitchCase] nodes.
    * [getConstants] returns the set of constants for a switch case.
    * [isDefaultCase] returns [:true:] if the provided switch case should be
    *   considered default for the created switch statement.
    * [buildSwitchCase] creates the statements for the switch case.
    */
-  void handleSwitch(ast.Node errorNode,
-                    JumpHandler jumpHandler,
-                    HInstruction buildExpression(),
-                    var switchCases,
-                    Iterable<Constant> getConstants(ast.SwitchCase switchCase),
-                    bool isDefaultCase(ast.SwitchCase switchCase),
-                    void buildSwitchCase(ast.SwitchCase switchCase)) {
-    Map<ast.CaseMatch, Constant> constants = new Map<ast.CaseMatch, Constant>();
+  void handleSwitch(
+      ast.Node errorNode,
+      JumpHandler jumpHandler,
+      HInstruction buildExpression(),
+      var switchCases,
+      Iterable<ConstantValue> getConstants(ast.SwitchCase switchCase),
+      bool isDefaultCase(ast.SwitchCase switchCase),
+      void buildSwitchCase(ast.SwitchCase switchCase)) {
+
+    Map<ast.CaseMatch, ConstantValue> constants =
+        new Map<ast.CaseMatch, ConstantValue>();
 
     HBasicBlock expressionStart = openNewBlock();
     HInstruction expression = buildExpression();
     if (switchCases.isEmpty) {
       return;
     }
 
     HSwitch switchInstruction = new HSwitch(<HInstruction>[expression]);
     HBasicBlock expressionEnd = close(switchInstruction);
     LocalsHandler savedLocals = localsHandler;
 
     List<HStatementInformation> statements = <HStatementInformation>[];
     bool hasDefault = false;
     Element getFallThroughErrorElement = backend.getFallThroughError();
     HasNextIterator<ast.Node> caseIterator =
         new HasNextIterator<ast.Node>(switchCases.iterator);
     while (caseIterator.hasNext) {
       ast.SwitchCase switchCase = caseIterator.next();
       HBasicBlock block = graph.addNewBlock();
-      for (Constant constant in getConstants(switchCase)) {
+      for (ConstantValue constant in getConstants(switchCase)) {
         HConstant hConstant = graph.addConstant(constant, compiler);
         switchInstruction.inputs.add(hConstant);
         hConstant.usedBy.add(switchInstruction);
         expressionEnd.addSuccessor(block);
       }
 
       if (isDefaultCase(switchCase)) {
         // An HSwitch has n inputs and n+1 successors, the last being the
         // default case.
         expressionEnd.addSuccessor(block);
@@ skipping 906 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }