Add a utility function to parse annotations in a test file.

lib/src/util/dart.dart

 // Copyright (c) 2015, 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 unittest.util.dart;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:isolate';
 
+import 'package:analyzer/src/error.dart';
+import 'package:analyzer/src/generated/ast.dart';
+import 'package:analyzer/src/generated/error.dart';
+import 'package:analyzer/src/generated/parser.dart';
+import 'package:analyzer/src/generated/scanner.dart';
+import 'package:analyzer/src/generated/source_io.dart';
+import 'package:analyzer/src/string_source.dart';
 import 'package:path/path.dart' as p;
 
 import 'io.dart';
 import 'isolate_wrapper.dart';
 import 'remote_exception.dart';
 
 /// Runs [code] in an isolate.
 ///
 /// [code] should be the contents of a Dart entrypoint. It may contain imports;
 /// they will be resolved in the same context as the host isolate. [message] is
@@ skipping 42 matching lines @@
   Isolate.spawnUri(Uri.parse(message['uri']), [], message['message'],
           packageRoot: packageRoot)
       .then((_) => replyTo.send({'type': 'success'}))
       .catchError((error, stackTrace) {
     replyTo.send({
       'type': 'error',
       'error': RemoteException.serialize(error, stackTrace)
     });
   });
 }
+
+/// Parse all the annotations at the beginning of a Dart file.
+///
+/// This will parse annotations until the first non-annotation production is
+/// reached.
+List<Annotation> parseAnnotations(String path) {
+  var contents = new File(path).readAsStringSync();
+  var sourceFactory = new SourceFactory([new FileUriResolver()]);
+
+  var absolutePath = p.absolute(path);
+  var source = sourceFactory.forUri(p.toUri(absolutePath).toString());
+  if (source == null) {
+    throw new ArgumentError("Can't get source for path $path");
+  }
+  if (!source.exists()) {
+    throw new ArgumentError("Source $source doesn't exist");
+  }
+
+  var errorCollector = new _ErrorCollector();
+  var reader = new CharSequenceReader(contents);
+
+  // TODO(nweiz): Avoid scanning the entire file when issue 22745 is fixed.

[Bob Nystrom, 2015/03/11 19:27:17]

I'm really surprised performance is an issue here. In my tests with the
formatter, I can process ~100kloc/s. Are you sure something else isn't going on?

If it were me, I'd just use parse directives and then look up the annotations on
the returned AST nodes.

[nweiz, 2015/03/12 19:24:37]

I was really trying to avoid spending much time on parsing, but I suppose the
simplicity of the existing API is probably better.

+  var scanner = new Scanner(source, reader, errorCollector);
+  var token = scanner.tokenize();
+  var parser = new Parser(source, errorCollector);
+  parser.currentToken = token;
+
+  var annotations = [];
+  while (token.type == TokenType.AT) {
+    annotations.add(parser.parseAnnotation());
+
+    // TODO(nweiz): this is a hack; add something to the analyzer package to
+    // support this better.
+    token = parser.getAndAdvance();
+    parser.currentToken = token;
+  }
+
+  if (errorCollector.hasErrors) throw errorCollector.group;
+
+  return annotations;
+}
+
+/// A simple error listener that collects errors into an [AnalysisErrorGroup].
+class _ErrorCollector extends AnalysisErrorListener {
+  final _errors = <AnalysisError>[];
+
+  _ErrorCollector();
+
+  /// The group of errors collected.
+  AnalyzerErrorGroup get group =>
+      new AnalyzerErrorGroup.fromAnalysisErrors(_errors);
+
+  /// Whether any errors where collected.
+  bool get hasErrors => !_errors.isEmpty;
+
+  void onError(AnalysisError error) => _errors.add(error);
+}
+