Use ConstExp for storing constants.

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, Constant c));
+  void forEachConstantNode(f(Node n, ConstExp 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, Constant constant);
-  Constant getConstant(Node node);
+  void setConstant(Node node, ConstExp constant);
+  ConstExp 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, Constant> _constants;
+  Map<Node, ConstExp> _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, Constant constant) {
+  void setConstant(Node node, ConstExp constant) {
     if (_constants == null) {
-      _constants = new Maplet<Node, Constant>();
+      _constants = new Maplet<Node, ConstExp>();
     }
     _constants[node] = constant;
   }
 
-  Constant getConstant(Node node) {
+  ConstExp 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, Constant c)) {
+  void forEachConstantNode(f(Node n, ConstExp c)) {
     if (_constants != null) {
       _constants.forEach(f);
     }
   }
 
   void setAssert(Send node) {
     if (_asserts == null) {
       _asserts = new Setlet<Send>();
     }
     _asserts.add(node);
@@ skipping 647 matching lines @@
       element.supertypeLoadState = STATE_DONE;
       element.resolutionState = STATE_DONE;
       // TODO(johnniwinther): Check matching type variables and
       // empty extends/implements clauses.
     }
   }
 
   void _postProcessClassElement(BaseClassElementX element) {
     for (MetadataAnnotation metadata in element.metadata) {
       metadata.ensureResolved(compiler);
-      if (!element.isProxy && metadata.value == compiler.proxyConstant) {
+      if (!element.isProxy &&
+          metadata.constant.value == compiler.proxyConstant) {
         element.isProxy = true;
       }
     }
 
     // Force resolution of metadata on non-instance members since they may be
     // inspected by the backend while emitting. Metadata on instance members is
     // handled as a result of processing instantiated class members in the
     // enqueuer.
     // TODO(ahe): Avoid this eager resolution.
     element.forEachMember((_, Element member) {
@@ skipping 368 matching lines @@
         classElement.ensureResolved(compiler);
       }
       assert(invariant(node, context != null,
           message: "No context found for metadata annotation "
                    "on $annotatedElement."));
       ResolverVisitor visitor = visitorFor(context, useEnclosingScope: true);
       ResolutionRegistry registry = visitor.registry;
       node.accept(visitor);
       // TODO(johnniwinther): Avoid passing the [TreeElements] to
       // [compileMetadata].
-      annotation.value =
+      annotation.constant =
           constantCompiler.compileMetadata(annotation, node, registry.mapping);
       // TODO(johnniwinther): Register the relation between the annotation
       // and the annotated element instead. This will allow the backend to
       // retrieve the backend constant and only register metadata on the
       // elements for which it is needed. (Issue 17732).
       registry.registerMetadataConstant(annotation, annotatedElement);
       annotation.resolutionState = STATE_DONE;
     }));
   }
 
@@ skipping 1886 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;
-        Constant name = compiler.resolver.constantCompiler.compileNode(
+        ConstExp constant = compiler.resolver.constantCompiler.compileNode(
             argumentNode, registry.mapping);
+        Constant name = constant.value;
         if (!name.isString) {
           DartType type = name.computeType(compiler);
           compiler.reportError(argumentNode, MessageKind.STRING_EXPECTED,
                                    {'type': type});
         } else {
           StringConstant stringConstant = name;
           String nameString = stringConstant.toDartString().slowToString();
           if (validateSymbol(argumentNode, nameString)) {
             registry.registerConstSymbol(nameString);
           }
@@ skipping 29 matching lines @@
       if (equals.enclosingClass != compiler.objectClass) {
         compiler.reportError(spannable,
                              MessageKind.CONST_MAP_KEY_OVERRIDES_EQUALS,
                              {'type': keyType});
       }
     }
   }
 
   void analyzeConstant(Node node) {
     addDeferredAction(enclosingElement, () {
-      Constant constant = compiler.resolver.constantCompiler.compileNode(
+      ConstExp constant = compiler.resolver.constantCompiler.compileNode(
           node, registry.mapping);
 
-      if (constant.isMap) {
-        checkConstMapKeysDontOverrideEquals(node, constant);
+      Constant 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 (constant.isType) {
-          TypeConstant typeConstant = constant;
+        if (value.isType) {
+          TypeConstant 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 352 matching lines @@
     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.
-        Constant constant = registry.getConstant(caseMatch.expression);
+        ConstExp constant = registry.getConstant(caseMatch.expression);
         assert(invariant(node, constant != null,
             message: 'No constant computed for $node'));
 
-        DartType caseType = typeOfConstant(constant);
+        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
           // get a "type differs" error.
           if (caseType.element == compiler.doubleClass) {
             compiler.reportError(node,
                                  MessageKind.SWITCH_CASE_VALUE_OVERRIDES_EQUALS,
                                  {'type': "double"});
           } else if (caseType.element == compiler.functionClass) {
             compiler.reportError(node, MessageKind.SWITCH_CASE_FORBIDDEN,
                                  {'type': "Function"});
-          } else if (constant.isObject && overridesEquals(caseType)) {
+          } else if (constant.value.isObject && overridesEquals(caseType)) {
             compiler.reportError(firstCase.expression,
                 MessageKind.SWITCH_CASE_VALUE_OVERRIDES_EQUALS,
                 {'type': caseType});
           }
         } else {
           if (caseType != firstCaseType) {
             if (!hasReportedProblem) {
               compiler.reportError(
                   node,
                   MessageKind.SWITCH_CASE_TYPES_NOT_EQUAL,
@@ skipping 1181 matching lines @@
 }
 
 /// The result for the resolution of the `assert` method.
 class AssertResult implements ResolutionResult {
   const AssertResult();
 
   Element get element => null;
 
   String toString() => 'AssertResult()';
 }