Instrument analyzer's type analysis and run front_end inference tests.

pkg/analyzer/lib/src/generated/resolver.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 analyzer.src.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/dart/element/visitor.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/ast/utilities.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/member.dart' show ConstructorMember;
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/resolver/inheritance_manager.dart';
 import 'package:analyzer/src/dart/resolver/scope.dart';
 import 'package:analyzer/src/error/codes.dart';
+import 'package:analyzer/src/fasta/uri_instrumentation.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element_resolver.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error_verifier.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/static_type_analyzer.dart';
 import 'package:analyzer/src/generated/testing/element_factory.dart';
 import 'package:analyzer/src/generated/type_system.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 
@@ skipping 4167 matching lines @@
   // hash table help in an instance of this class.
   static const String _typeProperty =
       'analyzer.src.generated.InferenceContext.contextType';
 
   /**
    * The error listener on which to record inference information.
    */
   final ErrorReporter _errorReporter;
 
   /**
+   * The instrumentation to report inference information.
+   */
+  final UriInstrumentation _instrumentation;
+
+  /**
    * If true, emit hints when types are inferred
    */
   final bool _inferenceHints;
 
   /**
    * Type provider, needed for type matching.
    */
   final TypeProvider _typeProvider;
 
   /**
    * The type system in use.
    */
   final TypeSystem _typeSystem;
 
   /**
    * When no context type is available, this will track the least upper bound
    * of all return statements in a lambda.
    *
    * This will always be kept in sync with [_returnStack].
    */
   final List<DartType> _inferredReturn = <DartType>[];
 
   /**
    * A stack of return types for all of the enclosing
    * functions and methods.
    */
   final List<DartType> _returnStack = <DartType>[];
 
-  InferenceContext._(this._errorReporter, TypeProvider typeProvider,
-      this._typeSystem, this._inferenceHints)
+  InferenceContext._(TypeProvider typeProvider, this._typeSystem,
+      this._inferenceHints, this._errorReporter, this._instrumentation)
       : _typeProvider = typeProvider;
 
   /**
    * Get the return type of the current enclosing function, if any.
    *
    * The type returned for a function is the type that is expected
    * to be used in a return or yield context.  For ordinary functions
    * this is the same as the return type of the function.  For async
    * functions returning Future<T> and for generator functions
    * returning Stream<T> or Iterable<T>, this is T.
@@ skipping 43 matching lines @@
   void pushReturnContext(BlockFunctionBody node) {
     _returnStack.add(getContext(node));
     _inferredReturn.add(_typeProvider.nullType);
   }
 
   /**
    * Place an info node into the error stream indicating that a
    * [type] has been inferred as the type of [node].
    */
   void recordInference(Expression node, DartType type) {
+    _instrumentation?.recordInference(node.offset, type);
+
     if (!_inferenceHints) {
       return;
     }
 
     ErrorCode error;
     if (node is Literal) {
       error = StrongModeCode.INFERRED_TYPE_LITERAL;
     } else if (node is InstanceCreationExpression) {
       error = StrongModeCode.INFERRED_TYPE_ALLOCATION;
     } else if (node is FunctionExpression) {
@@ skipping 668 matching lines @@
    * The object used to compute the type associated with the current node.
    */
   StaticTypeAnalyzer typeAnalyzer;
 
   /**
    * The type system in use during resolution.
    */
   TypeSystem typeSystem;
 
   /**
+   * The instrumentation to report inference information.
+   */
+  final UriInstrumentation instrumentation;
+
+  /**
    * The class declaration representing the class containing the current node, or `null` if
    * the current node is not contained in a class.
    */
   ClassDeclaration _enclosingClassDeclaration = null;
 
   /**
    * The function type alias representing the function type containing the current node, or
    * `null` if the current node is not contained in a function type alias.
    */
   FunctionTypeAlias _enclosingFunctionTypeAlias = null;
@@ skipping 48 matching lines @@
    * node that will first be visited.  If `null` or unspecified, a new
    * [LibraryScope] will be created based on [definingLibrary] and
    * [typeProvider]. The [inheritanceManager] is used to perform inheritance
    * lookups.  If `null` or unspecified, a new [InheritanceManager] will be
    * created based on [definingLibrary]. The [typeAnalyzerFactory] is used to
    * create the type analyzer.  If `null` or unspecified, a type analyzer of
    * type [StaticTypeAnalyzer] will be created.
    */
   ResolverVisitor(LibraryElement definingLibrary, Source source,
       TypeProvider typeProvider, AnalysisErrorListener errorListener,
-      {Scope nameScope})
+      {Scope nameScope, this.instrumentation})
       : super(definingLibrary, source, typeProvider, errorListener,
             nameScope: nameScope) {
     AnalysisOptions options = definingLibrary.context.analysisOptions;
     this.strongMode = options.strongMode;
     this.elementResolver = new ElementResolver(this);
     this.typeSystem = definingLibrary.context.typeSystem;
     bool strongModeHints = false;
     if (options is AnalysisOptionsImpl) {
       strongModeHints = options.strongModeHints;
     }
-    this.inferenceContext = new InferenceContext._(
-        errorReporter, typeProvider, typeSystem, strongModeHints);
+    this.inferenceContext = new InferenceContext._(typeProvider, typeSystem,
+        strongModeHints, errorReporter, instrumentation);
     this.typeAnalyzer = new StaticTypeAnalyzer(this);
   }
 
   /**
    * Return the element representing the function containing the current node, or `null` if
    * the current node is not contained in a function.
    *
    * @return the element representing the function containing the current node
    */
   ExecutableElement get enclosingFunction => _enclosingFunction;
@@ skipping 5852 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }