Implement 'Sort Members' for the new analysis driver.

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:typed_data';
 
 import 'package:analyzer/dart/ast/ast.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/dart/analysis/byte_store.dart';
 import 'package:analyzer/src/dart/analysis/file_state.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisContext, AnalysisEngine, AnalysisOptions, ChangeSet;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/summary/api_signature.dart';
 import 'package:analyzer/src/summary/format.dart';
 import 'package:analyzer/src/summary/idl.dart';
@@ skipping 356 matching lines @@
 
   /**
    * Return `true` if the file with the given [path] was explicitly added
    * to analysis using [addFile].
    */
   bool isAddedFile(String path) {
     return _explicitFiles.contains(path);
   }
 
   /**
+   * Return the [Future] that completes with a [ParseResult] for the file
+   * with the given [path].
+   *
+   * The [path] must be absolute and normalized.
+   *
+   * The [path] can be any file - explicitly or implicitly analyzed, or neither.
+   *
+   * The parsing is performed in the method itself, and the result is not
+   * produced through the [results] stream (just because it is not a fully
+   * resolved unit).
+   */
+  Future<ParseResult> parseFile(String path) async {
+    FileState file = _fsState.getFileForPath(path);
+    RecordingErrorListener listener = new RecordingErrorListener();
+    CompilationUnit unit = file.parse(listener);
+    return new ParseResult(file.path, file.uri, file.content, file.contentHash,
+        unit.lineInfo, unit, listener.errors);
+  }
+
+  /**
    * Remove the file with the given [path] from the list of files to analyze.
    *
    * The [path] must be absolute and normalized.
    *
    * The results of analysis of the file might still be produced by the
    * [results] stream. The driver will try to stop producing these results,
    * but does not guarantee this.
    */
   void removeFile(String path) {
     _explicitFiles.remove(path);
@@ skipping 392 matching lines @@
    */
   bool get isAnalyzing => _analyzing;
 
   /**
    * Return `true` is the driver is idle.
    */
   bool get isIdle => !_analyzing;
 }
 
 /**
+ * The result of parsing of a single file.
+ *
+ * These results are self-consistent, i.e. [content], [contentHash], the
+ * resolved [unit] correspond to each other. But none of the results is
+ * guaranteed to be consistent with the state of the files.
+ */
+class ParseResult {
+  /**
+   * The path of the parsed file, absolute and normalized.
+   */
+  final String path;
+
+  /**
+   * The URI of the file that corresponded to the [path].
+   */
+  final Uri uri;
+
+  /**
+   * The content of the file that was scanned and parsed.
+   */
+  final String content;
+
+  /**
+   * The MD5 hash of the [content].
+   */
+  final String contentHash;
+
+  /**
+   * Information about lines in the [content].
+   */
+  final LineInfo lineInfo;
+
+  /**
+   * The parsed, unresolved compilation unit for the [content].
+   */
+  final CompilationUnit unit;
+
+  /**
+   * The scanning and parsing errors.
+   */
+  final List<AnalysisError> errors;
+
+  ParseResult(this.path, this.uri, this.content, this.contentHash,
+      this.lineInfo, this.unit, this.errors);
+}
+
+/**
  * 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
@@ skipping 145 matching lines @@
   /**
    * Complete the [signal] future if it is not completed yet. It is safe to
    * call this method multiple times, but the [signal] will complete only once.
    */
   void notify() {
     if (!_completer.isCompleted) {
       _completer.complete(null);
     }
   }
 }