Handle variable declarations in inferrer

pkg/compiler/lib/src/inferrer/builder_kernel.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 '../constants/constant_system.dart';
 import '../elements/entities.dart';
+import '../elements/types.dart';
+import '../kernel/element_map.dart';
 import '../options.dart';
 import '../types/constants.dart';
 import '../world.dart';
 import 'inferrer_engine.dart';
 import 'locals_handler.dart';
 import 'type_graph_nodes.dart';
 import 'type_system.dart';
 
 /// [KernelTypeGraphBuilder] constructs a type-inference graph for a particular
 /// element.
 ///
 /// Calling [run] will start the work of visiting the body of the code to
 /// construct a set of inference-nodes that abstractly represent what the code
 /// is doing.
 class KernelTypeGraphBuilder extends ir.Visitor<TypeInformation> {
   final CompilerOptions _options;
   final ClosedWorld _closedWorld;
   final ClosureDataLookup<ir.Node> _closureDataLookup;
   final InferrerEngine<ir.Node> _inferrer;
   final TypeSystem<ir.Node> _types;
   final MemberEntity _analyzedMember;
   final ir.Node _analyzedNode;
+  final KernelToElementMapForBuilding _elementMap;
+  final KernelToLocalsMap _localsMap;
   LocalsHandler _locals;
 
   TypeInformation _returnType;
 
   KernelTypeGraphBuilder(
       this._options,
       this._closedWorld,
       this._closureDataLookup,
       this._inferrer,
       this._analyzedMember,
       this._analyzedNode,
+      this._elementMap,
+      this._localsMap,
       [this._locals])
       : this._types = _inferrer.types {
     if (_locals != null) return;
 
     FieldInitializationScope<ir.Node> fieldScope =
         _analyzedNode is ir.Constructor
             ? new FieldInitializationScope(_types)
             : null;
     _locals = new LocalsHandler(
         _inferrer, _types, _options, _analyzedNode, fieldScope);
@@ skipping 34 matching lines @@
     MemberEntity member = _analyzedMember;
     if (member is ConstructorEntity && member.isGenerativeConstructor) {
       _locals.fieldScope.isIndefinite = true;
     }
   }
 
   TypeInformation visit(ir.Node node) {
     return node == null ? null : node.accept(this);
   }
 
+  void visitList(List<ir.Node> nodes) {
+    if (nodes == null) return;
+    nodes.forEach(visit);
+  }
+
   @override
   TypeInformation visitFunctionNode(ir.FunctionNode node) {
     // TODO(redemption): Handle constructors.
     // TODO(redemption): Handle native methods.
-    // TODO(redemption): Set up parameters.
+    visitList(node.positionalParameters);
+    visitList(node.namedParameters);
     visit(node.body);
     switch (node.asyncMarker) {
       case ir.AsyncMarker.Sync:
         if (_returnType == null) {
           // No return in the body.
           _returnType = _locals.seenReturnOrThrow
               ? _types.nonNullEmpty() // Body always throws.
               : _types.nullType;
         } else if (!_locals.seenReturnOrThrow) {
           // We haven'TypeInformation seen returns on all branches. So the method may
@@ skipping 87 matching lines @@
   }
 
   @override
   TypeInformation visitDoubleLiteral(ir.DoubleLiteral node) {
     ConstantSystem constantSystem = _closedWorld.constantSystem;
     // The JavaScript backend may turn this literal into an integer at
     // runtime.
     return _types.getConcreteTypeFor(
         computeTypeMask(_closedWorld, constantSystem.createDouble(node.value)));
   }
+
+  @override
+  TypeInformation visitVariableDeclaration(ir.VariableDeclaration node) {
+    Local local = _localsMap.getLocalVariable(node);
+    DartType type = _localsMap.getLocalType(_elementMap, local);
+    if (node.initializer == null) {
+      _locals.update(local, _types.nullType, node, type);
+    } else {
+      _locals.update(local, visit(node.initializer), node, type);
+    }
+    return null;
+  }
+
+  @override
+  TypeInformation visitVariableGet(ir.VariableGet node) {
+    return _locals.use(_localsMap.getLocalVariable(node.variable));
+  }
 }