Handle int constant

pkg/compiler/lib/src/universe/codegen_world_builder.dart

 // Copyright (c) 2017, 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 world_builder;
 
 /// World builder specific to codegen.
 ///
 /// This adds additional access to liveness of selectors and elements.
 abstract class CodegenWorldBuilder implements WorldBuilder {
@@ skipping 30 matching lines @@
   Iterable<FunctionEntity> get staticFunctionsNeedingGetter;
   Iterable<FunctionEntity> get methodsNeedingSuperGetter;
 
   /// The set of all referenced static fields.
   ///
   /// Invariant: Elements are declaration elements.
   Iterable<FieldEntity> get allReferencedStaticFields;
 
   /// Set of methods in instantiated classes that are potentially closurized.
   Iterable<FunctionEntity> get closurizedMembers;
+
+  /// Register [constant] as needed for emission.
+  void addCompileTimeConstantForEmission(ConstantValue constant);
+
+  /// Returns a list of constants topologically sorted so that dependencies
+  /// appear before the dependent constant.
+  ///
+  /// [preSortCompare] is a comparator function that gives the constants a
+  /// consistent order prior to the topological sort which gives the constants
+  /// an ordering that is less sensitive to perturbations in the source code.
+  List<ConstantValue> getConstantsForEmission(
+      [Comparator<ConstantValue> preSortCompare]);
 }
 
 abstract class CodegenWorldBuilderImpl implements CodegenWorldBuilder {
   final ElementEnvironment _elementEnvironment;
   final NativeBasicData _nativeBasicData;
   final ClosedWorld _world;
 
   /// The set of all directly instantiated classes, that is, classes with a
   /// generative constructor that has been called directly and not only through
   /// a super-call.
@@ skipping 419 matching lines @@
         return true;
       }
       return false;
     }
 
     while (cls != null && processClass(cls)) {
       cls = _elementEnvironment.getSuperClass(cls);
     }
   }
 
-  bool registerConstantUse(ConstantUse use);
+  /// Set of all registered compiled constants.
+  final Set<ConstantValue> compiledConstants = new Set<ConstantValue>();
+
+  @override
+  void addCompileTimeConstantForEmission(ConstantValue constant) {
+    compiledConstants.add(constant);
+  }
+
+  @override
+  List<ConstantValue> getConstantsForEmission(
+      [Comparator<ConstantValue> preSortCompare]) {
+    // We must emit dependencies before their uses.
+    Set<ConstantValue> seenConstants = new Set<ConstantValue>();
+    List<ConstantValue> result = new List<ConstantValue>();
+
+    void addConstant(ConstantValue constant) {
+      if (!seenConstants.contains(constant)) {
+        constant.getDependencies().forEach(addConstant);
+        assert(!seenConstants.contains(constant));
+        result.add(constant);
+        seenConstants.add(constant);
+      }
+    }
+
+    List<ConstantValue> sorted = compiledConstants.toList();
+    if (preSortCompare != null) {
+      sorted.sort(preSortCompare);
+    }
+    sorted.forEach(addConstant);
+    return result;
+  }
+
+  /// Register the constant [use] with this world builder. Returns `true` if
+  /// the constant use was new to the world.
+  bool registerConstantUse(ConstantUse use) {
+    if (use.kind == ConstantUseKind.DIRECT) {
+      addCompileTimeConstantForEmission(use.value);
+    }
+    return _constantValues.add(use.value);
+  }
 }
 
 class ElementCodegenWorldBuilderImpl extends CodegenWorldBuilderImpl {
-  final JavaScriptConstantCompiler _constants;
-
   ElementCodegenWorldBuilderImpl(
       ElementEnvironment elementEnvironment,
       NativeBasicData nativeBasicData,
       ClosedWorld world,
-      this._constants,
       SelectorConstraintsStrategy selectorConstraintsStrategy)
       : super(elementEnvironment, nativeBasicData, world,
             selectorConstraintsStrategy);
 
   /// Calls [f] with every instance field, together with its declarer, in an
   /// instance of [cls].
   void forEachInstanceField(
       ClassElement cls, void f(ClassEntity declarer, FieldEntity field)) {
     cls.implementation
         .forEachInstanceField(f, includeSuperAndInjectedMembers: true);
@@ skipping 23 matching lines @@
     return super._getMemberUsage(member, memberUsed);
   }
 
   void registerStaticUse(StaticUse staticUse, MemberUsedCallback memberUsed) {
     Element element = staticUse.element;
     assert(element.isDeclaration,
         failedAt(element, "Element ${element} is not the declaration."));
     super.registerStaticUse(staticUse, memberUsed);
   }
 
-  /// Register the constant [use] with this world builder. Returns `true` if
-  /// the constant use was new to the world.
-  @override
-  bool registerConstantUse(ConstantUse use) {
-    if (use.kind == ConstantUseKind.DIRECT) {
-      _constants.addCompileTimeConstantForEmission(use.value);
-    }
-    return _constantValues.add(use.value);
-  }
-
   void registerIsCheck(ResolutionDartType type) {
     // Even in checked mode, type annotations for return type and argument
     // types do not imply type checks, so there should never be a check
     // against the type variable of a typedef.
     assert(!type.isTypeVariable || !type.element.enclosingElement.isTypedef);
     super.registerIsCheck(type);
   }
 }
 
 class KernelCodegenWorldBuilder extends CodegenWorldBuilderImpl {
   KernelCodegenWorldBuilder(
       ElementEnvironment elementEnvironment,
       NativeBasicData nativeBasicData,
       ClosedWorld world,
       SelectorConstraintsStrategy selectorConstraintsStrategy)
       : super(elementEnvironment, nativeBasicData, world,
             selectorConstraintsStrategy);
 
   @override
-  bool registerConstantUse(ConstantUse use) {
-    throw new UnimplementedError(
-        'KernelCodegenWorldBuilder.registerConstantUse');
-  }
-
-  @override
   void forEachParameter(
       FunctionEntity function, void f(DartType type, String name)) {
     throw new UnimplementedError('KernelCodegenWorldBuilder.forEachParameter');
   }
 
   @override
   void forEachInstanceField(
       ClassEntity cls, void f(ClassEntity declarer, FieldEntity field)) {
     throw new UnimplementedError(
         'KernelCodegenWorldBuilder.forEachInstanceField');
   }
 }