Use parseDirectives were possible. Also mark analyzer ready to be released.

pkg/observe/lib/transformer.dart

 // Copyright (c) 2013, 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.
 
 /// Code transform for @observable. The core transformation is relatively
 /// straightforward, and essentially like an editor refactoring.
 library observe.transformer;
 
 import 'dart:async';
 
+import 'package:analyzer/analyzer.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:barback/barback.dart';
 import 'package:source_maps/refactor.dart';
 import 'package:source_maps/span.dart' show SourceFile;
 
 /// A [Transformer] that replaces observables based on dirty-checking with an
 /// implementation based on change notifications.
@@ skipping 56 matching lines @@
       // TODO(sigmund): emit source maps when barback supports it (see
       // dartbug.com/12340)
       printer.build(url);
       transform.addOutput(new Asset.fromString(id, printer.text));
     });
   }
 }
 
 TextEditTransaction _transformCompilationUnit(
     String inputCode, SourceFile sourceFile, TransformLogger logger) {
-  var unit = _parseCompilationUnit(inputCode);
+  var unit = parseCompilationUnit(inputCode, suppressErrors: true);
   var code = new TextEditTransaction(inputCode, sourceFile);
   for (var directive in unit.directives) {
     if (directive is LibraryDirective && _hasObservable(directive)) {
       logger.warning('@observable on a library no longer has any effect. '
           'It should be placed on individual fields.',
           span: _getSpan(sourceFile, directive));
       break;
     }
   }
 
   for (var declaration in unit.declarations) {
     if (declaration is ClassDeclaration) {
       _transformClass(declaration, code, sourceFile, logger);
     } else if (declaration is TopLevelVariableDeclaration) {
       if (_hasObservable(declaration)) {
         logger.warning('Top-level fields can no longer be observable. '
             'Observable fields should be put in an observable objects.',
             span: _getSpan(sourceFile, declaration));
       }
     }
   }
   return code;
 }
 
-/// Parse [code] using analyzer.
-CompilationUnit _parseCompilationUnit(String code) {
-  var errorListener = new _ErrorCollector();
-  var reader = new CharSequenceReader(code);
-  var scanner = new Scanner(null, reader, errorListener);
-  var token = scanner.tokenize();
-  var parser = new Parser(null, errorListener);
-  return parser.parseCompilationUnit(token);
-}
-
-class _ErrorCollector extends AnalysisErrorListener {
-  final errors = <AnalysisError>[];
-  onError(error) => errors.add(error);
-}
-
 _getSpan(SourceFile file, AstNode node) => file.span(node.offset, node.end);
 
 /// True if the node has the `@observable` or `@published` annotation.
 // TODO(jmesserly): it is not good to be hard coding Polymer support here.
 bool _hasObservable(AnnotatedNode node) =>
     node.metadata.any(_isObservableAnnotation);
 
 // TODO(jmesserly): this isn't correct if the annotation has been imported
 // with a prefix, or cases like that. We should technically be resolving, but
 // that is expensive in analyzer, so it isn't feasible yet.
@@ skipping 290 matching lines @@
 
 Token _findFieldSeperator(Token token) {
   while (token != null) {
     if (token.type == TokenType.COMMA || token.type == TokenType.SEMICOLON) {
       break;
     }
     token = token.next;
   }
   return token;
 }