Move compile-time constant registrations to the backend.

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 special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 39 matching lines @@
         } else {
           compiler.internalErrorOnElement(element,
                                           'unexpected element kind $kind');
         }
         assert(graph.isValid());
         if (!identical(kind, ElementKind.FIELD)) {
           FunctionElement function = element;
           FunctionSignature signature = function.computeSignature(compiler);
           signature.forEachOptionalParameter((Element parameter) {
             // This ensures the default value will be computed.
-            builder.compileVariable(parameter);
+            Constant constant =
+                compiler.constantHandler.getConstantForVariable(parameter);
+            backend.registerCompileTimeConstant(constant, work.resolutionTree);
+            compiler.constantHandler.addCompileTimeConstantForEmission(
+                constant);
           });
         }
-
         if (compiler.tracer.enabled) {
           String name;
           if (element.isMember()) {
             String className = element.getEnclosingClass().name.slowToString();
             String memberName = element.name.slowToString();
             name = "$className.$memberName";
             if (element.isGenerativeConstructorBody()) {
               name = "$name (body)";
             }
           } else {
@@ skipping 872 matching lines @@
 
   bool inTryStatement = false;
   int loopNesting = 0;
 
   HBasicBlock get current => _current;
   void set current(c) {
     isReachable = c != null;
     _current = c;
   }
 
-  /**
-   * Compiles compile-time constants. Never returns [:null:]. If the
-   * initial value is not a compile-time constants, it reports an
-   * internal error.
-   */
-  Constant compileConstant(VariableElement element) {
-    return compiler.constantHandler.compileConstant(element);
+  Constant getConstantForNode(Node node) {
+    ConstantHandler handler = compiler.constantHandler;
+    Constant constant = elements.getConstant(node);
+    assert(invariant(node, constant != null,
+        message: 'No constant computed for $node'));
+    return constant;
   }
 
-  Constant compileVariable(VariableElement element) {
-    return compiler.constantHandler.compileVariable(element);
+  HInstruction addConstant(Node node) {
+    return graph.addConstant(getConstantForNode(node), compiler);
   }
 
   bool isLazilyInitialized(VariableElement element) {
-    Constant initialValue = compileVariable(element);
+    Constant initialValue =
+        compiler.constantHandler.getConstantForVariable(element);
     return initialValue == null;
   }
 
   HType cachedTypeOfThis;
 
   HType getTypeOfThis() {
     HType result = cachedTypeOfThis;
     if (result == null) {
       Element element = localsHandler.closureData.thisElement;
       ClassElement cls = element.enclosingElement.getEnclosingClass();
@@ skipping 1636 matching lines @@
     assert(selector.isGetter());
     pushInvokeDynamic(send, selector, [receiver]);
   }
 
   void generateGetter(Send send, Element element) {
     if (Elements.isStaticOrTopLevelField(element)) {
       Constant value;
       if (element.isField() && !element.isAssignable()) {
         // A static final or const. Get its constant value and inline it if
         // the value can be compiled eagerly.
-        value = compileVariable(element);
+        value = compiler.constantHandler.getConstantForVariable(element);
       }
       if (value != null) {
         HInstruction instruction = graph.addConstant(value, compiler);
         stack.add(instruction);
         // The inferrer may have found a better type than the constant
         // handler in the case of lists, because the constant handler
         // does not look at elements in the list.
         HType type = new HType.inferredTypeForElement(element, compiler);
         if (!type.isUnknown()) instruction.instructionType = type;
       } else if (element.isField() && isLazilyInitialized(element)) {
@@ skipping 306 matching lines @@
       // of instructions, in an order that can be shared with
       // selectors with the same named arguments.
       List<SourceString> orderedNames = selector.getOrderedNamedArguments();
       for (SourceString name in orderedNames) {
         list.add(instructions[name]);
       }
     }
   }
 
   HInstruction handleConstantForOptionalParameter(Element parameter) {
-    Constant constant = compileConstant(parameter);
+    Constant constant =
+        compiler.constantHandler.getConstantForVariable(parameter);
+    assert(invariant(parameter, constant != null,
+        message: 'No constant computed for $parameter'));
     return graph.addConstant(constant, compiler);
   }
 
   /**
    * Returns true if the arguments were compatible with the function signature.
    *
    * Invariant: [element] must be an implementation element.
    */
   bool addStaticSendArgumentsToList(Selector selector,
                                     Link<Node> arguments,
@@ skipping 697 matching lines @@
   HConstant addConstantString(Node node, String string) {
     DartString dartString = new DartString.literal(string);
     Constant constant = constantSystem.createString(dartString, node);
     return graph.addConstant(constant, compiler);
   }
 
   visitTypeReferenceSend(Send node) {
     Element element = elements[node];
     if (element.isClass() || element.isTypedef()) {
       // TODO(karlklose): add type representation
-      ConstantHandler handler = compiler.constantHandler;
-      Constant constant = handler.compileNodeWithDefinitions(node, elements);
-      stack.add(graph.addConstant(constant, compiler));
+      stack.add(addConstant(node));
     } else if (element.isTypeVariable()) {
       HInstruction value =
           addTypeVariableReference(element.computeType(compiler));
       pushInvokeStatic(node,
                        backend.getRuntimeTypeToString(),
                        [value],
                        backend.stringType);
       pushInvokeStatic(node,
                        backend.getCreateRuntimeType(),
                        [pop()]);
@@ skipping 110 matching lines @@
       ErroneousElement error = element;
       if (error.messageKind == MessageKind.CANNOT_FIND_CONSTRUCTOR.error) {
         generateThrowNoSuchMethod(node.send,
                                   getTargetName(error, 'constructor'),
                                   argumentNodes: node.send.arguments);
       } else {
         Message message = error.messageKind.message(error.messageArguments);
         generateRuntimeError(node.send, message.toString());
       }
     } else if (node.isConst()) {
-      ConstantHandler handler = compiler.constantHandler;
-      Constant constant = handler.compileNodeWithDefinitions(node, elements);
-      stack.add(graph.addConstant(constant, compiler));
+      stack.add(addConstant(node));
       if (isSymbolConstructor) {
-        ConstructedConstant symbol = constant;
+        ConstructedConstant symbol = elements.getConstant(node);
         StringConstant stringConstant = symbol.fields.single;
         String nameString = stringConstant.toDartString().slowToString();
         compiler.enqueuer.codegen.registerConstSymbol(nameString, elements);
       }
     } else {
       handleNewSend(node);
     }
   }
 
   void pushInvokeDynamic(Node node,
@@ skipping 295 matching lines @@
 
   void visitLiteralBool(LiteralBool node) {
     stack.add(graph.addConstantBool(node.value, compiler));
   }
 
   void visitLiteralString(LiteralString node) {
     stack.add(graph.addConstantString(node.dartString, node, compiler));
   }
 
   void visitLiteralSymbol(LiteralSymbol node) {
-    ConstantHandler handler = compiler.constantHandler;
-    ConstructedConstant constant =
-        handler.compileNodeWithDefinitions(node, elements);
-    stack.add(graph.addConstant(constant, compiler));
-    compiler.enqueuer.codegen.registerConstSymbol(node.slowNameString, elements);
+    stack.add(addConstant(node));
+    compiler.enqueuer.codegen.registerConstSymbol(
+        node.slowNameString, elements);
   }
 
   void visitStringJuxtaposition(StringJuxtaposition node) {
     if (!node.isInterpolation) {
       // This is a simple string with no interpolations.
       stack.add(graph.addConstantString(node.dartString, node, compiler));
       return;
     }
     StringBuilderVisitor stringBuilder = new StringBuilderVisitor(this, node);
     stringBuilder.visit(node);
@@ skipping 53 matching lines @@
     closeAndGotoExit(new HThrow(exception, isRethrow: true));
   }
 
   visitReturn(Return node) {
     if (identical(node.getBeginToken().stringValue, 'native')) {
       native.handleSsaNative(this, node.expression);
       return;
     }
     HInstruction value;
     if (node.isRedirectingFactoryBody) {
-      FunctionElement element = elements[node.expression];
+      FunctionElement element = elements[node.expression].implementation;
       FunctionElement function = currentElement;
       List<HInstruction> inputs = <HInstruction>[];
       FunctionSignature calleeSignature = element.functionSignature;
       FunctionSignature callerSignature = function.functionSignature;
       callerSignature.forEachRequiredParameter((Element element) {
         inputs.add(localsHandler.readLocal(element));
       });
       List<Element> calleeOptionals =
           calleeSignature.orderedOptionalParameters;
       List<Element> callerOptionals =
@@ skipping 63 matching lines @@
         visitSendSet(definition);
         pop();  // Discard value.
       }
     }
   }
 
   visitLiteralList(LiteralList node) {
     HInstruction instruction;
 
     if (node.isConst()) {
-      ConstantHandler handler = compiler.constantHandler;
-      Constant constant = handler.compileNodeWithDefinitions(node, elements);
-      instruction = graph.addConstant(constant, compiler);
+      instruction = addConstant(node);
     } else {
       List<HInstruction> inputs = <HInstruction>[];
       for (Link<Node> link = node.elements.nodes;
            !link.isEmpty;
            link = link.tail) {
         visit(link.head);
         inputs.add(pop());
       }
       instruction = buildLiteralList(inputs);
       add(instruction);
@@ skipping 176 matching lines @@
       entryBlock.setBlockFlow(
           new HLabeledBlockInformation(new HSubGraphBlockInformation(bodyGraph),
                                        handler.labels()),
           joinBlock);
     }
     handler.close();
   }
 
   visitLiteralMap(LiteralMap node) {
     if (node.isConst()) {
-      ConstantHandler handler = compiler.constantHandler;
-      Constant constant = handler.compileNodeWithDefinitions(node, elements);
-      stack.add(graph.addConstant(constant, compiler));
+      stack.add(addConstant(node));
       return;
     }
     List<HInstruction> inputs = <HInstruction>[];
     for (Link<Node> link = node.entries.nodes;
          !link.isEmpty;
          link = link.tail) {
       visit(link.head);
       inputs.add(pop());
       inputs.add(pop());
     }
@@ skipping 17 matching lines @@
     // First check whether all case expressions are compile-time constants,
     // and all have the same type that doesn't override operator==.
     // TODO(lrn): Move the constant resolution to the resolver, so
     // we can report an error before reaching the backend.
     DartType firstConstantType = null;
     bool failure = false;
     for (SwitchCase switchCase in node.cases) {
       for (Node labelOrCase in switchCase.labelsAndCases) {
         if (labelOrCase is CaseMatch) {
           CaseMatch match = labelOrCase;
-          Constant constant =
-              compiler.constantHandler.compileNodeWithDefinitions(
-                  match.expression, elements, isConst: true);
+          Constant constant = getConstantForNode(match.expression);
           if (firstConstantType == null) {
             firstConstantType = constant.computeType(compiler);
             if (nonPrimitiveTypeOverridesEquals(constant)) {
               compiler.reportFatalError(
                   match.expression,
                   MessageKind.SWITCH_CASE_VALUE_OVERRIDES_EQUALS);
               failure = true;
             }
           }
           constants[labelOrCase] = constant;
@@ skipping 1016 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }