Handle int constant

pkg/compiler/lib/src/js_emitter/interceptor_stub_generator.dart

 // Copyright (c) 2014, 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.
 
 library dart2js.js_emitter.interceptor_stub_generator;
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
 
 import '../common_elements.dart';
 import '../constants/values.dart';
 import '../elements/entities.dart';
 import '../elements/types.dart' show InterfaceType;
 import '../js/js.dart' as jsAst;
 import '../js/js.dart' show js;
 import '../js_backend/namer.dart' show Namer;
-import '../js_backend/constant_handler_javascript.dart'
-    show JavaScriptConstantCompiler;
 import '../js_backend/custom_elements_analysis.dart'
     show CustomElementsCodegenAnalysis;
 import '../js_backend/native_data.dart';
 import '../js_backend/interceptor_data.dart';
 import '../native/enqueue.dart';
 import '../options.dart';
 import '../universe/selector.dart' show Selector;
 import '../universe/world_builder.dart' show CodegenWorldBuilder;
 import '../world.dart' show ClosedWorld;
 
 import 'code_emitter_task.dart' show CodeEmitterTask, Emitter;
 
 class InterceptorStubGenerator {
   final CompilerOptions _options;
   final CommonElements _commonElements;
   final CodeEmitterTask _emitterTask;
   final NativeCodegenEnqueuer _nativeCodegenEnqueuer;
-  final JavaScriptConstantCompiler _constants;
   final Namer _namer;
   final OneShotInterceptorData _oneShotInterceptorData;
   final CustomElementsCodegenAnalysis _customElementsCodegenAnalysis;
   final CodegenWorldBuilder _codegenWorldBuilder;
   final ClosedWorld _closedWorld;
 
   InterceptorStubGenerator(
       this._options,
       this._commonElements,
       this._emitterTask,
       this._nativeCodegenEnqueuer,
-      this._constants,
       this._namer,
       this._oneShotInterceptorData,
       this._customElementsCodegenAnalysis,
       this._codegenWorldBuilder,
       this._closedWorld);
 
   NativeData get _nativeData => _closedWorld.nativeData;
 
   InterceptorData get _interceptorData => _closedWorld.interceptorData;
 
@@ skipping 352 matching lines @@
     ]);
   }
 
   jsAst.ArrayInitializer generateTypeToInterceptorMap() {
     // TODO(sra): Perhaps inject a constant instead?
     CustomElementsCodegenAnalysis analysis = _customElementsCodegenAnalysis;
     if (!analysis.needsTable) return null;
 
     List<jsAst.Expression> elements = <jsAst.Expression>[];
     List<ConstantValue> constants =
-        _constants.getConstantsForEmission(_emitter.compareConstants);
+        _codegenWorldBuilder.getConstantsForEmission(_emitter.compareConstants);
     for (ConstantValue constant in constants) {
       if (constant is TypeConstantValue &&
           constant.representedType is InterfaceType) {
         InterfaceType type = constant.representedType;
         ClassEntity classElement = type.element;
         if (!analysis.needsClass(classElement)) continue;
 
         elements.add(_emitter.constantReference(constant));
         elements.add(_emitter.interceptorClassAccess(classElement));
 
@@ skipping 19 matching lines @@
         }
 
         var map = new jsAst.ObjectInitializer(properties);
         elements.add(map);
       }
     }
 
     return new jsAst.ArrayInitializer(elements);
   }
 }