Introduce a testing framework for use with fasta type inference.

pkg/front_end/lib/src/fasta/kernel/kernel_shadow_ast.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.
 
 /// This file declares a "shadow hierarchy" of concrete classes which extend
 /// the kernel class hierarchy, adding methods and fields needed by the
 /// BodyBuilder.
 ///
 /// Instances of these classes may be created using the factory methods in
 /// `ast_factory.dart`.
 ///
 /// Note that these classes represent the Dart language prior to desugaring.
 /// When a single Dart construct desugars to a tree containing multiple kernel
 /// AST nodes, the shadow class extends the kernel object at the top of the
 /// desugared tree.
 ///
 /// This means that in some cases multiple shadow classes may extend the same
 /// kernel class, because multiple constructs in Dart may desugar to a tree
 /// with the same kind of root node.
+import 'package:front_end/src/base/instrumentation.dart';
 import 'package:front_end/src/fasta/type_inference/type_inferrer.dart';
 import 'package:kernel/ast.dart';
 import 'package:kernel/class_hierarchy.dart';
 import 'package:kernel/core_types.dart';
 
 /// Concrete shadow object representing a statement block in kernel form.
 class KernelBlock extends Block implements KernelStatement {
   KernelBlock(List<KernelStatement> statements) : super(statements);
 
   @override
@@ skipping 75 matching lines @@
 abstract class KernelStatement extends Statement {
   /// Calls back to [inferrer] to perform type inference for whatever concrete
   /// type of [KernelStatement] this is.
   void _inferStatement(KernelTypeInferrer inferrer);
 }
 
 /// Concrete implementation of [TypeInferrer] specialized to work with kernel
 /// objects.
 class KernelTypeInferrer extends TypeInferrer<Statement, Expression,
     KernelVariableDeclaration, Field> {
-  KernelTypeInferrer(CoreTypes coreTypes, ClassHierarchy classHierarchy)
-      : super(coreTypes, classHierarchy);
+  KernelTypeInferrer(CoreTypes coreTypes, ClassHierarchy classHierarchy,
+      Instrumentation instrumentation)
+      : super(coreTypes, classHierarchy, instrumentation);
 
   @override
   DartType inferExpression(
       Expression expression, DartType typeContext, bool typeNeeded) {
     if (expression is KernelExpression) {
       // Use polymorphic dispatch on [KernelExpression] to perform whatever kind
       // of type inference is correct for this kind of statement.
       // TODO(paulberry): experiment to see if dynamic dispatch would be better,
       // so that the type hierarchy will be simpler (which may speed up "is"
       // checks).
@@ skipping 50 matching lines @@
   KernelVariableGet(VariableDeclaration variable, [DartType promotedType])
       : super(variable, promotedType);
 
   @override
   DartType _inferExpression(
       KernelTypeInferrer inferrer, DartType typeContext, bool typeNeeded) {
     // TODO(paulberry): implement.
     return typeNeeded ? const DynamicType() : null;
   }
 }