Move compile-time constant registrations to the backend.

sdk/lib/_internal/compiler/implementation/js_backend/backend.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 js_backend;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked;
 
   JavaScriptItemCompilationContext()
@@ skipping 301 matching lines @@
 
   /// True if a call to preserveNames has been seen.
   bool mustPreserveNames = false;
 
   /// True if a call to disableTreeShaking has been seen.
   bool isTreeShakingDisabled = false;
 
   /// True if there isn't sufficient @MirrorsUsed data.
   bool hasInsufficientMirrorsUsed = false;
 
-  /// List of instantiated types from metadata.  If metadata must be preserved,
-  /// these types must registered.
-  final List<Dependency> metadataInstantiatedTypes = <Dependency>[];
-
-  /// List of elements used from metadata.  If metadata must be preserved,
-  /// these elements must be compiled.
-  final List<Element> metadataStaticUse = <Element>[];
-
-  /// List of tear-off functions referenced from metadata.  If metadata must be
-  /// preserved, these elements must be compiled.
-  final List<FunctionElement> metadataGetOfStaticFunction = <FunctionElement>[];
+  /// List of constants from metadata.  If metadata must be preserved,
+  /// these constants must be registered.
+  final List<Dependency> metadataConstants = <Dependency>[];
 
   /// List of symbols that the user has requested for reflection.
   final Set<String> symbolsUsed = new Set<String>();
 
   /// List of elements that the user has requested for reflection.
   final Set<Element> targetsUsed = new Set<Element>();
 
   /// List of annotations provided by user that indicate that the annotated
   /// element must be retained.
   final Set<Element> metaTargetsUsed = new Set<Element>();
@@ skipping 395 matching lines @@
     String name = namer.getInterceptorName(getInterceptorMethod, classes);
     if (classes.contains(jsInterceptorClass)) {
       // We can't use a specialized [getInterceptorMethod], so we make
       // sure we emit the one with all checks.
       specializedGetInterceptors[name] = interceptedClasses;
     } else {
       specializedGetInterceptors[name] = classes;
     }
   }
 
+

[ahe, 2013/09/30 11:05:26]

Extra line.

[Johnni Winther, 2013/10/01 11:21:48]

Done.

+  Constant registerCompileTimeConstant(Constant constant,
+                                       TreeElements elements) {
+    registerCompileTimeConstantInternal(constant, elements);
+    for (Constant dependency in constant.getDependencies()) {
+      registerCompileTimeConstant(dependency, elements);
+    }
+  }
+
+  void registerCompileTimeConstantInternal(Constant constant,
+                                           TreeElements elements) {
+    DartType type = constant.computeType(compiler);

[ahe, 2013/09/30 11:05:26]

Add todo to get rid of Constant.computeType?

[Johnni Winther, 2013/10/01 11:21:48]

Done.

+    registerInstantiatedConstantType(type, elements);
+
+    if (constant.isFunction()) {
+      FunctionConstant function = constant;
+      compiler.enqueuer.codegen.registerGetOfStaticFunction(function.element);
+    } else if (constant.isInterceptor()) {
+      // An interceptor constant references the class's prototype chain.
+      InterceptorConstant interceptor = constant;
+      registerInstantiatedConstantType(interceptor.dispatchedType, elements);
+    }
+  }
+
+  void registerInstantiatedConstantType(DartType type, TreeElements elements) {
+    Enqueuer enqueuer = compiler.enqueuer.codegen;
+    enqueuer.registerInstantiatedType(type, elements);
+    if (type is InterfaceType && !type.treatAsRaw &&
+        classNeedsRti(type.element)) {
+      enqueuer.registerStaticUse(getSetRuntimeTypeInfo());
+    }
+    if (type.element == typeImplementation) {
+      // 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.
+      enqueuer.registerStaticUse(getCreateRuntimeType());
+    }
+  }
+
+  void registerMetadataConstant(Constant constant, TreeElements elements) {
+    if (mustRetainMetadata) {
+      registerCompileTimeConstant(constant, elements);
+    } else {
+      metadataConstants.add(new Dependency(constant, elements));
+    }
+  }
+
   void registerInstantiatedClass(ClassElement cls,
                                  Enqueuer enqueuer,
                                  TreeElements elements) {
     if (!seenAnyClass) {
       seenAnyClass = true;
       if (enqueuer.isResolutionQueue) {
         // TODO(9577): Make it so that these are not needed when there are no
         // native classes.
         enqueue(enqueuer, getNativeInterceptorMethod, elements);
         enqueue(enqueuer, defineNativeMethodsFinishMethod, elements);
@@ skipping 422 matching lines @@
 
   void codegen(CodegenWorkItem work) {
     Element element = work.element;
     var kind = element.kind;
     if (kind == ElementKind.TYPEDEF) return;
     if (element.isConstructor() && element.getEnclosingClass() == jsNullClass) {
       // Work around a problem compiling JSNull's constructor.
       return;
     }
     if (kind.category == ElementCategory.VARIABLE) {
-      Constant initialValue = compiler.constantHandler.compileWorkItem(work);
+      Constant initialValue =
+          compiler.constantHandler.getConstantForVariable(element);
       if (initialValue != null) {
+        registerCompileTimeConstant(initialValue, work.resolutionTree);
+        compiler.constantHandler.addCompileTimeConstantForEmission(
+            initialValue);
         return;
       } else {
         // If the constant-handler was not able to produce a result we have to
         // go through the builder (below) to generate the lazy initializer for
         // the static variable.
         // We also need to register the use of the cyclic-error helper.
         compiler.enqueuer.codegen.registerStaticUse(getCyclicThrowHelper());
       }
     }
 
@@ skipping 403 matching lines @@
     if (name == const SourceString('')) return false;
     return symbolsUsed.contains(name.slowToString());
   }
 
   bool get rememberLazies => isTreeShakingDisabled;
 
   bool retainMetadataOf(Element element) {
     if (mustRetainMetadata) hasRetainedMetadata = true;
     if (mustRetainMetadata && isNeededForReflection(element)) {
       for (MetadataAnnotation metadata in element.metadata) {
-        metadata.ensureResolved(compiler)
-            .value.accept(new ConstantCopier(compiler.constantHandler));
+        metadata.ensureResolved(compiler);
+        compiler.constantHandler.addCompileTimeConstantForEmission(
+            metadata.value);
       }
       return true;
     }
     return false;
   }
 
   Future onLibraryLoaded(LibraryElement library, Uri uri) {
     if (uri == Uri.parse('dart:_js_mirrors')) {
       disableTreeShakingMarker =
           library.find(const SourceString('disableTreeShaking'));
       preserveMetadataMarker =
           library.find(const SourceString('preserveMetadata'));
     } else if (uri == Uri.parse('dart:_js_names')) {
       preserveNamesMarker =
           library.find(const SourceString('preserveNames'));
     }
     return new Future.value();
   }
 
-  void registerMetadataInstantiatedType(DartType type, TreeElements elements) {
-    if (mustRetainMetadata) {
-      compiler.constantHandler.registerInstantiatedType(type, elements);
-    } else {
-      metadataInstantiatedTypes.add(new Dependency(type, elements));
-    }
-  }
-
-  void registerMetadataStaticUse(Element element) {
-    if (mustRetainMetadata) {
-      compiler.constantHandler.registerStaticUse(element);
-    } else {
-      metadataStaticUse.add(element);
-    }
-  }
-
-  void registerMetadataGetOfStaticFunction(FunctionElement element) {
-    if (mustRetainMetadata) {
-      compiler.constantHandler.registerGetOfStaticFunction(element);
-    } else {
-      metadataGetOfStaticFunction.add(element);
-    }
-  }
-
   void registerMirrorUsage(Set<String> symbols,
                            Set<Element> targets,
                            Set<Element> metaTargets) {
     if (symbols == null && targets == null && metaTargets == null) {
       // The user didn't specify anything, or there are imports of
       // 'dart:mirrors' without @MirrorsUsed.
       hasInsufficientMirrorsUsed = true;
       return;
     }
     if (symbols != null) symbolsUsed.addAll(symbols);
@@ skipping 100 matching lines @@
     }
 
     if (isTreeShakingDisabled) enqueuer.enqueueEverything();
 
     if (mustPreserveNames) compiler.log('Preserving names.');
 
     if (mustRetainMetadata) {
       compiler.log('Retaining metadata.');
 
       compiler.libraries.values.forEach(retainMetadataOf);
-      for (Dependency dependency in metadataInstantiatedTypes) {
-        registerMetadataInstantiatedType(dependency.type, dependency.user);
+      for (Dependency dependency in metadataConstants) {

[ngeoffray, 2013/10/01 08:33:35]

Why is that not covered by registerMetadataConstant?

[Johnni Winther, 2013/10/01 11:21:48]

This handles the late registration, when [mustRetainMetadata] has been set to
[:true:] after the constants have been registered with
[registerMetadataConstant].

+        registerCompileTimeConstant(
+            dependency.constant, dependency.user);
       }
-      metadataInstantiatedTypes.clear();
-      for (Element e in metadataStaticUse) {
-        registerMetadataStaticUse(e);
-      }
-      metadataStaticUse.clear();
-      for (Element e in metadataGetOfStaticFunction) {
-        registerMetadataGetOfStaticFunction(e);
-      }
-      metadataGetOfStaticFunction.clear();
+      metadataConstants.clear();
     }
   }
 }
 
-/// Records that [type] is used by [user.element].
+/// Records that [constant] is used by [user.element].
 class Dependency {
-  final DartType type;
+  final Constant constant;
   final TreeElements user;
 
-  const Dependency(this.type, this.user);
+  const Dependency(this.constant, this.user);
 }
 
 /// Used to copy metadata to the the actual constant handler.
 class ConstantCopier implements ConstantVisitor {
   final ConstantHandler target;
 
   ConstantCopier(this.target);
 
   void copy(/* Constant or List<Constant> */ value) {
     if (value is Constant) {
@@ skipping 30 matching lines @@
     copy(constant.values);
     copy(constant.protoValue);
     copy(constant);
   }
 
   void visitConstructed(ConstructedConstant constant) {
     copy(constant.fields);
     copy(constant);
   }
 }