Move compile-time constant registrations to the backend.

sdk/lib/_internal/compiler/implementation/compile_time_constants.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 dart2js;
 
 /**
  * The [ConstantHandler] keeps track of compile-time constants,
  * initializations of global and static fields, and default values of
  * optional parameters.
@@ skipping 11 matching lines @@
 
   /** Set of all registered compiled constants. */
   final Set<Constant> compiledConstants;
 
   /** The set of variable elements that are in the process of being computed. */
   final Set<VariableElement> pendingVariables;
 
   /** Caches the statics where the initial value cannot be eagerly compiled. */
   final Set<VariableElement> lazyStatics;
 
-  /** Caches the createRuntimeType function if registered. */
-  Element createRuntimeTypeFunction = null;
-
-  /** Caches the setRuntimeTypeInfo function if registered. */
-  Element setRuntimeTypeInfoFunction = null;
-
   ConstantHandler(Compiler compiler, this.constantSystem,
                   { bool this.isMetadata: false })
       : initialVariableValues = new Map<VariableElement, dynamic>(),
         compiledConstants = new Set<Constant>(),
         pendingVariables = new Set<VariableElement>(),
         lazyStatics = new Set<VariableElement>(),
         super(compiler);
 
   String get name => 'ConstantHandler';
 
-  void registerCompileTimeConstant(Constant constant, TreeElements elements) {
-    registerInstantiatedType(constant.computeType(compiler), elements);
-    if (constant.isFunction()) {
-      FunctionConstant function = constant;
-      registerGetOfStaticFunction(function.element);
-    } else if (constant.isInterceptor()) {
-      // An interceptor constant references the class's prototype chain.
-      InterceptorConstant interceptor = constant;
-      registerInstantiatedType(interceptor.dispatchedType, elements);
-    }
+  void addCompileTimeConstantForEmission(Constant constant) {
     compiledConstants.add(constant);
   }
 
-  void registerInstantiatedType(DartType type, TreeElements elements) {
-    if (isMetadata) {
-      compiler.backend.registerMetadataInstantiatedType(type, elements);
-      return;
-    }
-    compiler.enqueuer.codegen.registerInstantiatedType(type, elements);
-    if (type is InterfaceType &&
-        !type.treatAsRaw &&
-        compiler.backend.classNeedsRti(type.element)) {
-      registerSetRuntimeTypeInfoFunction();
-    }
-  }
-
-  void registerStaticUse(Element element) {
-    if (isMetadata) {
-      compiler.backend.registerMetadataStaticUse(element);
-      return;
-    }
-    compiler.analyzeElement(element.declaration);
-    compiler.enqueuer.codegen.registerStaticUse(element);
-  }
-
-  void registerGetOfStaticFunction(FunctionElement element) {
-    if (isMetadata) {
-      compiler.backend.registerMetadataGetOfStaticFunction(element);
-      return;
-    }
-    compiler.analyzeElement(element.declaration);
-    compiler.enqueuer.codegen.registerGetOfStaticFunction(element);
-  }
-
-  void registerStringInstance(TreeElements elements) {
-    registerInstantiatedType(compiler.stringClass.rawType, elements);
-  }
-
-  void registerSetRuntimeTypeInfoFunction() {
-    if (setRuntimeTypeInfoFunction != null) return;
-    SourceString helperName = const SourceString('setRuntimeTypeInfo');
-    setRuntimeTypeInfoFunction = compiler.findHelper(helperName);
-    registerStaticUse(setRuntimeTypeInfoFunction);
-  }
-
-  void registerCreateRuntimeTypeFunction() {
-    if (createRuntimeTypeFunction != null) return;
-    SourceString helperName = const SourceString('createRuntimeType');
-    createRuntimeTypeFunction = compiler.findHelper(helperName);
-    registerStaticUse(createRuntimeTypeFunction);
+  Constant getConstantForVariable(VariableElement element) {
+    return initialVariableValues[element];
   }
 
   /**
-   * Compiles the initial value of the given field and stores it in an internal
-   * map. Returns the initial value (a constant) if it can be computed
-   * statically. Returns [:null:] if the variable must be initialized lazily.
-   *
-   * [work] must contain a [VariableElement] refering to a global or
-   * static field.
-   */
-  Constant compileWorkItem(CodegenWorkItem work) {
-    return measure(() {
-      assert(work.element.kind == ElementKind.FIELD
-             || work.element.kind == ElementKind.PARAMETER
-             || work.element.kind == ElementKind.FIELD_PARAMETER);
-      VariableElement element = work.element;
-      // Shortcut if it has already been compiled.
-      Constant result = initialVariableValues[element];
-      if (result != null) return result;
-      if (lazyStatics.contains(element)) return null;
-      result = compileVariableWithDefinitions(element, work.resolutionTree);
-      assert(pendingVariables.isEmpty);
-      return result;
-    });
-  }
-
-  /**
    * Returns a compile-time constant, or reports an error if the element is not
    * a compile-time constant.
    */
   Constant compileConstant(VariableElement element) {
     return compileVariable(element, isConst: true);
   }
 
   /**
    * Returns the a compile-time constant if the variable could be compiled
    * eagerly. Otherwise returns `null`.
@@ skipping 89 matching lines @@
                                       TreeElements definitions,
                                       {bool isConst: false}) {
     return measure(() {
       assert(node != null);
       CompileTimeConstantEvaluator evaluator = new CompileTimeConstantEvaluator(
           this, definitions, compiler, isConst: isConst);
       return evaluator.evaluate(node);
     });
   }
 
-  /** Attempts to compile a constant expression. Returns null if not possible */
-  Constant tryCompileNodeWithDefinitions(Node node, TreeElements definitions) {
-    return measure(() {
-      assert(node != null);
-      try {
-        TryCompileTimeConstantEvaluator evaluator =
-            new TryCompileTimeConstantEvaluator(this, definitions, compiler);
-        return evaluator.evaluate(node);
-      } on CompileTimeConstantError catch (exn) {
-        return null;
-      }
-    });
-  }
-
   /**
    * Returns an [Iterable] of static non final fields that need to be
    * initialized. The fields list must be evaluated in order since they might
    * depend on each other.
    */
   Iterable<VariableElement> getStaticNonFinalFieldsForEmission() {
     return initialVariableValues.keys.where((element) {
       return element.kind == ElementKind.FIELD
           && !element.isInstanceMember()
           && !element.modifiers.isFinal()
@@ skipping 83 matching lines @@
     isEvaluatingConstant = oldIsEvaluatingConstant;
     assert(result != null);
     return result;
   }
 
   Constant visitNode(Node node) {
     return signalNotCompileTimeConstant(node);
   }
 
   Constant visitLiteralBool(LiteralBool node) {
-    handler.registerInstantiatedType(compiler.boolClass.rawType, elements);
     return constantSystem.createBool(node.value);
   }
 
   Constant visitLiteralDouble(LiteralDouble node) {
-    handler.registerInstantiatedType(compiler.doubleClass.rawType, elements);
     return constantSystem.createDouble(node.value);
   }
 
   Constant visitLiteralInt(LiteralInt node) {
-    handler.registerInstantiatedType(compiler.intClass.rawType, elements);
     return constantSystem.createInt(node.value);
   }
 
   Constant visitLiteralList(LiteralList node) {
     if (!node.isConst())  {
       return signalNotCompileTimeConstant(node);
     }
     List<Constant> arguments = <Constant>[];
     for (Link<Node> link = node.elements.nodes;
          !link.isEmpty;
          link = link.tail) {
       arguments.add(evaluateConstant(link.head));
     }
     DartType type = elements.getType(node);
-    handler.registerInstantiatedType(type, elements);
-    Constant constant = new ListConstant(type, arguments);
-    handler.registerCompileTimeConstant(constant, elements);
-    return constant;
+    return new ListConstant(type, arguments);
   }
 
   Constant visitLiteralMap(LiteralMap node) {
     if (!node.isConst()) {
       return signalNotCompileTimeConstant(node);
     }
     List<Constant> keys = <Constant>[];
     Map<Constant, Constant> map = new Map<Constant, Constant>();
     for (Link<Node> link = node.entries.nodes;
          !link.isEmpty;
@@ skipping 24 matching lines @@
     InterfaceType sourceType = elements.getType(node);
     DartType keysType;
     if (sourceType.treatAsRaw) {
       keysType = compiler.listClass.rawType;
     } else {
       Link<DartType> arguments =
           new Link<DartType>.fromList([sourceType.typeArguments.head]);
       keysType = new InterfaceType(compiler.listClass, arguments);
     }
     ListConstant keysList = new ListConstant(keysType, keys);
-    if (onlyStringKeys) {
-      handler.registerCompileTimeConstant(keysList, elements);
-    }
     SourceString className = onlyStringKeys
         ? (hasProtoKey ? MapConstant.DART_PROTO_CLASS
                        : MapConstant.DART_STRING_CLASS)
         : MapConstant.DART_GENERAL_CLASS;
     ClassElement classElement = compiler.jsHelperLibrary.find(className);
     classElement.ensureResolved(compiler);
     Link<DartType> typeArgument = sourceType.typeArguments;
     InterfaceType type;
     if (sourceType.treatAsRaw) {
       type = classElement.rawType;
     } else {
       type = new InterfaceType(classElement, typeArgument);
     }
-    Constant constant =
-        new MapConstant(type, keysList, values, protoValue, onlyStringKeys);
-    handler.registerCompileTimeConstant(constant, elements);
-    return constant;
+    return new MapConstant(type, keysList, values, protoValue, onlyStringKeys);
   }
 
   Constant visitLiteralNull(LiteralNull node) {
     return constantSystem.createNull();
   }
 
   Constant visitLiteralString(LiteralString node) {
-    handler.registerStringInstance(elements);
     return constantSystem.createString(node.dartString, node);
   }
 
   Constant visitStringJuxtaposition(StringJuxtaposition node) {
     StringConstant left = evaluate(node.first);
     StringConstant right = evaluate(node.second);
     if (left == null || right == null) return null;
-    handler.registerStringInstance(elements);
     return constantSystem.createString(
         new DartString.concat(left.value, right.value), node);
   }
 
   Constant visitStringInterpolation(StringInterpolation node) {
     StringConstant initialString = evaluate(node.string);
     if (initialString == null) return null;
     DartString accumulator = initialString.value;
     for (StringInterpolationPart part in node.parts) {
       Constant expression = evaluate(part.expression);
       DartString expressionString;
       if (expression == null) {
         return signalNotCompileTimeConstant(part.expression);
       } else if (expression.isNum() || expression.isBool()) {
         PrimitiveConstant primitive = expression;
         expressionString = new DartString.literal(primitive.value.toString());
       } else if (expression.isString()) {
         PrimitiveConstant primitive = expression;
         expressionString = primitive.value;
       } else {
         return signalNotCompileTimeConstant(part.expression);
       }
       accumulator = new DartString.concat(accumulator, expressionString);
       StringConstant partString = evaluate(part.string);
       if (partString == null) return null;
       accumulator = new DartString.concat(accumulator, partString.value);
     };
-    handler.registerStringInstance(elements);
     return constantSystem.createString(accumulator, node);
   }
 
   Constant visitLiteralSymbol(LiteralSymbol node) {
-    handler.registerStringInstance(elements);
     InterfaceType type = compiler.symbolClass.computeType(compiler);
     List<Constant> createArguments(_) {
       return [constantSystem.createString(
         new DartString.literal(node.slowNameString), node)];
     }
     return makeConstructedConstant(
         node, type, compiler.symbolConstructor, createArguments);
   }
 
   Constant makeTypeConstant(Element element) {
     DartType elementType = element.computeType(compiler).asRaw();
     compiler.backend.registerTypeLiteral(
         element, compiler.enqueuer.codegen, elements);
     DartType constantType =
         compiler.backend.typeImplementation.computeType(compiler);
-    Constant constant = new TypeConstant(elementType, constantType);
-    // If we use a type literal in a constant, the compile time
-    // constant emitter will generate a call to the createRuntimeType
-    // helper so we register a use of that.
-    handler.registerCreateRuntimeTypeFunction();
-    handler.registerCompileTimeConstant(constant, elements);
-    return constant;
+    return new TypeConstant(elementType, constantType);
   }
 
   // TODO(floitsch): provide better error-messages.
   Constant visitSend(Send send) {
     Element element = elements[send];
     if (send.isPropertyAccess) {
       if (Elements.isStaticOrTopLevelFunction(element)) {
-        Constant constant = new FunctionConstant(element);
-        handler.registerCompileTimeConstant(constant, elements);
-        return constant;
+        return new FunctionConstant(element);
       } else if (Elements.isStaticOrTopLevelField(element)) {
         Constant result;
         if (element.modifiers.isConst()) {
           result = handler.compileConstant(element);
         } else if (element.modifiers.isFinal() && !isEvaluatingConstant) {
           result = handler.compileVariable(element);
         }
         if (result != null) return result;
       } else if (Elements.isClass(element) || Elements.isTypedef(element)) {
         return makeTypeConstant(element);
@@ skipping 201 matching lines @@
     // initializers are handled correctly.
     constructor = constructor.implementation;
     assert(invariant(node, constructor.isImplementation));
 
     List<Constant> arguments = getArguments(constructor);
     ConstructorEvaluator evaluator =
         new ConstructorEvaluator(constructor, handler, compiler);
     evaluator.evaluateConstructorFieldValues(arguments);
     List<Constant> jsNewArguments = evaluator.buildJsNewArguments(classElement);
 
-    handler.registerInstantiatedType(type, elements);
-    Constant constant = new ConstructedConstant(type, jsNewArguments);
-    handler.registerCompileTimeConstant(constant, elements);
-    return constant;
+    return new ConstructedConstant(type, jsNewArguments);
   }
 
   Constant visitParenthesizedExpression(ParenthesizedExpression node) {
     return node.expression.accept(this);
   }
 
   error(Node node) {
     // TODO(floitsch): get the list of constants that are currently compiled
     // and present some kind of stack-trace.
     compiler.reportFatalError(
@@ skipping 207 matching lines @@
           if (fieldValue == null) {
             // Use the default value.
             fieldValue = handler.compileConstant(field);
           }
           jsNewArguments.add(fieldValue);
         },
         includeSuperAndInjectedMembers: true);
     return jsNewArguments;
   }
 }