Handle int/double literals in inference

pkg/compiler/lib/src/inferrer/kernel_inferrer_engine.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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common_elements.dart';
 import '../compiler.dart';
 import '../constants/values.dart';
 import '../elements/entities.dart';
 import '../elements/types.dart';
+import '../js_model/locals.dart';
 import '../kernel/element_map.dart';
-import '../js_model/locals.dart';
+import '../options.dart';
 import '../types/types.dart';
 import '../world.dart';
 import 'builder_kernel.dart';
 import 'inferrer_engine.dart';
 import 'type_graph_inferrer.dart';
 import 'type_graph_nodes.dart';
 import 'type_system.dart';
 
 class KernelTypeGraphInferrer extends TypeGraphInferrer<ir.Node> {
   final Compiler _compiler;
@@ skipping 44 matching lines @@
   }
 
   GlobalTypeInferenceParameterResult<ir.Node> createParameterResult(
       TypeGraphInferrer<ir.Node> inferrer, Local parameter) {
     return new GlobalTypeInferenceParameterResultImpl<ir.Node>(
         parameter, inferrer, dynamicType);
   }
 }
 
 class KernelInferrerEngine extends InferrerEngineImpl<ir.Node> {
+  final CompilerOptions _options;
   final KernelToElementMapForBuilding _elementMap;
   final GlobalLocalsMap _globalLocalsMap;
   final ClosureDataLookup<ir.Node> _closureDataLookup;
 
   KernelInferrerEngine(
       Compiler compiler,
       this._elementMap,
       this._globalLocalsMap,
       this._closureDataLookup,
       ClosedWorld closedWorld,
       ClosedWorldRefiner closedWorldRefiner,
       FunctionEntity mainElement)
-      : super(
+      : this._options = compiler.options,
+        super(
             compiler,
             closedWorld,
             closedWorldRefiner,
             mainElement,
             new KernelTypeSystemStrategy(
                 _elementMap, _globalLocalsMap, _closureDataLookup));
 
   ElementEnvironment get _elementEnvironment => _elementMap.elementEnvironment;
 
   @override
   ConstantValue getFieldConstant(FieldEntity field) {
     return _elementMap.getFieldConstantValue(field);
   }
 
   @override
   bool isFieldInitializerPotentiallyNull(
       FieldEntity field, ir.Node initializer) {
     // TODO(johnniwinther): Implement the ad-hoc check in ast inferrer?
     return true;
   }
 
   @override
   TypeInformation computeMemberTypeInformation(
       MemberEntity member, ir.Node body) {
-    KernelTypeGraphBuilder visitor =
-        new KernelTypeGraphBuilder(member, compiler, _elementMap, this, body);
+    KernelTypeGraphBuilder visitor = new KernelTypeGraphBuilder(
+        _options, closedWorld, _closureDataLookup, this, member, body);
     return visitor.run();
   }
 
   @override
   FunctionEntity lookupCallMethod(ClassEntity cls) {
     throw new UnimplementedError('KernelInferrerEngine.lookupCallMethod');
   }
 
   @override
   ir.Node computeMemberBody(MemberEntity member) {
@@ skipping 171 matching lines @@
       ConstructorEntity constructor = member;
       if (constructor.isFactoryConstructor) {
         DartType type = _elementEnvironment.getFunctionType(constructor);
         return new FactoryConstructorTypeInformation(constructor, type);
       } else {
         return new GenerativeConstructorTypeInformation(constructor);
       }
     }
   }
 }