Support for DartBlockBody, DartExpressionBody, DartOmit in java2dart.

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

 // Copyright (c) 2014, 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.
 
 // 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';
@@ skipping 276 matching lines @@
    *
    * @param source the source whose line information is to be returned
    * @return the line information for the given source
    * @throws AnalysisException if the line information could not be determined because the analysis
    *           could not be performed
    * @see #getLineInfo(Source)
    */
   LineInfo computeLineInfo(Source source);
 
   /**
+   * Notifies the context that the client is going to stop using this context.
+   */
+  void dispose();
+
+  /**
    * Return `true` if the given source exists.
    *
    * This method should be used rather than the method [Source#exists] because contexts can
    * have local overrides of the content of a source that the source is not aware of and a source
    * with local content is considered to exist even if there is no file on disk.
    *
    * @param source the source whose modification stamp is to be returned
    * @return `true` if the source exists
    */
   bool exists(Source source);
@@ skipping 35 matching lines @@
    * This method should be used rather than the method [Source#getContents] because contexts
    * can have local overrides of the content of a source that the source is not aware of.
    *
    * @param source the source whose content is to be returned
    * @return the contents and timestamp of the source
    * @throws Exception if the contents of the source could not be accessed
    */
   TimestampedData<String> getContents(Source source);
 
   /**
-   * Get the contents of the given source and pass it to the given content receiver.
-   *
-   * This method should be used rather than the method
-   * [Source#getContentsToReceiver] because contexts can have local overrides
-   * of the content of a source that the source is not aware of.
-   *
-   * @param source the source whose content is to be returned
-   * @param receiver the content receiver to which the content of the source will be passed
-   * @throws Exception if the contents of the source could not be accessed
-   */
-  void getContentsToReceiver(Source source, Source_ContentReceiver receiver);
-
-  /**
    * Return the element referenced by the given location, or `null` if the element is not
    * immediately available or if there is no element with the given location. The latter condition
    * can occur, for example, if the location describes an element from a different context or if the
    * element has been removed from this context as a result of some change since it was originally
    * obtained.
    *
    * @param location the reference describing the element to be returned
    * @return the element referenced by the given location
    */
   Element getElement(ElementLocation location);
@@ skipping 195 matching lines @@
    * <b>Note:</b> In addition to the expected case of returning `false` if the source is known
    * to be a library that cannot be run on a client, this method will also return `false` if
    * the source is not known to be a library or if we do not know whether it can be run on a client.
    *
    * @param librarySource the source being tested
    * @return `true` if the given source is known to be a library that can be run on a client
    */
   bool isClientLibrary(Source librarySource);
 
   /**
+   * Returns `true` if this context was disposed using [dispose].
+   *
+   * @return `true` if this context was disposed
+   */
+  bool get isDisposed;
+
+  /**
    * Return `true` if the given source is known to be the defining compilation unit of a
    * library that can be run on the server (does not reference 'dart:html', either directly or
    * indirectly).
    *
    * <b>Note:</b> In addition to the expected case of returning `false` if the source is known
    * to be a library that cannot be run on the server, this method will also return `false` if
    * the source is not known to be a library or if we do not know whether it can be run on the
    * server.
    *
    * @param librarySource the source being tested
@@ skipping 3045 matching lines @@
    * priority source's AST structure to be flushed.
    */
   static int _PRIORITY_ORDER_SIZE_DELTA = 4;
 
   /**
    * The set of analysis options controlling the behavior of this context.
    */
   AnalysisOptionsImpl _options = new AnalysisOptionsImpl();
 
   /**
+   * A flag indicating whether this context is disposed.
+   */
+  bool _disposed = false;
+
+  /**
    * A cache of content used to override the default content of a source.
    */
   ContentCache _contentCache = new ContentCache();
 
   /**
    * The source factory used to create the sources that can be analyzed in this context.
    */
   SourceFactory _sourceFactory;
 
   /**
@@ skipping 246 matching lines @@
     dartEntry = _cacheDartParseData(source, dartEntry, DartEntry.PARSED_UNIT);
     DartEntryImpl dartCopy = dartEntry.writableCopy;
     CompilationUnit unit = dartCopy.resolvableCompilationUnit;
     if (unit == null) {
       throw new AnalysisException.con2("Internal error: computeResolvableCompilationUnit could not parse ${source.fullName}", dartEntry.exception);
     }
     _cache.put(source, dartCopy);
     return new ResolvableCompilationUnit(dartCopy.modificationTime, unit);
   }
 
+  void dispose() {
+    _disposed = true;
+  }
+
   bool exists(Source source) {
     if (source == null) {
       return false;
     }
     if (_contentCache.getContents(source) != null) {
       return true;
     }
     return source.exists();
   }
 
@@ skipping 33 matching lines @@
   }
 
   TimestampedData<String> getContents(Source source) {
     String contents = _contentCache.getContents(source);
     if (contents != null) {
       return new TimestampedData<String>(_contentCache.getModificationStamp(source), contents);
     }
     return source.contents;
   }
 
-  void getContentsToReceiver(Source source, Source_ContentReceiver receiver) {
-    String contents = _contentCache.getContents(source);
-    if (contents != null) {
-      receiver.accept(contents, _contentCache.getModificationStamp(source));
-      return;
-    }
-    source.getContentsToReceiver(receiver);
-  }
-
   Element getElement(ElementLocation location) {
     // TODO(brianwilkerson) This should not be a "get" method.
     try {
       List<String> components = (location as ElementLocationImpl).components;
       Source librarySource = _computeSourceFromEncoding(components[0]);
       ElementImpl element = computeLibraryElement(librarySource) as ElementImpl;
       for (int i = 1; i < components.length; i++) {
         if (element == null) {
           return null;
         }
         element = element.getChild(components[i]);
       }
       return element;
     } on AnalysisException catch (exception) {
       return null;
     }
   }
 
   AnalysisErrorInfo getErrors(Source source) {
-    SourceEntry sourceEntry = _getReadableSourceEntry(source);
+    SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       return new AnalysisErrorInfoImpl(dartEntry.allErrors, dartEntry.getValue(SourceEntry.LINE_INFO));
     } else if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       return new AnalysisErrorInfoImpl(htmlEntry.allErrors, htmlEntry.getValue(SourceEntry.LINE_INFO));
     }
     return new AnalysisErrorInfoImpl(AnalysisError.NO_ERRORS, null);
   }
 
   HtmlElement getHtmlElement(Source source) {
-    SourceEntry sourceEntry = _getReadableSourceEntry(source);
+    SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
     if (sourceEntry is HtmlEntry) {
       return sourceEntry.getValue(HtmlEntry.ELEMENT);
     }
     return null;
   }
 
   List<Source> getHtmlFilesReferencing(Source source) {
     SourceKind sourceKind = getKindOf(source);
     if (sourceKind == null) {
       return Source.EMPTY_ARRAY;
@@ skipping 17 matching lines @@
     }
     if (htmlSources.isEmpty) {
       return Source.EMPTY_ARRAY;
     }
     return new List.from(htmlSources);
   }
 
   List<Source> get htmlSources => _getSources(SourceKind.HTML);
 
   SourceKind getKindOf(Source source) {
-    SourceEntry sourceEntry = _getReadableSourceEntry(source);
+    SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
     if (sourceEntry == null) {
       return SourceKind.UNKNOWN;
     }
     return sourceEntry.kind;
   }
 
   List<Source> get launchableClientLibrarySources {
     // TODO(brianwilkerson) This needs to filter out libraries that do not reference dart:html,
     // either directly or indirectly.
     List<Source> sources = new List<Source>();
@@ skipping 19 matching lines @@
       if (identical(sourceEntry.kind, SourceKind.LIBRARY) && !source.isInSystemLibrary) {
         //          DartEntry dartEntry = (DartEntry) sourceEntry;
         //          if (dartEntry.getValue(DartEntry.IS_LAUNCHABLE) && !dartEntry.getValue(DartEntry.IS_CLIENT)) {
         sources.add(source);
       }
     }
     return new List.from(sources);
   }
 
   List<Source> getLibrariesContaining(Source source) {
-    DartEntry dartEntry = _getReadableDartEntry(source);
-    if (dartEntry == null) {
-      return Source.EMPTY_ARRAY;
+    SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
+    if (sourceEntry is DartEntry) {
+      return sourceEntry.getValue(DartEntry.CONTAINING_LIBRARIES);
     }
-    return dartEntry.getValue(DartEntry.CONTAINING_LIBRARIES);
+    return Source.EMPTY_ARRAY;
   }
 
   List<Source> getLibrariesDependingOn(Source librarySource) {
     List<Source> dependentLibraries = new List<Source>();
     for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
       SourceEntry sourceEntry = entry.getValue();
       if (identical(sourceEntry.kind, SourceKind.LIBRARY)) {
         if (_contains((sourceEntry as DartEntry).getValue(DartEntry.EXPORTED_LIBRARIES), librarySource)) {
           dependentLibraries.add(entry.getKey());
         }
         if (_contains((sourceEntry as DartEntry).getValue(DartEntry.IMPORTED_LIBRARIES), librarySource)) {
           dependentLibraries.add(entry.getKey());
         }
       }
     }
     if (dependentLibraries.isEmpty) {
       return Source.EMPTY_ARRAY;
     }
     return new List.from(dependentLibraries);
   }
 
   LibraryElement getLibraryElement(Source source) {
-    SourceEntry sourceEntry = _getReadableSourceEntry(source);
+    SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
     if (sourceEntry is DartEntry) {
       return sourceEntry.getValue(DartEntry.ELEMENT);
     }
     return null;
   }
 
   List<Source> get librarySources => _getSources(SourceKind.LIBRARY);
 
   LineInfo getLineInfo(Source source) {
-    SourceEntry sourceEntry = _getReadableSourceEntry(source);
+    SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
     if (sourceEntry != null) {
       return sourceEntry.getValue(SourceEntry.LINE_INFO);
     }
     return null;
   }
 
   int getModificationStamp(Source source) {
     int stamp = _contentCache.getModificationStamp(source);
     if (stamp != null) {
       return stamp;
@@ skipping 72 matching lines @@
   }
 
   CompilationUnit getResolvedCompilationUnit(Source unitSource, LibraryElement library) {
     if (library == null) {
       return null;
     }
     return getResolvedCompilationUnit2(unitSource, library.source);
   }
 
   CompilationUnit getResolvedCompilationUnit2(Source unitSource, Source librarySource) {
-    SourceEntry sourceEntry = _getReadableSourceEntry(unitSource);
+    SourceEntry sourceEntry = _getReadableSourceEntryOrNull(unitSource);
     if (sourceEntry is DartEntry) {
       return sourceEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
     }
     return null;
   }
 
   ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource) {
-    SourceEntry sourceEntry = _getReadableSourceEntry(htmlSource);
+    SourceEntry sourceEntry = _getReadableSourceEntryOrNull(htmlSource);
     if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       return htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT);
     }
     return null;
   }
 
   SourceFactory get sourceFactory => _sourceFactory;
 
   /**
@@ skipping 80 matching lines @@
 
   bool isClientLibrary(Source librarySource) {
     SourceEntry sourceEntry = _getReadableSourceEntry(librarySource);
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       return dartEntry.getValue(DartEntry.IS_CLIENT) && dartEntry.getValue(DartEntry.IS_LAUNCHABLE);
     }
     return false;
   }
 
+  bool get isDisposed => _disposed;
+
   bool isServerLibrary(Source librarySource) {
     SourceEntry sourceEntry = _getReadableSourceEntry(librarySource);
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       return !dartEntry.getValue(DartEntry.IS_CLIENT) && dartEntry.getValue(DartEntry.IS_LAUNCHABLE);
     }
     return false;
   }
 
   void mergeContext(AnalysisContext context) {
@@ skipping 1424 matching lines @@
     if (sourceEntry == null) {
       sourceEntry = _createSourceEntry(source);
     }
     if (sourceEntry is HtmlEntry) {
       return sourceEntry as HtmlEntry;
     }
     return null;
   }
 
   /**
-   * Return the cache entry associated with the given source, or `null` if there is no entry
-   * associated with the source.
+   * Return the cache entry associated with the given source, creating it if necessary.
    *
    * @param source the source for which a cache entry is being sought
    * @return the source cache entry associated with the given source
    */
   SourceEntry _getReadableSourceEntry(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       sourceEntry = _createSourceEntry(source);
     }
     return sourceEntry;
   }
 
   /**
+   * Return the cache entry associated with the given source, or `null` if there is no entry
+   * associated with the source.
+   *
+   * @param source the source for which a cache entry is being sought
+   * @return the source cache entry associated with the given source
+   */
+  SourceEntry _getReadableSourceEntryOrNull(Source source) => _cache.get(source);
+
+  /**
    * Return an array containing all of the sources known to this context that have the given kind.
    *
    * @param kind the kind of sources to be returned
    * @return all of the sources known to this context that have the given kind
    */
   List<Source> _getSources(SourceKind kind) {
     List<Source> sources = new List<Source>();
     for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
       if (identical(entry.getValue().kind, kind)) {
         sources.add(entry.getKey());
@@ skipping 2230 matching lines @@
   bool get hasWork => _oldLength > 0 || _newLength > 0;
 }
 
 /**
  * Instances of the class `InstrumentedAnalysisContextImpl` implement an
  * [AnalysisContext] by recording instrumentation data and delegating to
  * another analysis context to do the non-instrumentation work.
  */
 class InstrumentedAnalysisContextImpl implements InternalAnalysisContext {
   /**
+   * If the current thread is the UI thread, then note this in the specified instrumentation and
+   * append this information to the log.
+   *
+   * @param instrumentation the instrumentation, not `null`
+   */
+  static void _checkThread(InstrumentationBuilder instrumentation) {
+  }
+
+  /**
    * Record an exception that was thrown during analysis.
    *
    * @param instrumentation the instrumentation builder being used to record the exception
    * @param exception the exception being reported
    */
   static void _recordAnalysisException(InstrumentationBuilder instrumentation, AnalysisException exception) {
     instrumentation.record(exception);
   }
 
   /**
@@ skipping 21 matching lines @@
   InstrumentedAnalysisContextImpl.con1(InternalAnalysisContext context) {
     _basis = context;
   }
 
   void addSourceInfo(Source source, SourceEntry info) {
     _basis.addSourceInfo(source, info);
   }
 
   void applyChanges(ChangeSet changeSet) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-applyChanges");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       _basis.applyChanges(changeSet);
     } finally {
       instrumentation.log();
     }
   }
 
   String computeDocumentationComment(Element element) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeDocumentationComment");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.computeDocumentationComment(element);
     } finally {
       instrumentation.log();
     }
   }
 
   List<AnalysisError> computeErrors(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeErrors");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       List<AnalysisError> errors = _basis.computeErrors(source);
       instrumentation.metric2("Errors-count", errors.length);
       return errors;
     } finally {
       instrumentation.log();
     }
   }
 
   List<Source> computeExportedLibraries(Source source) => _basis.computeExportedLibraries(source);
 
   HtmlElement computeHtmlElement(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeHtmlElement");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.computeHtmlElement(source);
     } on AnalysisException catch (e) {
       _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   List<Source> computeImportedLibraries(Source source) => _basis.computeImportedLibraries(source);
 
   SourceKind computeKindOf(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeKindOf");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.computeKindOf(source);
     } finally {
       instrumentation.log();
     }
   }
 
   LibraryElement computeLibraryElement(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeLibraryElement");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.computeLibraryElement(source);
     } on AnalysisException catch (e) {
       _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   LineInfo computeLineInfo(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeLineInfo");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.computeLineInfo(source);
     } on AnalysisException catch (e) {
       _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   ResolvableCompilationUnit computeResolvableCompilationUnit(Source source) => _basis.computeResolvableCompilationUnit(source);
 
+  void dispose() {
+    InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-dispose");
+    _checkThread(instrumentation);
+    try {
+      instrumentation.metric3("contextId", _contextId);
+      _basis.dispose();
+    } finally {
+      instrumentation.log();
+    }
+  }
+
   bool exists(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-exists");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.exists(source);
     } finally {
       instrumentation.log();
     }
   }
 
   AnalysisContext extractContext(SourceContainer container) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-extractContext");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       InstrumentedAnalysisContextImpl newContext = new InstrumentedAnalysisContextImpl();
       _basis.extractContextInto(container, newContext._basis);
       return newContext;
     } finally {
       instrumentation.log();
     }
   }
 
   InternalAnalysisContext extractContextInto(SourceContainer container, InternalAnalysisContext newContext) => _basis.extractContextInto(container, newContext);
 
   AnalysisOptions get analysisOptions {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getAnalysisOptions");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.analysisOptions;
     } finally {
       instrumentation.log();
     }
   }
 
   /**
    * @return the underlying [AnalysisContext].
    */
   AnalysisContext get basis => _basis;
 
   CompilationUnitElement getCompilationUnitElement(Source unitSource, Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getCompilationUnitElement");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getCompilationUnitElement(unitSource, librarySource);
     } finally {
       instrumentation.log();
     }
   }
 
   TimestampedData<String> getContents(Source source) => _basis.getContents(source);
 
-  void getContentsToReceiver(Source source, Source_ContentReceiver receiver) {
-    _basis.getContentsToReceiver(source, receiver);
-  }
-
   Element getElement(ElementLocation location) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getElement");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getElement(location);
     } finally {
       instrumentation.log();
     }
   }
 
   AnalysisErrorInfo getErrors(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getErrors");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       AnalysisErrorInfo ret = _basis.getErrors(source);
       if (ret != null) {
         instrumentation.metric2("Errors-count", ret.errors.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
 
   HtmlElement getHtmlElement(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getHtmlElement");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getHtmlElement(source);
     } finally {
       instrumentation.log();
     }
   }
 
   List<Source> getHtmlFilesReferencing(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getHtmlFilesReferencing");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       List<Source> ret = _basis.getHtmlFilesReferencing(source);
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
 
   List<Source> get htmlSources {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getHtmlSources");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       List<Source> ret = _basis.htmlSources;
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
 
   SourceKind getKindOf(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getKindOf");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getKindOf(source);
     } finally {
       instrumentation.log();
     }
   }
 
   List<Source> get launchableClientLibrarySources {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLaunchableClientLibrarySources");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       List<Source> ret = _basis.launchableClientLibrarySources;
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
 
   List<Source> get launchableServerLibrarySources {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLaunchableServerLibrarySources");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       List<Source> ret = _basis.launchableServerLibrarySources;
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
 
   List<Source> getLibrariesContaining(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLibrariesContaining");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       List<Source> ret = _basis.getLibrariesContaining(source);
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log2(2);
     }
   }
 
   List<Source> getLibrariesDependingOn(Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLibrariesDependingOn");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       List<Source> ret = _basis.getLibrariesDependingOn(librarySource);
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
 
   LibraryElement getLibraryElement(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLibraryElement");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getLibraryElement(source);
     } finally {
       instrumentation.log();
     }
   }
 
   List<Source> get librarySources {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLibrarySources");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       List<Source> ret = _basis.librarySources;
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
 
   LineInfo getLineInfo(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLineInfo");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getLineInfo(source);
     } finally {
       instrumentation.log();
     }
   }
 
   int getModificationStamp(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getModificationStamp");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getModificationStamp(source);
     } finally {
       instrumentation.log();
     }
   }
 
   Namespace getPublicNamespace(LibraryElement library) => _basis.getPublicNamespace(library);
 
   Namespace getPublicNamespace2(Source source) => _basis.getPublicNamespace2(source);
 
   List<Source> get refactoringUnsafeSources {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getRefactoringUnsafeSources");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.refactoringUnsafeSources;
     } finally {
       instrumentation.log();
     }
   }
 
   CompilationUnit getResolvedCompilationUnit(Source unitSource, LibraryElement library) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getResolvedCompilationUnit");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getResolvedCompilationUnit(unitSource, library);
     } finally {
       instrumentation.log();
     }
   }
 
   CompilationUnit getResolvedCompilationUnit2(Source unitSource, Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getResolvedCompilationUnit");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getResolvedCompilationUnit2(unitSource, librarySource);
     } finally {
       instrumentation.log2(2);
     }
   }
 
   ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getResolvedHtmlUnit");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getResolvedHtmlUnit(htmlSource);
     } finally {
       instrumentation.log2(2);
     }
   }
 
   SourceFactory get sourceFactory {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getSourceFactory");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.sourceFactory;
     } finally {
       instrumentation.log2(2);
     }
   }
 
   AnalysisContentStatistics get statistics => _basis.statistics;
 
   TypeProvider get typeProvider => _basis.typeProvider;
 
   TimestampedData<CompilationUnit> internalResolveCompilationUnit(Source unitSource, LibraryElement libraryElement) => _basis.internalResolveCompilationUnit(unitSource, libraryElement);
 
   bool isClientLibrary(Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-isClientLibrary");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.isClientLibrary(librarySource);
     } finally {
       instrumentation.log();
     }
   }
 
+  bool get isDisposed {
+    InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-isDisposed");
+    _checkThread(instrumentation);
+    try {
+      instrumentation.metric3("contextId", _contextId);
+      return _basis.isDisposed;
+    } finally {
+      instrumentation.log();
+    }
+  }
+
   bool isServerLibrary(Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-isServerLibrary");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.isServerLibrary(librarySource);
     } finally {
       instrumentation.log();
     }
   }
 
   void mergeContext(AnalysisContext context) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-mergeContext");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       if (context is InstrumentedAnalysisContextImpl) {
         context = (context as InstrumentedAnalysisContextImpl)._basis;
       }
       _basis.mergeContext(context);
     } finally {
       instrumentation.log();
     }
   }
 
   CompilationUnit parseCompilationUnit(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-parseCompilationUnit");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.parseCompilationUnit(source);
     } on AnalysisException catch (e) {
       _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   ht.HtmlUnit parseHtmlUnit(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-parseHtmlUnit");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.parseHtmlUnit(source);
     } on AnalysisException catch (e) {
       _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   AnalysisResult performAnalysisTask() {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-performAnalysisTask");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       AnalysisResult result = _basis.performAnalysisTask();
       if (result.changeNotices != null) {
         instrumentation.metric2("ChangeNotice-count", result.changeNotices.length);
       }
       return result;
     } finally {
       instrumentation.log2(2);
     }
   }
 
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
     _basis.recordLibraryElements(elementMap);
   }
 
   CompilationUnit resolveCompilationUnit(Source unitSource, LibraryElement library) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-resolveCompilationUnit");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.resolveCompilationUnit(unitSource, library);
     } on AnalysisException catch (e) {
       _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   CompilationUnit resolveCompilationUnit2(Source unitSource, Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-resolveCompilationUnit");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.resolveCompilationUnit2(unitSource, librarySource);
     } on AnalysisException catch (e) {
       _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   ht.HtmlUnit resolveHtmlUnit(Source htmlSource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-resolveHtmlUnit");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.resolveHtmlUnit(htmlSource);
     } on AnalysisException catch (e) {
       _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   void set analysisOptions(AnalysisOptions options) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-setAnalysisOptions");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       _basis.analysisOptions = options;
     } finally {
       instrumentation.log();
     }
   }
 
   void set analysisPriorityOrder(List<Source> sources) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-setAnalysisPriorityOrder");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       _basis.analysisPriorityOrder = sources;
     } finally {
       instrumentation.log();
     }
   }
 
   void setChangedContents(Source source, String contents, int offset, int oldLength, int newLength) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-setChangedContents");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       _basis.setChangedContents(source, contents, offset, oldLength, newLength);
     } finally {
       instrumentation.log();
     }
   }
 
   void setContents(Source source, String contents) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-setContents");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       _basis.setContents(source, contents);
     } finally {
       instrumentation.log();
     }
   }
 
   void set sourceFactory(SourceFactory factory) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-setSourceFactory");
+    _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       _basis.sourceFactory = factory;
     } finally {
       instrumentation.log();
     }
   }
 }
 
 /**
@@ skipping 3339 matching lines @@
 
   void logError2(String message, Exception exception) {
   }
 
   void logInformation(String message) {
   }
 
   void logInformation2(String message, Exception exception) {
   }
 }