Rename analyzer_experimental to analyzer.

pkg/observe/lib/transform.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.transform;
 
 import 'dart:async';
 
-import 'package:analyzer_experimental/src/generated/java_core.dart' show CharSequence;
-import 'package:analyzer_experimental/src/generated/ast.dart';
-import 'package:analyzer_experimental/src/generated/error.dart';
-import 'package:analyzer_experimental/src/generated/parser.dart';
-import 'package:analyzer_experimental/src/generated/scanner.dart';
+import 'package:analyzer/src/generated/java_core.dart' show CharSequence;
+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.
  *
  * The transformation adds hooks for field setters and notifies the observation
  * system of the change.
@@ skipping 53 matching lines @@
       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_experimental. */
+/** Parse [code] using analyzer. */
 CompilationUnit _parseCompilationUnit(String code) {
   var errorListener = new _ErrorCollector();
   var reader = new CharSequenceReader(new CharSequence(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_experimental, so it isn't feasible yet.
+// that is expensive in analyzer, so it isn't feasible yet.
 bool _isObservableAnnotation(Annotation node) =>
     _isAnnotationContant(node, 'observable') ||
     _isAnnotationContant(node, 'published') ||
     _isAnnotationType(node, 'ObservableProperty') ||
     _isAnnotationType(node, 'PublishedProperty');
 
 bool _isAnnotationContant(Annotation m, String name) =>
     m.name.name == name && m.constructorName == null && m.arguments == null;
 
 bool _isAnnotationType(Annotation m, String name) => m.name == name;
@@ skipping 280 matching lines @@
 
 Token _findFieldSeperator(Token token) {
   while (token != null) {
     if (token.type == TokenType.COMMA || token.type == TokenType.SEMICOLON) {
       break;
     }
     token = token.next;
   }
   return token;
 }