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

pkg/analyzer/lib/src/dart/analysis/library_analyzer.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:analyzer/context/declared_variables.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/src/context/context.dart';
 import 'package:analyzer/src/dart/analysis/file_state.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/ast/utilities.dart';
 import 'package:analyzer/src/dart/constant/evaluation.dart';
 import 'package:analyzer/src/dart/constant/utilities.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/error/pending_error.dart';
+import 'package:analyzer/src/fasta/uri_instrumentation.dart';
 import 'package:analyzer/src/generated/declaration_resolver.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error_verifier.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/services/lint.dart';
 import 'package:analyzer/src/summary/package_bundle_reader.dart';
 import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/src/task/strong/checker.dart';
+import 'package:front_end/src/base/instrumentation.dart' as fasta;
 import 'package:front_end/src/dependency_walker.dart';
 
 /**
  * Analyzer of a single library.
  */
 class LibraryAnalyzer {
   final AnalysisOptions _analysisOptions;
   final DeclaredVariables _declaredVariables;
   final SourceFactory _sourceFactory;
   final FileSystemState _fsState;
   final SummaryDataStore _store;
   final FileState _library;
+  final fasta.Instrumentation _instrumentation;
 
   TypeProvider _typeProvider;
   AnalysisContextImpl _context;
   StoreBasedSummaryResynthesizer _resynthesizer;
   LibraryElement _libraryElement;
 
   final Map<FileState, LineInfo> _fileToLineInfo = {};
   final Map<FileState, IgnoreInfo> _fileToIgnoreInfo = {};
 
   final Map<FileState, RecordingErrorListener> _errorListeners = {};
   final Map<FileState, ErrorReporter> _errorReporters = {};
   final List<UsedImportedElements> _usedImportedElementsList = [];
   final List<UsedLocalElements> _usedLocalElementsList = [];
   final Map<FileState, List<PendingError>> _fileToPendingErrors = {};
   final List<ConstantEvaluationTarget> _constants = [];
 
-  LibraryAnalyzer(this._analysisOptions, this._declaredVariables,
-      this._sourceFactory, this._fsState, this._store, this._library);
+  LibraryAnalyzer(
+      this._analysisOptions,
+      this._declaredVariables,
+      this._sourceFactory,
+      this._fsState,
+      this._store,
+      this._library,
+      this._instrumentation);
 
   /**
    * Compute analysis results for all units of the library.
    */
   Map<FileState, UnitAnalysisResult> analyze() {
     Map<FileState, CompilationUnit> units = {};
 
     // Parse all files.
     units[_library] = _parse(_library);
     for (FileState part in _library.partedFiles) {
@@ skipping 437 matching lines @@
   }
 
   void _resolveFile(FileState file, CompilationUnit unit) {
     Source source = file.source;
     if (source == null) {
       return;
     }
 
     RecordingErrorListener errorListener = _getErrorListener(file);
 
+    UriInstrumentation instrumentation = _instrumentation != null
+        ? new UriInstrumentation(_instrumentation, file.uri)
+        : null;
+
     CompilationUnitElement unitElement = unit.element;
 
     // TODO(scheglov) Hack: set types for top-level variables
     // Otherwise TypeResolverVisitor will set declared types, and because we
     // don't run InferStaticVariableTypeTask, we will stuck with these declared
     // types. And we don't need to run this task - resynthesized elements have
     // inferred types.
     for (var e in unitElement.topLevelVariables) {
       if (!e.isSynthetic) {
         e.type;
+        if (instrumentation != null && e.hasImplicitType) {
+          instrumentation.recordTopType(e.nameOffset, e.type);
+        }
       }
     }
 
     new DeclarationResolver().resolve(unit, unitElement);
 
     // TODO(scheglov) remove EnumMemberBuilder class
 
     new TypeParameterBoundsResolver(
             _typeProvider, _libraryElement, source, errorListener)
         .resolveTypeBounds(unit);
 
     unit.accept(new TypeResolverVisitor(
         _libraryElement, source, _typeProvider, errorListener));
 
     LibraryScope libraryScope = new LibraryScope(_libraryElement);
     unit.accept(new VariableResolverVisitor(
         _libraryElement, source, _typeProvider, errorListener,
         nameScope: libraryScope));
 
     unit.accept(new PartialResolverVisitor(_libraryElement, source,
         _typeProvider, AnalysisErrorListener.NULL_LISTENER));
 
     // Nothing for RESOLVED_UNIT8?
     // Nothing for RESOLVED_UNIT9?
     // Nothing for RESOLVED_UNIT10?
 
     unit.accept(new ResolverVisitor(
-        _libraryElement, source, _typeProvider, errorListener));
+        _libraryElement, source, _typeProvider, errorListener,
+        instrumentation: instrumentation));
 
     //
     // Find constants to compute.
     //
     {
       ConstantFinder constantFinder = new ConstantFinder();
       unit.accept(constantFinder);
       _constants.addAll(constantFinder.constantsToCompute);
     }
 
@@ skipping 221 matching lines @@
 }
 
 /**
  * Either the name or the source associated with a part-of directive.
  */
 class _NameOrSource {
   final String name;
   final Source source;
   _NameOrSource(this.name, this.source);
 }