Rename Constant to ConstantValue and ConstExp to ConstantExpression.

sdk/lib/_internal/compiler/implementation/resolution/members.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 resolution;
 
 abstract class TreeElements {
   AnalyzableElement get analyzedElement;
   Iterable<Node> get superUses;
 
   /// Iterables of the dependencies that this [TreeElement] records of
   /// [analyzedElement].
   Iterable<Element> get allElements;
-  void forEachConstantNode(f(Node n, ConstExp c));
+  void forEachConstantNode(f(Node n, ConstantExpression c));
 
   /// A set of additional dependencies.  See [registerDependency] below.
   Iterable<Element> get otherDependencies;
 
   Element operator[](Node node);
 
   // TODO(johnniwinther): Investigate whether [Node] could be a [Send].
   Selector getSelector(Node node);
   Selector getGetterSelectorInComplexSendSet(SendSet node);
   Selector getOperatorSelectorInComplexSendSet(SendSet node);
   DartType getType(Node node);
   void setSelector(Node node, Selector selector);
   void setGetterSelectorInComplexSendSet(SendSet node, Selector selector);
   void setOperatorSelectorInComplexSendSet(SendSet node, Selector selector);
 
   /// Returns the for-in loop variable for [node].
   Element getForInVariable(ForIn node);
   Selector getIteratorSelector(ForIn node);
   Selector getMoveNextSelector(ForIn node);
   Selector getCurrentSelector(ForIn node);
   void setIteratorSelector(ForIn node, Selector selector);
   void setMoveNextSelector(ForIn node, Selector selector);
   void setCurrentSelector(ForIn node, Selector selector);
-  void setConstant(Node node, ConstExp constant);
-  ConstExp getConstant(Node node);
+  void setConstant(Node node, ConstantExpression constant);
+  ConstantExpression getConstant(Node node);
   bool isAssert(Send send);
 
   /// Returns the [FunctionElement] defined by [node].
   FunctionElement getFunctionDefinition(FunctionExpression node);
 
   /// Returns target constructor for the redirecting factory body [node].
   ConstructorElement getRedirectingTargetConstructor(
       RedirectingFactoryBody node);
 
   /**
@@ skipping 36 matching lines @@
   /// Returns the label that [node] targets.
   LabelDefinition getTargetLabel(GotoStatement node);
 }
 
 class TreeElementMapping implements TreeElements {
   final AnalyzableElement analyzedElement;
   Map<Spannable, Selector> _selectors;
   Map<Node, DartType> _types;
   Setlet<Node> _superUses;
   Setlet<Element> _otherDependencies;
-  Map<Node, ConstExp> _constants;
+  Map<Node, ConstantExpression> _constants;
   Map<VariableElement, List<Node>> _potentiallyMutated;
   Map<Node, Map<VariableElement, List<Node>>> _potentiallyMutatedIn;
   Map<VariableElement, List<Node>> _potentiallyMutatedInClosure;
   Map<Node, Map<VariableElement, List<Node>>> _accessedByClosureIn;
   Setlet<Element> _elements;
   Setlet<Send> _asserts;
 
   /// Map from nodes to the targets they define.
   Map<Node, JumpTarget> _definedTargets;
 
@@ skipping 122 matching lines @@
   }
 
   Selector getCurrentSelector(ForIn node) {
     return _getSelector(node.inToken);
   }
 
   Element getForInVariable(ForIn node) {
     return this[node];
   }
 
-  void setConstant(Node node, ConstExp constant) {
+  void setConstant(Node node, ConstantExpression constant) {
     if (_constants == null) {
-      _constants = new Maplet<Node, ConstExp>();
+      _constants = new Maplet<Node, ConstantExpression>();
     }
     _constants[node] = constant;
   }
 
-  ConstExp getConstant(Node node) {
+  ConstantExpression getConstant(Node node) {
     return _constants != null ? _constants[node] : null;
   }
 
   bool isTypeLiteral(Send node) {
     return getType(node) != null;
   }
 
   DartType getTypeLiteralType(Send node) {
     return getType(node);
   }
@@ skipping 80 matching lines @@
           () => new Maplet<VariableElement, List<Node>>());
     accessMap.putIfAbsent(element, () => <Node>[]).add(accessNode);
   }
 
   String toString() => 'TreeElementMapping($analyzedElement)';
 
   Iterable<Element> get allElements {
     return _elements != null ? _elements : const <Element>[];
   }
 
-  void forEachConstantNode(f(Node n, ConstExp c)) {
+  void forEachConstantNode(f(Node n, ConstantExpression c)) {
     if (_constants != null) {
       _constants.forEach(f);
     }
   }
 
   void setAssert(Send node) {
     if (_asserts == null) {
       _asserts = new Setlet<Send>();
     }
     _asserts.add(node);
@@ skipping 2944 matching lines @@
       registry.registerFactoryWithTypeArguments();
     }
     if (constructor.isGenerativeConstructor && cls.isAbstract) {
       warning(node, MessageKind.ABSTRACT_CLASS_INSTANTIATION);
       registry.registerAbstractClassInstantiation();
     }
 
     if (isSymbolConstructor) {
       if (node.isConst) {
         Node argumentNode = node.send.arguments.head;
-        ConstExp constant = compiler.resolver.constantCompiler.compileNode(
-            argumentNode, registry.mapping);
-        Constant name = constant.value;
+        ConstantExpression constant =
+            compiler.resolver.constantCompiler.compileNode(
+                argumentNode, registry.mapping);
+        ConstantValue name = constant.value;
         if (!name.isString) {
           DartType type = name.computeType(compiler);
           compiler.reportError(argumentNode, MessageKind.STRING_EXPECTED,
                                    {'type': type});
         } else {
-          StringConstant stringConstant = name;
+          StringConstantValue stringConstant = name;
           String nameString = stringConstant.toDartString().slowToString();
           if (validateSymbol(argumentNode, nameString)) {
             registry.registerConstSymbol(nameString);
           }
         }
       } else {
         if (!compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(
                 enclosingElement)) {
           compiler.reportHint(
               node.newToken, MessageKind.NON_CONST_BLOAT,
               {'name': compiler.symbolClass.name});
         }
         registry.registerNewSymbol();
       }
     } else if (isMirrorsUsedConstant) {
       compiler.mirrorUsageAnalyzerTask.validate(node, registry.mapping);
     }
     if (node.isConst) {
       analyzeConstant(node);
     }
 
     return null;
   }
 
   void checkConstMapKeysDontOverrideEquals(Spannable spannable,
-                                           MapConstant map) {
-    for (Constant key in map.keys) {
+                                           MapConstantValue map) {
+    for (ConstantValue key in map.keys) {
       if (!key.isObject) continue;
-      ObjectConstant objectConstant = key;
+      ObjectConstantValue objectConstant = key;
       DartType keyType = objectConstant.type;
       ClassElement cls = keyType.element;
       if (cls == compiler.stringClass) continue;
       Element equals = cls.lookupMember('==');
       if (equals.enclosingClass != compiler.objectClass) {
         compiler.reportError(spannable,
                              MessageKind.CONST_MAP_KEY_OVERRIDES_EQUALS,
                              {'type': keyType});
       }
     }
   }
 
   void analyzeConstant(Node node) {
     addDeferredAction(enclosingElement, () {
-      ConstExp constant = compiler.resolver.constantCompiler.compileNode(
-          node, registry.mapping);
+      ConstantExpression constant =
+          compiler.resolver.constantCompiler.compileNode(
+              node, registry.mapping);
 
-      Constant value = constant.value;
+      ConstantValue value = constant.value;
       if (value.isMap) {
         checkConstMapKeysDontOverrideEquals(node, value);
       }
 
       // The type constant that is an argument to JS_INTERCEPTOR_CONSTANT names
       // a class that will be instantiated outside the program by attaching a
       // native class dispatch record referencing the interceptor.
       if (argumentsToJsInterceptorConstant != null &&
           argumentsToJsInterceptorConstant.contains(node)) {
         if (value.isType) {
-          TypeConstant typeConstant = value;
+          TypeConstantValue typeConstant = value;
           if (typeConstant.representedType is InterfaceType) {
             registry.registerInstantiatedType(typeConstant.representedType);
           } else {
             compiler.reportError(node,
                 MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
           }
         } else {
           compiler.reportError(node,
               MessageKind.WRONG_ARGUMENT_FOR_JS_INTERCEPTOR_CONSTANT);
         }
@@ skipping 315 matching lines @@
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     node.visitChildren(this);
   }
 
   visitNamedArgument(NamedArgument node) {
     visit(node.expression);
   }
 
-  DartType typeOfConstant(Constant constant) {
+  DartType typeOfConstant(ConstantValue constant) {
     if (constant.isInt) return compiler.intClass.rawType;
     if (constant.isBool) return compiler.boolClass.rawType;
     if (constant.isDouble) return compiler.doubleClass.rawType;
     if (constant.isString) return compiler.stringClass.rawType;
     if (constant.isNull) return compiler.nullClass.rawType;
     if (constant.isFunction) return compiler.functionClass.rawType;
     assert(constant.isObject);
-    ObjectConstant objectConstant = constant;
+    ObjectConstantValue objectConstant = constant;
     return objectConstant.type;
   }
 
   bool overridesEquals(DartType type) {
     ClassElement cls = type.element;
     Element equals = cls.lookupMember('==');
     return equals.enclosingClass != compiler.objectClass;
   }
 
   void checkCaseExpressions(SwitchStatement node) {
     JumpTarget breakElement = getOrDefineTarget(node);
     Map<String, LabelDefinition> continueLabels = <String, LabelDefinition>{};
 
     Link<Node> cases = node.cases.nodes;
     CaseMatch firstCase = null;
     DartType firstCaseType = null;
     bool hasReportedProblem = false;
 
     for (Link<Node> cases = node.cases.nodes;
          !cases.isEmpty;
          cases = cases.tail) {
       SwitchCase switchCase = cases.head;
 
       for (Node labelOrCase in switchCase.labelsAndCases) {
         CaseMatch caseMatch = labelOrCase.asCaseMatch();
         if (caseMatch == null) continue;
 
         // Analyze the constant.
-        ConstExp constant = registry.getConstant(caseMatch.expression);
+        ConstantExpression constant =
+            registry.getConstant(caseMatch.expression);
         assert(invariant(node, constant != null,
             message: 'No constant computed for $node'));
 
         DartType caseType = typeOfConstant(constant.value);
 
         if (firstCaseType == null) {
           firstCase = caseMatch;
           firstCaseType = caseType;
 
           // We only report the bad type on the first class element. All others
@@ skipping 1200 matching lines @@
 }
 
 /// The result for the resolution of the `assert` method.
 class AssertResult implements ResolutionResult {
   const AssertResult();
 
   Element get element => null;
 
   String toString() => 'AssertResult()';
 }