Fresh drop of analyzer-experimental.

pkg/analyzer-experimental/lib/src/generated/engine.dart

Index: pkg/analyzer-experimental/lib/src/generated/engine.dart
===================================================================
--- pkg/analyzer-experimental/lib/src/generated/engine.dart	(revision 0)
+++ pkg/analyzer-experimental/lib/src/generated/engine.dart	(revision 0)
@@ -0,0 +1,660 @@
+// This code was auto-generated, is not intended to be edited, and is subject to
+// significant change. Please see the README file for more information.
+
+library engine;
+
+import 'java_core.dart';
+import 'dart:collection' show HasNextIterator;
+import 'error.dart';
+import 'source.dart';
+import 'scanner.dart' show Token, CharBufferScanner, StringScanner;
+import 'ast.dart' show CompilationUnit;
+import 'parser.dart' show Parser;
+import 'element.dart';
+import 'resolver.dart' show Namespace, NamespaceBuilder, LibraryResolver;
+
+/**
+ * The unique instance of the class {@code AnalysisEngine} serves as the entry point for the
+ * functionality provided by the analysis engine.
+ */
+class AnalysisEngine {

[Jennifer Messerly, 2013/02/13 21:36:54]

Can't wait to try using this! Would be nice to have an example too when it's
ready :)

(The parser example was a nice starting point.)

+  /**
+   * The unique instance of this class.
+   */
+  static AnalysisEngine _UniqueInstance = new AnalysisEngine();
+  /**
+   * Return the unique instance of this class.
+   * @return the unique instance of this class
+   */
+  static AnalysisEngine get instance => _UniqueInstance;
+  /**
+   * The logger that should receive information about errors within the analysis engine.
+   */
+  Logger _logger = Logger.NULL;
+  /**
+   * Prevent the creation of instances of this class.
+   */
+  AnalysisEngine() : super() {
+  }
+  /**
+   * Create a new context in which analysis can be performed.
+   * @return the analysis context that was created
+   */
+  AnalysisContext createAnalysisContext() => new AnalysisContextImpl();
+  /**
+   * Return the logger that should receive information about errors within the analysis engine.
+   * @return the logger that should receive information about errors within the analysis engine
+   */
+  Logger get logger => _logger;
+  /**
+   * Set the logger that should receive information about errors within the analysis engine to the
+   * given logger.
+   * @param logger the logger that should receive information about errors within the analysis
+   * engine
+   */
+  void set logger(Logger logger2) {
+    this._logger = logger2 == null ? Logger.NULL : logger2;
+  }
+}
+/**
+ * The interface {@code AnalysisContext} defines the behavior of objects that represent a context in
+ * which analysis can be performed. The context includes such information as the version of the SDK
+ * being analyzed against as well as the package-root used to resolve 'package:' URI's. This
+ * information is included indirectly through the {@link SourceFactory source factory}.
+ * <p>
+ * Analysis engine allows for having more than one context. This can be used, for example, to
+ * perform one analysis based on the state of files on disk and a separate analysis based on the
+ * state of those files in open editors. It can also be used to perform an analysis based on a
+ * proposed future state, such as after a refactoring.
+ */
+abstract class AnalysisContext {
+  /**
+   * Clear any cached information that is dependent on resolution. This method should be invoked if
+   * the assumptions used by resolution have changed but the contents of the file have not changed.
+   * Use {@link #sourceChanged(Source)} and {@link #sourcesDeleted(SourceContainer)} to indicate
+   * when the contents of a file or files have changed.
+   */
+  void clearResolution();
+  /**
+   * Call this method when this context is no longer going to be used. At this point, the receiver
+   * may choose to push some of its information back into the global cache for consumption by
+   * another context for performance.
+   */
+  void discard();
+  /**
+   * Create a new context in which analysis can be performed. Any sources in the specified directory
+   * in the receiver will be removed from the receiver and added to the newly created context.
+   * @param directory the directory (not {@code null}) containing sources that should be removed
+   * from the receiver and added to the returned context
+   * @return the analysis context that was created (not {@code null})
+   */
+  AnalysisContext extractAnalysisContext(SourceContainer container);
+  /**
+   * Answer the collection of sources that have been added to the receiver via{@link #sourceAvailable(Source)} and not removed from the receiver via{@link #sourceDeleted(Source)} or {@link #sourcesDeleted(SourceContainer)}.
+   * @return a collection of sources (not {@code null}, contains no {@code null}s)
+   */
+  Collection<Source> get availableSources;
+  /**
+   * Return the element referenced by the given location.
+   * @param location the reference describing the element to be returned
+   * @return the element referenced by the given location
+   */
+  Element getElement(ElementLocation location);
+  /**
+   * Return an array containing all of the errors associated with the given source.
+   * @param source the source whose errors are to be returned
+   * @return all of the errors associated with the given source
+   * @throws AnalysisException if the errors could not be determined because the analysis could not
+   * be performed
+   */
+  List<AnalysisError> getErrors(Source source);
+  /**
+   * Parse and build an element model for the HTML file defined by the given source.
+   * @param source the source defining the HTML file whose element model is to be returned
+   * @return the element model corresponding to the HTML file defined by the given source
+   */
+  HtmlElement getHtmlElement(Source source);
+  /**
+   * Return the kind of the given source if it is already known, or {@code null} if the kind is not
+   * already known.
+   * @param source the source whose kind is to be returned
+   * @return the kind of the given source
+   * @see #getOrComputeKindOf(Source)
+   */
+  SourceKind getKnownKindOf(Source source);
+  /**
+   * Return the element model corresponding to the library defined by the given source. If the
+   * element model does not yet exist it will be created. The process of creating an element model
+   * for a library can long-running, depending on the size of the library and the number of
+   * libraries that are imported into it that also need to have a model built for them.
+   * @param source the source defining the library whose element model is to be returned
+   * @return the element model corresponding to the library defined by the given source or{@code null} if the element model could not be determined because the analysis could
+   * not be performed
+   */
+  LibraryElement getLibraryElement(Source source);
+  /**
+   * Return the element model corresponding to the library defined by the given source, or{@code null} if the element model does not yet exist.
+   * @param source the source defining the library whose element model is to be returned
+   * @return the element model corresponding to the library defined by the given source
+   */
+  LibraryElement getLibraryElementOrNull(Source source);
+  /**
+   * Return the kind of the given source, computing it's kind if it is not already known.
+   * @param source the source whose kind is to be returned
+   * @return the kind of the given source
+   * @see #getKnownKindOf(Source)
+   */
+  SourceKind getOrComputeKindOf(Source source);
+  /**
+   * Return an array containing all of the parsing errors associated with the given source.
+   * @param source the source whose errors are to be returned
+   * @return all of the parsing errors associated with the given source
+   * @throws AnalysisException if the errors could not be determined because the analysis could not
+   * be performed
+   */
+  List<AnalysisError> getParsingErrors(Source source);
+  /**
+   * Return an array containing all of the resolution errors associated with the given source.
+   * @param source the source whose errors are to be returned
+   * @return all of the resolution errors associated with the given source
+   * @throws AnalysisException if the errors could not be determined because the analysis could not
+   * be performed
+   */
+  List<AnalysisError> getResolutionErrors(Source source);
+  /**
+   * Return the source factory used to create the sources that can be analyzed in this context.
+   * @return the source factory used to create the sources that can be analyzed in this context
+   */
+  SourceFactory get sourceFactory;
+  /**
+   * Add the sources contained in the specified context to the receiver's collection of sources.
+   * This method is called when an existing context's pubspec has been removed, and the contained
+   * sources should be reanalyzed as part of the receiver.
+   * @param context the context being merged (not {@code null})
+   */
+  void mergeAnalysisContext(AnalysisContext context);
+  /**
+   * Parse a single source to produce an AST structure. The resulting AST structure may or may not
+   * be resolved, and may have a slightly different structure depending upon whether it is resolved.
+   * @param source the source to be parsed
+   * @return the AST structure representing the content of the source
+   * @throws AnalysisException if the analysis could not be performed
+   */
+  CompilationUnit parse(Source source);
+  /**
+   * Parse and resolve a single source within the given context to produce a fully resolved AST.
+   * @param source the source to be parsed and resolved
+   * @param library the library defining the context in which the source file is to be resolved
+   * @return the result of resolving the AST structure representing the content of the source
+   * @throws AnalysisException if the analysis could not be performed
+   */
+  CompilationUnit resolve(Source source, LibraryElement library);
+  /**
+   * Scan a single source to produce a token stream.
+   * @param source the source to be scanned
+   * @param errorListener the listener to which errors should be reported
+   * @return the head of the token stream representing the content of the source
+   * @throws AnalysisException if the analysis could not be performed
+   */
+  Token scan(Source source, AnalysisErrorListener errorListener);
+  /**
+   * Set the source factory used to create the sources that can be analyzed in this context to the
+   * given source factory.
+   * @param sourceFactory the source factory used to create the sources that can be analyzed in this
+   * context
+   */
+  void set sourceFactory(SourceFactory sourceFactory4);
+  /**
+   * Cache the fact that content for the given source is now available, is of interest to the
+   * client, and should be analyzed. Do not modify or discard any information about this source that
+   * is already cached.
+   * @param source the source that is now available
+   */
+  void sourceAvailable(Source source);
+  /**
+   * Respond to the fact that the content of the given source has changed by removing any cached
+   * information that might now be out-of-date.
+   * @param source the source whose content has changed
+   */
+  void sourceChanged(Source source);
+  /**
+   * Respond to the fact that the given source has been deleted and should no longer be analyzed by
+   * removing any cached information that might now be out-of-date.
+   * @param source the source that was deleted
+   */
+  void sourceDeleted(Source source);
+  /**
+   * Discard cached information for all files in the specified source container.
+   * @param container the source container that was deleted (not {@code null})
+   */
+  void sourcesDeleted(SourceContainer container);
+  /**
+   * Given a collection of sources with content that has changed, return an {@link Iterable}identifying the sources that need to be resolved.
+   * @param changedSources an array of sources (not {@code null}, contains no {@code null}s)
+   * @return An iterable returning the sources to be resolved
+   */
+  Iterable<Source> sourcesToResolve(List<Source> changedSources);
+}
+/**
+ * Instances of the class {@code AnalysisException} represent an exception that occurred during the
+ * analysis of one or more sources.
+ */
+class AnalysisException extends JavaException {
+  /**
+   * Initialize a newly created exception.
+   */
+  AnalysisException() : super() {
+    _jtd_constructor_117_impl();
+  }
+  _jtd_constructor_117_impl() {
+  }
+  /**
+   * Initialize a newly created exception to have the given message.
+   * @param message the message associated with the exception
+   */
+  AnalysisException.con1(String message) : super(message) {
+    _jtd_constructor_118_impl(message);
+  }
+  _jtd_constructor_118_impl(String message) {
+  }
+  /**
+   * Initialize a newly created exception to have the given message and cause.
+   * @param message the message associated with the exception
+   * @param cause the underlying exception that caused this exception
+   */
+  AnalysisException.con2(String message, Exception cause) : super(message, cause) {
+    _jtd_constructor_119_impl(message, cause);
+  }
+  _jtd_constructor_119_impl(String message, Exception cause) {
+  }
+  /**
+   * Initialize a newly created exception to have the given cause.
+   * @param cause the underlying exception that caused this exception
+   */
+  AnalysisException.con3(Exception cause) : super.withCause(cause) {
+    _jtd_constructor_120_impl(cause);
+  }
+  _jtd_constructor_120_impl(Exception cause) {
+  }
+}
+/**
+ * Instances of the class {@code AnalysisContextImpl} implement an {@link AnalysisContext analysis
+ * context}.
+ */
+class AnalysisContextImpl implements AnalysisContext {
+  /**
+   * The source factory used to create the sources that can be analyzed in this context.
+   */
+  SourceFactory _sourceFactory;
+  /**
+   * A cache mapping sources to the compilation units that were produced for the contents of the
+   * source.
+   */
+  Map<Source, CompilationUnit> _parseCache = new Map<Source, CompilationUnit>();
+  /**
+   * A cache mapping sources (of the defining compilation units of libraries) to the library
+   * elements for those libraries.
+   */
+  Map<Source, LibraryElement> _libraryElementCache = new Map<Source, LibraryElement>();
+  /**
+   * A cache mapping sources (of the defining compilation units of libraries) to the public
+   * namespace for that library.
+   */
+  Map<Source, Namespace> _publicNamespaceCache = new Map<Source, Namespace>();
+  /**
+   * A cache of the available sources of interest to the client. Sources are added to this
+   * collection via {@link #sourceAvailable(Source)} and removed from this collection via{@link #sourceDeleted(Source)} and {@link #directoryDeleted(File)}
+   */
+  Set<Source> _availableSources = new Set<Source>();
+  /**
+   * The object used to synchronize access to all of the caches.
+   */
+  Object _cacheLock = new Object();
+  /**
+   * The suffix used by sources that contain Dart.
+   */
+  static String _DART_SUFFIX = ".dart";
+  /**
+   * The suffix used by sources that contain HTML.
+   */
+  static String _HTML_SUFFIX = ".html";
+  /**
+   * Initialize a newly created analysis context.
+   */
+  AnalysisContextImpl() : super() {
+  }
+  void clearResolution() {
+    {
+      _parseCache.clear();
+      _libraryElementCache.clear();
+      _publicNamespaceCache.clear();
+    }
+  }
+  void discard() {
+    {
+      _parseCache.clear();
+      _libraryElementCache.clear();
+      _publicNamespaceCache.clear();
+      _availableSources.clear();
+    }
+  }
+  AnalysisContext extractAnalysisContext(SourceContainer container) {
+    AnalysisContext newContext = AnalysisEngine.instance.createAnalysisContext();
+    {
+      JavaIterator<Source> iter = new JavaIterator(_availableSources);
+      while (iter.hasNext) {
+        Source source = iter.next();
+        if (container.contains(source)) {
+          iter.remove();
+          newContext.sourceAvailable(source);
+        }
+      }
+    }
+    return newContext;
+  }
+  Collection<Source> get availableSources {
+    {
+      return new List<Source>.from(_availableSources);
+    }
+  }
+  Element getElement(ElementLocation location) {
+    throw new UnsupportedOperationException();
+  }
+  List<AnalysisError> getErrors(Source source) {
+    throw new UnsupportedOperationException();
+  }
+  HtmlElement getHtmlElement(Source source) {
+    throw new UnsupportedOperationException();
+  }
+  SourceKind getKnownKindOf(Source source) {
+    if (source.fullName.endsWith(_HTML_SUFFIX)) {
+      return SourceKind.HTML;
+    }
+    if (!source.fullName.endsWith(_DART_SUFFIX)) {
+      return SourceKind.UNKNOWN;
+    }
+    {
+      if (_libraryElementCache.containsKey(source)) {
+        return SourceKind.LIBRARY;
+      }
+      CompilationUnit unit = _parseCache[source];
+      if (unit != null && hasPartOfDirective(unit)) {
+        return SourceKind.PART;
+      }
+    }
+    return null;
+  }
+  LibraryElement getLibraryElement(Source source) {
+    {
+      LibraryElement element = _libraryElementCache[source];
+      if (element == null) {
+        RecordingErrorListener listener = new RecordingErrorListener();
+        LibraryResolver resolver = new LibraryResolver(this, listener);
+        try {
+          element = resolver.resolveLibrary(source, true);
+        } on AnalysisException catch (exception) {
+          AnalysisEngine.instance.logger.logError2("Could not resolve the library ${source.fullName}", exception);
+        }
+      }
+      return element;
+    }
+  }
+  /**
+   * Return the element model corresponding to the library defined by the given source, or{@code null} if the element model does not yet exist.
+   * @param source the source defining the library whose element model is to be returned
+   * @return the element model corresponding to the library defined by the given source
+   */
+  LibraryElement getLibraryElementOrNull(Source source) {
+    {
+      return _libraryElementCache[source];
+    }
+  }
+  SourceKind getOrComputeKindOf(Source source) {
+    SourceKind kind = getKnownKindOf(source);
+    if (kind != null) {
+      return kind;
+    }
+    try {
+      if (hasPartOfDirective(parse(source))) {
+        return SourceKind.PART;
+      }
+    } on AnalysisException catch (exception) {
+      return SourceKind.UNKNOWN;
+    }
+    return SourceKind.LIBRARY;
+  }
+  List<AnalysisError> getParsingErrors(Source source) {
+    throw new UnsupportedOperationException();
+  }
+  /**
+   * Return a namespace containing mappings for all of the public names defined by the given
+   * library.
+   * @param library the library whose public namespace is to be returned
+   * @return the public namespace of the given library
+   */
+  Namespace getPublicNamespace(LibraryElement library) {
+    Source source7 = library.definingCompilationUnit.source;
+    {
+      Namespace namespace = _publicNamespaceCache[source7];
+      if (namespace == null) {
+        NamespaceBuilder builder = new NamespaceBuilder();
+        namespace = builder.createPublicNamespace(library);
+        _publicNamespaceCache[source7] = namespace;
+      }
+      return namespace;
+    }
+  }
+  /**
+   * Return a namespace containing mappings for all of the public names defined by the library
+   * defined by the given source.
+   * @param source the source defining the library whose public namespace is to be returned
+   * @return the public namespace corresponding to the library defined by the given source
+   */
+  Namespace getPublicNamespace2(Source source) {
+    {
+      Namespace namespace = _publicNamespaceCache[source];
+      if (namespace == null) {
+        LibraryElement library = getLibraryElement(source);
+        if (library == null) {
+          return null;
+        }
+        NamespaceBuilder builder = new NamespaceBuilder();
+        namespace = builder.createPublicNamespace(library);
+        _publicNamespaceCache[source] = namespace;
+      }
+      return namespace;
+    }
+  }
+  List<AnalysisError> getResolutionErrors(Source source) {
+    throw new UnsupportedOperationException();
+  }
+  SourceFactory get sourceFactory => _sourceFactory;
+  void mergeAnalysisContext(AnalysisContext context) {
+    {
+      _availableSources.addAll(context.availableSources);
+    }
+  }
+  CompilationUnit parse(Source source) {
+    {
+      CompilationUnit unit = _parseCache[source];
+      if (unit == null) {
+        RecordingErrorListener errorListener = new RecordingErrorListener();
+        Token token = scan(source, errorListener);
+        Parser parser = new Parser(source, errorListener);
+        unit = parser.parseCompilationUnit(token);
+        unit.parsingErrors = errorListener.errors;
+        _parseCache[source] = unit;
+      }
+      return unit;
+    }
+  }
+  CompilationUnit parse2(Source source, AnalysisErrorListener errorListener) {
+    {
+      CompilationUnit unit = _parseCache[source];
+      if (unit == null) {
+        Token token = scan(source, errorListener);
+        Parser parser = new Parser(source, errorListener);
+        unit = parser.parseCompilationUnit(token);
+        _parseCache[source] = unit;
+      }
+      return unit;
+    }
+  }
+  /**
+   * Given a table mapping the source for the libraries represented by the corresponding elements to
+   * the elements representing the libraries, record those mappings.
+   * @param elementMap a table mapping the source for the libraries represented by the elements to
+   * the elements representing the libraries
+   */
+  void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
+    {
+      javaMapPutAll(_libraryElementCache, elementMap);
+    }
+  }
+  CompilationUnit resolve(Source source, LibraryElement library) => parse(source);
+  Token scan(Source source, AnalysisErrorListener errorListener) {
+    List<Token> tokens = new List<Token>.fixedLength(1);
+    Source_ContentReceiver receiver = new Source_ContentReceiver_1(source, errorListener, tokens);
+    try {
+      source.getContents(receiver);
+    } on JavaException catch (exception) {
+    }
+    return tokens[0];
+  }
+  void set sourceFactory(SourceFactory sourceFactory2) {
+    this._sourceFactory = sourceFactory2;
+  }
+  void sourceAvailable(Source source) {
+    {
+      javaSetAdd(_availableSources, source);
+    }
+  }
+  void sourceChanged(Source source) {
+    {
+      _parseCache.remove(source);
+      _libraryElementCache.remove(source);
+      _publicNamespaceCache.remove(source);
+    }
+  }
+  void sourceDeleted(Source source) {
+    {
+      _availableSources.remove(source);
+      sourceChanged(source);
+    }
+  }
+  void sourcesDeleted(SourceContainer container) {
+    {
+      _parseCache.clear();
+      _libraryElementCache.clear();
+      _publicNamespaceCache.clear();
+      JavaIterator<Source> iter = new JavaIterator(_availableSources);
+      while (iter.hasNext) {
+        if (container.contains(iter.next())) {
+          iter.remove();
+        }
+      }
+    }
+  }
+  Iterable<Source> sourcesToResolve(List<Source> changedSources) => JavaArrays.asList(changedSources);
+  /**
+   * Return {@code true} if the given compilation unit has a part-of directive.
+   * @param unit the compilation unit being tested
+   * @return {@code true} if the compilation unit has a part-of directive
+   */
+  bool hasPartOfDirective(CompilationUnit unit) {
+    for (Directive directive in unit.directives) {
+      if (directive is PartOfDirective) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+class Source_ContentReceiver_1 implements Source_ContentReceiver {
+  Source source;
+  AnalysisErrorListener errorListener;
+  List<Token> tokens;
+  Source_ContentReceiver_1(this.source, this.errorListener, this.tokens);
+  accept(CharBuffer contents) {
+    CharBufferScanner scanner = new CharBufferScanner(source, contents, errorListener);
+    tokens[0] = scanner.tokenize();
+  }
+  void accept2(String contents) {
+    StringScanner scanner = new StringScanner(source, contents, errorListener);
+    tokens[0] = scanner.tokenize();
+  }
+}
+/**
+ * Instances of the class {@code RecordingErrorListener} implement an error listener that will
+ * record the errors that are reported to it in a way that is appropriate for caching those errors
+ * within an analysis context.
+ */
+class RecordingErrorListener implements AnalysisErrorListener {
+  /**
+   * A list containing the errors that were collected.
+   */
+  List<AnalysisError> _errors = null;
+  /**
+   * Answer the errors collected by the listener.
+   * @return an array of errors (not {@code null}, contains no {@code null}s)
+   */
+  List<AnalysisError> get errors => _errors != null ? new List.from(_errors) : AnalysisError.NO_ERRORS;
+  void onError(AnalysisError event) {
+    if (_errors == null) {
+      _errors = new List<AnalysisError>();
+    }
+    _errors.add(event);
+  }
+}
+/**
+ * The interface {@code Logger} defines the behavior of objects that can be used to receive
+ * information about errors within the analysis engine. Implementations usually write this
+ * information to a file, but can also record the information for later use (such as during testing)
+ * or even ignore the information.
+ */
+abstract class Logger {
+  static Logger NULL = new Logger_NullLogger();
+  /**
+   * Log the given message as an error.
+   * @param message an explanation of why the error occurred or what it means
+   */
+  void logError(String message);
+  /**
+   * Log the given exception as one representing an error.
+   * @param message an explanation of why the error occurred or what it means
+   * @param exception the exception being logged
+   */
+  void logError2(String message, Exception exception);
+  /**
+   * Log the given exception as one representing an error.
+   * @param exception the exception being logged
+   */
+  void logError3(Exception exception);
+  /**
+   * Log the given informational message.
+   * @param message an explanation of why the error occurred or what it means
+   * @param exception the exception being logged
+   */
+  void logInformation(String message);
+  /**
+   * Log the given exception as one representing an informational message.
+   * @param message an explanation of why the error occurred or what it means
+   * @param exception the exception being logged
+   */
+  void logInformation2(String message, Exception exception);
+}
+/**
+ * Implementation of {@link Logger} that does nothing.
+ */
+class Logger_NullLogger implements Logger {
+  void logError(String message) {
+  }
+  void logError2(String message, Exception exception) {
+  }
+  void logError3(Exception exception) {
+  }
+  void logInformation(String message) {
+  }
+  void logInformation2(String message, Exception exception) {
+  }
+}