Actually compute AnalysisResult(s).

pkg/analyzer/lib/src/dart/analysis/driver.dart

 // Copyright (c) 2016, 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 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/error/listener.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/context/context.dart';
 import 'package:analyzer/src/context/source.dart';
 import 'package:analyzer/src/dart/analysis/byte_store.dart';
-import 'package:analyzer/src/dart/error/todo_codes.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
 import 'package:analyzer/src/dart/scanner/scanner.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisContext, AnalysisEngine, AnalysisOptions, ChangeSet;
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/summary/api_signature.dart';
-import 'package:analyzer/src/summary/flat_buffers.dart' as fb;
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/link.dart';
 import 'package:analyzer/src/summary/package_bundle_reader.dart';
 import 'package:analyzer/src/summary/summarize_ast.dart';
 import 'package:analyzer/src/summary/summarize_elements.dart';
 import 'package:analyzer/src/util/fast_uri.dart';
 import 'package:convert/convert.dart';
 import 'package:crypto/crypto.dart';
 
@@ skipping 141 matching lines @@
   /**
    * Return the [Stream] that produces [AnalysisResult]s for added files.
    *
    * Analysis starts when the client starts listening to the stream, and stops
    * when the client cancels the subscription.
    *
    * When the client starts listening, the analysis state transitions to
    * "analyzing" and an analysis result is produced for every added file prior
    * to the next time the analysis state transitions to "idle".
    *
-   * Invocation of [addFile] or [changeFile] might result in producing more
-   * analysis results that reflect the new current file state.
+   * At least one analysis result is produced for every file passed to
+   * [addFile] or [changeFile] prior to the next time the analysis state
+   * transitions to "idle". Analysis results for other files are produced
+   * only if the changes affect analysis results of other files.
    *
    * More than one result might be produced for the same file, even if the
    * client does not change the state of the files.
    *
    * Results might be produced even for files that have never been added
    * using [addFile], for example when [getResult] was called for a file.
    */
   Stream<AnalysisResult> get results async* {
     try {
       while (true) {
         // TODO(scheglov) implement state transitioning
         await for (String why in _hasWorkStreamController.stream) {
           _verifyUnlinkedSignatureOfChangedFiles();
 
           // Analyze the first file in the general queue.
           if (_filesToAnalyze.isNotEmpty) {
-            _logger.run('Analyze ${_filesToAnalyze.length} files', () {
+            PerformanceLogSection analysisSection =
+                _logger.enter('Analyze ${_filesToAnalyze.length} files');
+            try {
+              // TODO(scheglov) The loop is strange for now.

[Brian Wilkerson, 2016/10/26 06:45:03]

Describe what needs to be done to fix the strangeness.

               while (_filesToAnalyze.isNotEmpty) {
                 String path = _filesToAnalyze.first;
                 _filesToAnalyze.remove(path);
                 _File file = _fileForPath(path);
-                _computeAndPrintErrors(file);
-                // TODO(scheglov) yield the result
+                AnalysisResult result = _computeAnalysisResult(file);
+                yield result;
               }
-            });
+            } finally {
+              analysisSection.exit();
+            }
           }
         }
         // TODO(scheglov) implement
       }
     } finally {
       print('The stream was cancelled.');
     }
   }
 
   /**
@@ skipping 86 matching lines @@
    * add [UnlinkedUnit] with wrong URI.
    *
    * We need to clean this up.
    */
   void _addToStoreUnlinked(
       SummaryDataStore store, String uri, UnlinkedUnit unlinked) {
     store.unlinkedMap[uri] = unlinked;
   }
 
   /**
-   * TODO(scheglov) replace with actual [AnalysisResult] computing.
+   * Compute the [AnalysisResult] for the [file].
    */
-  List<String> _computeAndPrintErrors(_File file) {
+  AnalysisResult _computeAnalysisResult(_File file) {
     // TODO(scheglov) Computing resolved unit fails for these units.
     // pkg/analyzer/lib/plugin/embedded_resolver_provider.dart
     // pkg/analyzer/lib/plugin/embedded_resolver_provider.dart
     if (file.path.endsWith(
             'pkg/analyzer/lib/plugin/embedded_resolver_provider.dart') ||
         file.path.endsWith('pkg/analyzer/lib/source/embedder.dart') ||
         file.path.endsWith('pkg/analyzer/lib/src/generated/ast.dart') ||
         file.path.endsWith('pkg/analyzer/lib/src/generated/element.dart') ||
         file.path
             .endsWith('pkg/analyzer/lib/src/generated/element_handle.dart') ||
         file.path.endsWith('pkg/analyzer/lib/src/generated/error.dart') ||
         file.path.endsWith('pkg/analyzer/lib/src/generated/scanner.dart') ||
         file.path.endsWith('pkg/analyzer/lib/src/generated/sdk_io.dart') ||
         file.path.endsWith('pkg/analyzer/lib/src/generated/visitors.dart') ||
         file.path.endsWith('pkg/analyzer/test/generated/constant_test.dart') ||
         file.path.endsWith('pkg/analyzer/test/source/embedder_test.dart')) {
-      return [];
+      return new AnalysisResult(
+          file.path, file.uri, null, file.contentHash, null, []);
     }
 
-    List<String> errorStrings = _logger.run('Compute errors $file', () {
+    return _logger.run('Compute analysis result for $file', () {
       _LibraryContext libraryContext = _createLibraryContext(file);
-
-      String errorsKey;
-      {
-        ApiSignature signature = new ApiSignature();
-        signature.addString(libraryContext.node.dependencySignature);
-        signature.addString(file.contentHash);
-        errorsKey = '${signature.toHex()}.errors';
-      }
-
-      {
-        List<int> bytes = _byteStore.get(errorsKey);
-        if (bytes != null) {
-          fb.BufferContext bp = new fb.BufferContext.fromBytes(bytes);
-          int table = bp.derefObject(0);
-          return const fb.ListReader<String>(const fb.StringReader())
-              .vTableGet(bp, table, 0);
-        }
-      }
-
       AnalysisContext analysisContext = _createAnalysisContext(libraryContext);
       analysisContext.setContents(file.source, file.content);
-      try {
-        // Compute resolved unit.
-//        _logger.runTimed('Computed resolved unit', () {
-//          analysisContext.resolveCompilationUnit2(
-//              libraryContext.file.source, libraryContext.file.source);
-//        });
-        // Compute errors.
-        List<AnalysisError> errors = _logger.run('Compute errors', () {
-          return analysisContext.computeErrors(file.source);
-        });
-        List<String> errorStrings = errors
-            .where((error) => error.errorCode is! TodoCode)
-            .map((error) => error.toString())
-            .toList();
-        {
-          fb.Builder fbBuilder = new fb.Builder();
-          var exportedOffset = fbBuilder.writeList(errorStrings
-              .map((errorStr) => fbBuilder.writeString(errorStr))
-              .toList());
-          fbBuilder.startTable();
-          fbBuilder.addOffset(0, exportedOffset);
-          var offset = fbBuilder.endTable();
-          List<int> bytes = fbBuilder.finish(offset, 'CErr');
-          _byteStore.put(errorsKey, bytes);
-        }
-
-        return errorStrings;
-      } finally {
-        analysisContext.dispose();
-      }
+      // TODO(scheglov) Add support for parts.
+      CompilationUnit resolvedUnit =
+          analysisContext.resolveCompilationUnit2(file.source, file.source);
+      List<AnalysisError> errors = analysisContext.computeErrors(file.source);
+      return new AnalysisResult(file.path, file.uri, file.content,
+          file.contentHash, resolvedUnit, errors);
     });
-
-    if (errorStrings.isNotEmpty) {
-      errorStrings.forEach((errorString) => print('\t$errorString'));
-    } else {
-      print('\tNO ERRORS');
-    }
-    return errorStrings;
   }
 
   AnalysisContext _createAnalysisContext(_LibraryContext libraryContext) {
     AnalysisContextImpl analysisContext =
         AnalysisEngine.instance.createAnalysisContext();
 
     analysisContext.sourceFactory =
         new SourceFactory((_sourceFactory as SourceFactoryImpl).resolvers);
     analysisContext.resultProvider =
         new InputPackagesResultProvider(analysisContext, libraryContext.store);
@@ skipping 251 matching lines @@
 /**
  * This class is used to gather and print performance information.
  */
 class PerformanceLog {
   final StringSink sink;
   int _level = 0;
 
   PerformanceLog(this.sink);
 
   /**
+   * Enter a new execution section, which starts at one point of code, runs
+   * some time, and then ends at the other point of code.
+   *
+   * The client must call [PerformanceLogSection.exit] for every [enter].
+   */
+  PerformanceLogSection enter(String msg) {
+    writeln('+++ $msg.');
+    _level++;
+    return new PerformanceLogSection(this, msg);
+  }
+
+  /**
    * Return the result of the function [f] invocation and log the elapsed time.
    *
    * Each invocation of [run] creates a new enclosed section in the log,
    * which begins with printing [msg], then any log output produced during
    * [f] invocation, and ends with printing [msg] with the elapsed time.
    */
   /*=T*/ run/*<T>*/(String msg, /*=T*/ f()) {
     Stopwatch timer = new Stopwatch()..start();
     try {
       writeln('+++ $msg.');
       _level++;
       return f();
     } finally {
       _level--;
       int ms = timer.elapsedMilliseconds;
       writeln('--- $msg in $ms ms.');
     }
   }
 
   /**
    * Write a new line into the log
    */
   void writeln(String msg) {
     String indent = '\t' * _level;
     sink.writeln('$indent$msg');
   }
 }
 
 /**
+ * The performance measurement section for operations that start and end
+ * at different place in code, so cannot be run using [PerformanceLog.run].
+ *
+ * The client must call [exit] for every [PerformanceLog.enter].
+ */
+class PerformanceLogSection {

[Brian Wilkerson, 2016/10/26 06:45:03]

Consider moving logging into a separate library.

+  final PerformanceLog _logger;
+  final String _msg;
+  final Stopwatch _timer = new Stopwatch()..start();
+
+  PerformanceLogSection(this._logger, this._msg);
+
+  /**
+   * Stop the timer, log the time.
+   */
+  void exit() {
+    _timer.stop();
+    _logger._level--;
+    int ms = _timer.elapsedMilliseconds;
+    _logger.writeln('--- $_msg in $ms ms.');
+  }
+}
+
+/**
  * Information about a file being analyzed, explicitly or implicitly.
  *
  * It keeps a consistent view on its [content], [contentHash] and [unit].
  *
  * Instances of this class may only be used during computing a single analysis
  * result and should not be cached anywhere. We need this limitation to prevent
  * references from caches to the resolved [unit], so to element models, etc.
  * The data structures should be short lived - computed, returned to the client,
  * processed there and quickly thrown away.
  */
@@ skipping 268 matching lines @@
       }
     }
     for (UnlinkedExportPublic export in unit.publicNamespace.exports) {
       referenced.exported.add(export.uri);
     }
     return referenced;
   }
 
   _ReferencedUris._();
 }