| // 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 "dart:math" as math; |
| import 'dart:async'; |
| import 'dart:collection'; |
| |
| import 'package:analyzer/src/cancelable_future.dart'; |
| import 'package:analyzer/src/generated/incremental_resolution_validator.dart'; |
| import 'package:analyzer/src/services/lint.dart'; |
| import 'package:analyzer/src/task/task_dart.dart'; |
| |
| import '../../instrumentation/instrumentation.dart'; |
| import 'ast.dart'; |
| import 'constant.dart'; |
| import 'element.dart'; |
| import 'error.dart'; |
| import 'error_verifier.dart'; |
| import 'html.dart' as ht; |
| import 'incremental_resolver.dart' show IncrementalResolver, |
| PoorMansIncrementalResolver; |
| import 'incremental_scanner.dart'; |
| import 'java_core.dart'; |
| import 'java_engine.dart'; |
| import 'parser.dart' show Parser, IncrementalParser; |
| import 'resolver.dart'; |
| import 'scanner.dart'; |
| import 'sdk.dart' show DartSdk; |
| import 'source.dart'; |
| import 'utilities_collection.dart'; |
| import 'utilities_general.dart'; |
| |
| /** |
| * Type of callback functions used by PendingFuture. Functions of this type |
| * should perform a computation based on the data in [sourceEntry] and return |
| * it. If the computation can't be performed yet because more analysis is |
| * needed, null should be returned. |
| * |
| * The function may also throw an exception, in which case the corresponding |
| * future will be completed with failure. |
| * |
| * Since this function is called while the state of analysis is being updated, |
| * it should be free of side effects so that it doesn't cause reentrant |
| * changes to the analysis state. |
| */ |
| typedef T PendingFutureComputer<T>(SourceEntry sourceEntry); |
| |
| /** |
| * Instances of the class `AnalysisCache` implement an LRU cache of information related to |
| * analysis. |
| */ |
| class AnalysisCache { |
| /** |
| * A flag used to control whether trace information should be produced when the content of the |
| * cache is modified. |
| */ |
| static bool _TRACE_CHANGES = false; |
| |
| /** |
| * An array containing the partitions of which this cache is comprised. |
| */ |
| final List<CachePartition> _partitions; |
| |
| /** |
| * Initialize a newly created cache to have the given partitions. The partitions will be searched |
| * in the order in which they appear in the array, so the most specific partition (usually an |
| * [SdkCachePartition]) should be first and the most general (usually a |
| * [UniversalCachePartition]) last. |
| * |
| * @param partitions the partitions for the newly created cache |
| */ |
| AnalysisCache(this._partitions); |
| |
| /** |
| * Return the number of entries in this cache that have an AST associated with them. |
| * |
| * @return the number of entries in this cache that have an AST associated with them |
| */ |
| int get astSize => _partitions[_partitions.length - 1].astSize; |
| |
| /** |
| * Return information about each of the partitions in this cache. |
| * |
| * @return information about each of the partitions in this cache |
| */ |
| List<AnalysisContextStatistics_PartitionData> get partitionData { |
| int count = _partitions.length; |
| List<AnalysisContextStatistics_PartitionData> data = |
| new List<AnalysisContextStatistics_PartitionData>(count); |
| for (int i = 0; i < count; i++) { |
| CachePartition partition = _partitions[i]; |
| data[i] = new AnalysisContextStatisticsImpl_PartitionDataImpl( |
| partition.astSize, |
| partition.map.length); |
| } |
| return data; |
| } |
| |
| /** |
| * Record that the AST associated with the given source was just read from the cache. |
| * |
| * @param source the source whose AST was accessed |
| */ |
| void accessedAst(Source source) { |
| int count = _partitions.length; |
| for (int i = 0; i < count; i++) { |
| if (_partitions[i].contains(source)) { |
| _partitions[i].accessedAst(source); |
| return; |
| } |
| } |
| } |
| |
| /** |
| * Return the entry associated with the given source. |
| * |
| * @param source the source whose entry is to be returned |
| * @return the entry associated with the given source |
| */ |
| SourceEntry get(Source source) { |
| int count = _partitions.length; |
| for (int i = 0; i < count; i++) { |
| if (_partitions[i].contains(source)) { |
| return _partitions[i].get(source); |
| } |
| } |
| // |
| // We should never get to this point because the last partition should |
| // always be a universal partition, except in the case of the SDK context, |
| // in which case the source should always be part of the SDK. |
| // |
| return null; |
| } |
| |
| /** |
| * Return context that owns the given source. |
| * |
| * @param source the source whose context is to be returned |
| * @return the context that owns the partition that contains the source |
| */ |
| InternalAnalysisContext getContextFor(Source source) { |
| int count = _partitions.length; |
| for (int i = 0; i < count; i++) { |
| if (_partitions[i].contains(source)) { |
| return _partitions[i].context; |
| } |
| } |
| // |
| // We should never get to this point because the last partition should |
| // always be a universal partition, except in the case of the SDK context, |
| // in which case the source should always be part of the SDK. |
| // |
| AnalysisEngine.instance.logger.logInformation( |
| "Could not find context for ${source.fullName}", |
| new CaughtException(new AnalysisException(), null)); |
| return null; |
| } |
| |
| /** |
| * Return an iterator returning all of the map entries mapping sources to cache entries. |
| * |
| * @return an iterator returning all of the map entries mapping sources to cache entries |
| */ |
| MapIterator<Source, SourceEntry> iterator() { |
| int count = _partitions.length; |
| List<Map<Source, SourceEntry>> maps = new List<Map>(count); |
| for (int i = 0; i < count; i++) { |
| maps[i] = _partitions[i].map; |
| } |
| return new MultipleMapIterator<Source, SourceEntry>(maps); |
| } |
| |
| /** |
| * Associate the given entry with the given source. |
| * |
| * @param source the source with which the entry is to be associated |
| * @param entry the entry to be associated with the source |
| */ |
| void put(Source source, SourceEntry entry) { |
| entry.fixExceptionState(); |
| int count = _partitions.length; |
| for (int i = 0; i < count; i++) { |
| if (_partitions[i].contains(source)) { |
| if (_TRACE_CHANGES) { |
| try { |
| SourceEntry oldEntry = _partitions[i].get(source); |
| if (oldEntry == null) { |
| AnalysisEngine.instance.logger.logInformation( |
| "Added a cache entry for '${source.fullName}'."); |
| } else { |
| AnalysisEngine.instance.logger.logInformation( |
| "Modified the cache entry for ${source.fullName}'. Diff = ${entry.getDiff(oldEntry)}"); |
| } |
| } catch (exception) { |
| // Ignored |
| JavaSystem.currentTimeMillis(); |
| } |
| } |
| _partitions[i].put(source, entry); |
| return; |
| } |
| } |
| } |
| |
| /** |
| * Remove all information related to the given source from this cache. |
| * |
| * @param source the source to be removed |
| */ |
| void remove(Source source) { |
| int count = _partitions.length; |
| for (int i = 0; i < count; i++) { |
| if (_partitions[i].contains(source)) { |
| if (_TRACE_CHANGES) { |
| try { |
| AnalysisEngine.instance.logger.logInformation( |
| "Removed the cache entry for ${source.fullName}'."); |
| } catch (exception) { |
| // Ignored |
| JavaSystem.currentTimeMillis(); |
| } |
| } |
| _partitions[i].remove(source); |
| return; |
| } |
| } |
| } |
| |
| /** |
| * Record that the AST associated with the given source was just removed from the cache. |
| * |
| * @param source the source whose AST was removed |
| */ |
| void removedAst(Source source) { |
| int count = _partitions.length; |
| for (int i = 0; i < count; i++) { |
| if (_partitions[i].contains(source)) { |
| _partitions[i].removedAst(source); |
| return; |
| } |
| } |
| } |
| |
| /** |
| * Return the number of sources that are mapped to cache entries. |
| * |
| * @return the number of sources that are mapped to cache entries |
| */ |
| int size() { |
| int size = 0; |
| int count = _partitions.length; |
| for (int i = 0; i < count; i++) { |
| size += _partitions[i].size(); |
| } |
| return size; |
| } |
| |
| /** |
| * Record that the AST associated with the given source was just stored to the cache. |
| * |
| * @param source the source whose AST was stored |
| */ |
| void storedAst(Source source) { |
| int count = _partitions.length; |
| for (int i = 0; i < count; i++) { |
| if (_partitions[i].contains(source)) { |
| _partitions[i].storedAst(source); |
| return; |
| } |
| } |
| } |
| } |
| |
| /** |
| * The interface `AnalysisContext` defines the behavior of objects that represent a context in |
| * which a single analysis can be performed and incrementally maintained. 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. (Both of which are known indirectly through the [SourceFactory |
| ].) |
| * |
| * An analysis context also represents the state of the analysis, which includes knowing which |
| * sources have been included in the analysis (either directly or indirectly) and the results of the |
| * analysis. Sources must be added and removed from the context using the method |
| * [applyChanges], which is also used to notify the context when sources have been |
| * modified and, consequently, previously known results might have been invalidated. |
| * |
| * There are two ways to access the results of the analysis. The most common is to use one of the |
| * 'get' methods to access the results. The 'get' methods have the advantage that they will always |
| * return quickly, but have the disadvantage that if the results are not currently available they |
| * will return either nothing or in some cases an incomplete result. The second way to access |
| * results is by using one of the 'compute' methods. The 'compute' methods will always attempt to |
| * compute the requested results but might block the caller for a significant period of time. |
| * |
| * When results have been invalidated, have never been computed (as is the case for newly added |
| * sources), or have been removed from the cache, they are <b>not</b> automatically recreated. They |
| * will only be recreated if one of the 'compute' methods is invoked. |
| * |
| * However, this is not always acceptable. Some clients need to keep the analysis results |
| * up-to-date. For such clients there is a mechanism that allows them to incrementally perform |
| * needed analysis and get notified of the consequent changes to the analysis results. This |
| * mechanism is realized by the method [performAnalysisTask]. |
| * |
| * 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 the state after a refactoring. |
| */ |
| abstract class AnalysisContext { |
| |
| /** |
| * An empty list of contexts. |
| */ |
| static const List<AnalysisContext> EMPTY_LIST = const <AnalysisContext>[]; |
| |
| /** |
| * Return the set of analysis options controlling the behavior of this context. Clients should not |
| * modify the returned set of options. The options should only be set by invoking the method |
| * [setAnalysisOptions]. |
| * |
| * @return the set of analysis options controlling the behavior of this context |
| */ |
| AnalysisOptions get analysisOptions; |
| |
| /** |
| * Set the set of analysis options controlling the behavior of this context to the given options. |
| * Clients can safely assume that all necessary analysis results have been invalidated. |
| * |
| * @param options the set of analysis options that will control the behavior of this context |
| */ |
| void set analysisOptions(AnalysisOptions options); |
| |
| /** |
| * Set the order in which sources will be analyzed by [performAnalysisTask] to match the |
| * order of the sources in the given list. If a source that needs to be analyzed is not contained |
| * in the list, then it will be treated as if it were at the end of the list. If the list is empty |
| * (or `null`) then no sources will be given priority over other sources. |
| * |
| * Changes made to the list after this method returns will <b>not</b> be reflected in the priority |
| * order. |
| * |
| * @param sources the sources to be given priority over other sources |
| */ |
| void set analysisPriorityOrder(List<Source> sources); |
| |
| /** |
| * Return the set of declared variables used when computing constant values. |
| * |
| * @return the set of declared variables used when computing constant values |
| */ |
| DeclaredVariables get declaredVariables; |
| |
| /** |
| * Return an array containing all of the sources known to this context that represent HTML files. |
| * The contents of the array can be incomplete. |
| * |
| * @return the sources known to this context that represent HTML files |
| */ |
| List<Source> get htmlSources; |
| |
| /** |
| * Returns `true` if this context was disposed using [dispose]. |
| * |
| * @return `true` if this context was disposed |
| */ |
| bool get isDisposed; |
| |
| /** |
| * Return an array containing all of the sources known to this context that represent the defining |
| * compilation unit of a library that can be run within a browser. The sources that are returned |
| * represent libraries that have a 'main' method and are either referenced by an HTML file or |
| * import, directly or indirectly, a client-only library. The contents of the array can be |
| * incomplete. |
| * |
| * @return the sources known to this context that represent the defining compilation unit of a |
| * library that can be run within a browser |
| */ |
| List<Source> get launchableClientLibrarySources; |
| |
| /** |
| * Return an array containing all of the sources known to this context that represent the defining |
| * compilation unit of a library that can be run outside of a browser. The contents of the array |
| * can be incomplete. |
| * |
| * @return the sources known to this context that represent the defining compilation unit of a |
| * library that can be run outside of a browser |
| */ |
| List<Source> get launchableServerLibrarySources; |
| |
| /** |
| * Return an array containing all of the sources known to this context that represent the defining |
| * compilation unit of a library. The contents of the array can be incomplete. |
| * |
| * @return the sources known to this context that represent the defining compilation unit of a |
| * library |
| */ |
| List<Source> get librarySources; |
| |
| /** |
| * The stream that is notified when sources have been added or removed, |
| * or the source's content has changed. |
| */ |
| Stream<SourcesChangedEvent> get onSourcesChanged; |
| |
| /** |
| * Return an array containing all of the sources known to this context and their resolution state |
| * is not valid or flush. So, these sources are not safe to update during refactoring, because we |
| * may be don't know all the references in them. |
| * |
| * @return the sources known to this context and are not safe for refactoring |
| */ |
| List<Source> get refactoringUnsafeSources; |
| |
| /** |
| * 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; |
| |
| /** |
| * Set the source factory used to create the sources that can be analyzed in this context to the |
| * given source factory. Clients can safely assume that all analysis results have been |
| * invalidated. |
| * |
| * @param factory the source factory used to create the sources that can be analyzed in this |
| * context |
| */ |
| void set sourceFactory(SourceFactory factory); |
| |
| /** |
| * Add the given listener to the list of objects that are to be notified when various analysis |
| * results are produced in this context. |
| * |
| * @param listener the listener to be added |
| */ |
| void addListener(AnalysisListener listener); |
| |
| /** |
| * Apply the given delta to change the level of analysis that will be performed for the sources |
| * known to this context. |
| * |
| * @param delta a description of the level of analysis that should be performed for some sources |
| */ |
| void applyAnalysisDelta(AnalysisDelta delta); |
| |
| /** |
| * Apply the changes specified by the given change set to this context. Any analysis results that |
| * have been invalidated by these changes will be removed. |
| * |
| * @param changeSet a description of the changes that are to be applied |
| */ |
| void applyChanges(ChangeSet changeSet); |
| |
| /** |
| * Return the documentation comment for the given element as it appears in the original source |
| * (complete with the beginning and ending delimiters) for block documentation comments, or lines |
| * starting with `"///"` and separated with `"\n"` characters for end-of-line |
| * documentation comments, or `null` if the element does not have a documentation comment |
| * associated with it. This can be a long-running operation if the information needed to access |
| * the comment is not cached. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param element the element whose documentation comment is to be returned |
| * @return the element's documentation comment |
| * @throws AnalysisException if the documentation comment could not be determined because the |
| * analysis could not be performed |
| */ |
| String computeDocumentationComment(Element element); |
| |
| /** |
| * Return an array containing all of the errors associated with the given source. If the errors |
| * are not already known then the source will be analyzed in order to determine the errors |
| * associated with it. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @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 |
| * See [getErrors]. |
| */ |
| List<AnalysisError> computeErrors(Source source); |
| |
| /** |
| * Return the element model corresponding to the HTML file 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 an HTML file can be long-running, depending on the size of the file and the number of |
| * libraries that are defined in it (via script tags) that also need to have a model built for |
| * them. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @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 |
| * @throws AnalysisException if the element model could not be determined because the analysis |
| * could not be performed |
| * See [getHtmlElement]. |
| */ |
| HtmlElement computeHtmlElement(Source source); |
| |
| /** |
| * Return the kind of the given source, computing it's kind if it is not already known. Return |
| * [SourceKind.UNKNOWN] if the source is not contained in this context. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param source the source whose kind is to be returned |
| * @return the kind of the given source |
| * See [getKindOf]. |
| */ |
| SourceKind computeKindOf(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. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @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 |
| * @throws AnalysisException if the element model could not be determined because the analysis |
| * could not be performed |
| * See [getLibraryElement]. |
| */ |
| LibraryElement computeLibraryElement(Source source); |
| |
| /** |
| * Return the line information for the given source, or `null` if the source is not of a |
| * recognized kind (neither a Dart nor HTML file). If the line information was not previously |
| * known it will be created. The line information is used to map offsets from the beginning of the |
| * source to line and column pairs. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @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]. |
| */ |
| LineInfo computeLineInfo(Source source); |
| |
| /** |
| * Return a future which will be completed with the fully resolved AST for a |
| * single compilation unit within the given library, once that AST is up to |
| * date. |
| * |
| * If the resolved AST can't be computed for some reason, the future will be |
| * completed with an error. One possible error is AnalysisNotScheduledError, |
| * which means that the resolved AST can't be computed because the given |
| * source file is not scheduled to be analyzed within the context of the |
| * given library. |
| */ |
| CancelableFuture<CompilationUnit> |
| computeResolvedCompilationUnitAsync(Source source, Source librarySource); |
| |
| /** |
| * 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); |
| |
| /** |
| * Return the element model corresponding to the compilation unit defined by the given source in |
| * the library defined by the given source, or `null` if the element model does not |
| * currently exist or if the library cannot be analyzed for some reason. |
| * |
| * @param unitSource the source of the compilation unit |
| * @param librarySource the source of the defining compilation unit of the library containing the |
| * compilation unit |
| * @return the element model corresponding to the compilation unit defined by the given source |
| */ |
| CompilationUnitElement getCompilationUnitElement(Source unitSource, |
| Source librarySource); |
| |
| /** |
| * Get the contents and timestamp of the given source. |
| * |
| * 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); |
| |
| /** |
| * 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); |
| |
| /** |
| * Return an analysis error info containing the array of all of the errors and the line info |
| * associated with the given source. The array of errors will be empty if the source is not known |
| * to this context or if there are no errors in the source. The errors contained in the array can |
| * be incomplete. |
| * |
| * @param source the source whose errors are to be returned |
| * @return all of the errors associated with the given source and the line info |
| * See [computeErrors]. |
| */ |
| AnalysisErrorInfo getErrors(Source source); |
| |
| /** |
| * Return the element model corresponding to the HTML file defined by the given source, or |
| * `null` if the source does not represent an HTML file, the element representing the file |
| * has not yet been created, or the analysis of the HTML file failed for some reason. |
| * |
| * @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 |
| * See [computeHtmlElement]. |
| */ |
| HtmlElement getHtmlElement(Source source); |
| |
| /** |
| * Return the sources for the HTML files that reference the given compilation unit. If the source |
| * does not represent a Dart source or is not known to this context, the returned array will be |
| * empty. The contents of the array can be incomplete. |
| * |
| * @param source the source referenced by the returned HTML files |
| * @return the sources for the HTML files that reference the given compilation unit |
| */ |
| List<Source> getHtmlFilesReferencing(Source source); |
| |
| /** |
| * Return the kind of the given source, or `null` if the kind is not known to this context. |
| * |
| * @param source the source whose kind is to be returned |
| * @return the kind of the given source |
| * See [computeKindOf]. |
| */ |
| SourceKind getKindOf(Source source); |
| |
| /** |
| * Return the sources for the defining compilation units of any libraries of which the given |
| * source is a part. The array will normally contain a single library because most Dart sources |
| * are only included in a single library, but it is possible to have a part that is contained in |
| * multiple identically named libraries. If the source represents the defining compilation unit of |
| * a library, then the returned array will contain the given source as its only element. If the |
| * source does not represent a Dart source or is not known to this context, the returned array |
| * will be empty. The contents of the array can be incomplete. |
| * |
| * @param source the source contained in the returned libraries |
| * @return the sources for the libraries containing the given source |
| */ |
| List<Source> getLibrariesContaining(Source source); |
| |
| /** |
| * Return the sources for the defining compilation units of any libraries that depend on the given |
| * library. One library depends on another if it either imports or exports that library. |
| * |
| * @param librarySource the source for the defining compilation unit of the library being depended |
| * on |
| * @return the sources for the libraries that depend on the given library |
| */ |
| List<Source> getLibrariesDependingOn(Source librarySource); |
| |
| /** |
| * Return the sources for the defining compilation units of any libraries that are referenced from |
| * the given HTML file. |
| * |
| * @param htmlSource the source for the HTML file |
| * @return the sources for the libraries that are referenced by the given HTML file |
| */ |
| List<Source> getLibrariesReferencedFromHtml(Source htmlSource); |
| |
| /** |
| * Return the element model corresponding to the library defined by the given source, or |
| * `null` if the element model does not currently exist or if the library cannot be analyzed |
| * for some reason. |
| * |
| * @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 getLibraryElement(Source source); |
| |
| /** |
| * Return the line information for the given source, or `null` if the line information is |
| * not known. The line information is used to map offsets from the beginning of the source to line |
| * and column pairs. |
| * |
| * @param source the source whose line information is to be returned |
| * @return the line information for the given source |
| * See [computeLineInfo]. |
| */ |
| LineInfo getLineInfo(Source source); |
| |
| /** |
| * Return the modification stamp for the given source. A modification stamp is a non-negative |
| * integer with the property that if the contents of the source have not been modified since the |
| * last time the modification stamp was accessed then the same value will be returned, but if the |
| * contents of the source have been modified one or more times (even if the net change is zero) |
| * the stamps will be different. |
| * |
| * This method should be used rather than the method [Source.getModificationStamp] because |
| * contexts can have local overrides of the content of a source that the source is not aware of. |
| * |
| * @param source the source whose modification stamp is to be returned |
| * @return the modification stamp for the source |
| */ |
| int getModificationStamp(Source source); |
| |
| /** |
| * Return a fully resolved AST for a single compilation unit within the given library, or |
| * `null` if the resolved AST is not already computed. |
| * |
| * @param unitSource the source of the compilation unit |
| * @param library the library containing the compilation unit |
| * @return a fully resolved AST for the compilation unit |
| * See [resolveCompilationUnit]. |
| */ |
| CompilationUnit getResolvedCompilationUnit(Source unitSource, |
| LibraryElement library); |
| |
| /** |
| * Return a fully resolved AST for a single compilation unit within the given library, or |
| * `null` if the resolved AST is not already computed. |
| * |
| * @param unitSource the source of the compilation unit |
| * @param librarySource the source of the defining compilation unit of the library containing the |
| * compilation unit |
| * @return a fully resolved AST for the compilation unit |
| * See [resolveCompilationUnit]. |
| */ |
| CompilationUnit getResolvedCompilationUnit2(Source unitSource, |
| Source librarySource); |
| |
| /** |
| * Return a fully resolved HTML unit, or `null` if the resolved unit is not already |
| * computed. |
| * |
| * @param htmlSource the source of the HTML unit |
| * @return a fully resolved HTML unit |
| * See [resolveHtmlUnit]. |
| */ |
| ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource); |
| |
| /** |
| * Return `true` if the given source is known to be the defining compilation unit of a |
| * library that can be run on a client (references '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 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); |
| |
| /** |
| * 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 |
| * @return `true` if the given source is known to be a library that can be run on the server |
| */ |
| bool isServerLibrary(Source librarySource); |
| |
| /** |
| * 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. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @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 parseCompilationUnit(Source source); |
| |
| /** |
| * Parse a single HTML source to produce an AST structure. The resulting HTML AST structure may or |
| * may not be resolved, and may have a slightly different structure depending upon whether it is |
| * resolved. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param source the HTML source to be parsed |
| * @return the parse result (not `null`) |
| * @throws AnalysisException if the analysis could not be performed |
| */ |
| ht.HtmlUnit parseHtmlUnit(Source source); |
| |
| /** |
| * Perform the next unit of work required to keep the analysis results up-to-date and return |
| * information about the consequent changes to the analysis results. This method can be long |
| * running. |
| * |
| * @return the results of performing the analysis |
| */ |
| AnalysisResult performAnalysisTask(); |
| |
| /** |
| * Remove the given listener from the list of objects that are to be notified when various |
| * analysis results are produced in this context. |
| * |
| * @param listener the listener to be removed |
| */ |
| void removeListener(AnalysisListener listener); |
| |
| /** |
| * Parse and resolve a single source within the given context to produce a fully resolved AST. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param unitSource the source to be parsed and resolved |
| * @param library the library containing the source to be resolved |
| * @return the result of resolving the AST structure representing the content of the source in the |
| * context of the given library |
| * @throws AnalysisException if the analysis could not be performed |
| * See [getResolvedCompilationUnit]. |
| */ |
| CompilationUnit resolveCompilationUnit(Source unitSource, |
| LibraryElement library); |
| |
| /** |
| * Parse and resolve a single source within the given context to produce a fully resolved AST. |
| * Return the resolved AST structure, or `null` if the source could not be either parsed or |
| * resolved. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param unitSource the source to be parsed and resolved |
| * @param librarySource the source of the defining compilation unit of the library containing the |
| * source to be resolved |
| * @return the result of resolving the AST structure representing the content of the source in the |
| * context of the given library |
| * @throws AnalysisException if the analysis could not be performed |
| * See [getResolvedCompilationUnit]. |
| */ |
| CompilationUnit resolveCompilationUnit2(Source unitSource, |
| Source librarySource); |
| |
| /** |
| * Parse and resolve a single source within the given context to produce a fully resolved AST. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param htmlSource the source to be parsed and resolved |
| * @return the result of resolving the AST structure representing the content of the source |
| * @throws AnalysisException if the analysis could not be performed |
| */ |
| ht.HtmlUnit resolveHtmlUnit(Source htmlSource); |
| |
| /** |
| * Set the contents of the given source to the given contents and mark the source as having |
| * changed. The additional offset and length information is used by the context to determine what |
| * reanalysis is necessary. |
| * |
| * @param source the source whose contents are being overridden |
| * @param contents the text to replace the range in the current contents |
| * @param offset the offset into the current contents |
| * @param oldLength the number of characters in the original contents that were replaced |
| * @param newLength the number of characters in the replacement text |
| */ |
| void setChangedContents(Source source, String contents, int offset, |
| int oldLength, int newLength); |
| |
| /** |
| * Set the contents of the given source to the given contents and mark the source as having |
| * changed. This has the effect of overriding the default contents of the source. If the contents |
| * are `null` the override is removed so that the default contents will be returned. |
| * |
| * @param source the source whose contents are being overridden |
| * @param contents the new contents of the source |
| */ |
| void setContents(Source source, String contents); |
| } |
| |
| /** |
| * Instances of the class `AnalysisContextImpl` implement an [AnalysisContext]. |
| */ |
| class AnalysisContextImpl implements InternalAnalysisContext { |
| /** |
| * The difference between the maximum cache size and the maximum priority order size. The priority |
| * list must be capped so that it is less than the cache size. Failure to do so can result in an |
| * infinite loop in performAnalysisTask() because re-caching one AST structure can cause another |
| * priority source's AST structure to be flushed. |
| */ |
| static int _PRIORITY_ORDER_SIZE_DELTA = 4; |
| |
| /** |
| * A flag indicating whether trace output should be produced as analysis tasks are performed. Used |
| * for debugging. |
| */ |
| static bool _TRACE_PERFORM_TASK = false; |
| |
| /** |
| * The next context identifier. |
| */ |
| static int _NEXT_ID = 0; |
| |
| /** |
| * The unique identifier of this context. |
| */ |
| final int _id = _NEXT_ID++; |
| |
| /** |
| * The set of analysis options controlling the behavior of this context. |
| */ |
| AnalysisOptionsImpl _options = new AnalysisOptionsImpl(); |
| |
| /** |
| * A flag indicating whether errors related to sources in the SDK should be generated and |
| * reported. |
| */ |
| bool _generateSdkErrors = true; |
| |
| /** |
| * 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; |
| |
| /** |
| * The set of declared variables used when computing constant values. |
| */ |
| DeclaredVariables _declaredVariables = new DeclaredVariables(); |
| |
| /** |
| * A source representing the core library. |
| */ |
| Source _coreLibrarySource; |
| |
| /** |
| * The partition that contains analysis results that are not shared with other contexts. |
| */ |
| CachePartition _privatePartition; |
| |
| /** |
| * A table mapping the sources known to the context to the information known about the source. |
| */ |
| AnalysisCache _cache; |
| |
| /** |
| * An array containing sources for which data should not be flushed. |
| */ |
| List<Source> _priorityOrder = Source.EMPTY_ARRAY; |
| |
| /** |
| * A map from all sources for which there are futures pending to a list of |
| * the corresponding PendingFuture objects. These sources will be analyzed |
| * in the same way as priority sources, except with higher priority. |
| * |
| * TODO(paulberry): since the size of this map is not constrained (as it is |
| * for _priorityOrder), we run the risk of creating an analysis loop if |
| * re-caching one AST structure causes the AST structure for another source |
| * with pending futures to be flushed. However, this is unlikely to happen |
| * in practice since sources are removed from this hash set as soon as their |
| * futures have completed. |
| */ |
| HashMap<Source, List<PendingFuture>> _pendingFutureSources = |
| new HashMap<Source, List<PendingFuture>>(); |
| |
| /** |
| * An array containing sources whose AST structure is needed in order to resolve the next library |
| * to be resolved. |
| */ |
| HashSet<Source> _neededForResolution = null; |
| |
| /** |
| * A table mapping sources to the change notices that are waiting to be returned related to that |
| * source. |
| */ |
| HashMap<Source, ChangeNoticeImpl> _pendingNotices = |
| new HashMap<Source, ChangeNoticeImpl>(); |
| |
| /** |
| * The object used to record the results of performing an analysis task. |
| */ |
| AnalysisContextImpl_AnalysisTaskResultRecorder _resultRecorder; |
| |
| /** |
| * Cached information used in incremental analysis or `null` if none. Synchronize against |
| * [cacheLock] before accessing this field. |
| */ |
| IncrementalAnalysisCache _incrementalAnalysisCache; |
| |
| /** |
| * The object used to manage the list of sources that need to be analyzed. |
| */ |
| WorkManager _workManager = new WorkManager(); |
| |
| /** |
| * The [Stopwatch] of the current "perform tasks cycle". |
| */ |
| Stopwatch _performAnalysisTaskStopwatch; |
| |
| /** |
| * The controller for sending [SourcesChangedEvent]s. |
| */ |
| StreamController<SourcesChangedEvent> _onSourcesChangedController; |
| |
| /** |
| * The listeners that are to be notified when various analysis results are produced in this |
| * context. |
| */ |
| List<AnalysisListener> _listeners = new List<AnalysisListener>(); |
| |
| /** |
| * The most recently incrementally resolved [Source]. |
| * Is null when it was already validated, or the most recent change was |
| * not incrementally resolved. |
| */ |
| Source incrementalResolutionValidation_lastUnitSource; |
| |
| /** |
| * The most recently incrementally resolved library [Source]. |
| * Is null when it was already validated, or the most recent change was |
| * not incrementally resolved. |
| */ |
| Source incrementalResolutionValidation_lastLibrarySource; |
| |
| /** |
| * The result of incremental resolution result of |
| * [incrementalResolutionValidation_lastSource]. |
| */ |
| CompilationUnit incrementalResolutionValidation_lastUnit; |
| |
| /** |
| * Initialize a newly created analysis context. |
| */ |
| AnalysisContextImpl() { |
| _resultRecorder = new AnalysisContextImpl_AnalysisTaskResultRecorder(this); |
| _privatePartition = new UniversalCachePartition( |
| this, |
| AnalysisOptionsImpl.DEFAULT_CACHE_SIZE, |
| new AnalysisContextImpl_ContextRetentionPolicy(this)); |
| _cache = createCacheFromSourceFactory(null); |
| _onSourcesChangedController = |
| new StreamController<SourcesChangedEvent>.broadcast(); |
| } |
| |
| @override |
| AnalysisOptions get analysisOptions => _options; |
| |
| @override |
| void set analysisOptions(AnalysisOptions options) { |
| bool needsRecompute = |
| this._options.analyzeFunctionBodies != options.analyzeFunctionBodies || |
| this._options.generateSdkErrors != options.generateSdkErrors || |
| this._options.dart2jsHint != options.dart2jsHint || |
| (this._options.hint && !options.hint) || |
| this._options.preserveComments != options.preserveComments; |
| int cacheSize = options.cacheSize; |
| if (this._options.cacheSize != cacheSize) { |
| this._options.cacheSize = cacheSize; |
| //cache.setMaxCacheSize(cacheSize); |
| _privatePartition.maxCacheSize = cacheSize; |
| // |
| // Cap the size of the priority list to being less than the cache size. |
| // Failure to do so can result in an infinite loop in |
| // performAnalysisTask() because re-caching one AST structure |
| // can cause another priority source's AST structure to be flushed. |
| // |
| int maxPriorityOrderSize = cacheSize - _PRIORITY_ORDER_SIZE_DELTA; |
| if (_priorityOrder.length > maxPriorityOrderSize) { |
| List<Source> newPriorityOrder = new List<Source>(maxPriorityOrderSize); |
| JavaSystem.arraycopy( |
| _priorityOrder, |
| 0, |
| newPriorityOrder, |
| 0, |
| maxPriorityOrderSize); |
| _priorityOrder = newPriorityOrder; |
| } |
| } |
| this._options.analyzeFunctionBodies = options.analyzeFunctionBodies; |
| this._options.generateSdkErrors = options.generateSdkErrors; |
| this._options.dart2jsHint = options.dart2jsHint; |
| this._options.hint = options.hint; |
| this._options.incremental = options.incremental; |
| this._options.incrementalApi = options.incrementalApi; |
| this._options.incrementalValidation = options.incrementalValidation; |
| this._options.preserveComments = options.preserveComments; |
| _generateSdkErrors = options.generateSdkErrors; |
| if (needsRecompute) { |
| _invalidateAllLocalResolutionInformation(false); |
| } |
| } |
| |
| @override |
| void set analysisPriorityOrder(List<Source> sources) { |
| if (sources == null || sources.isEmpty) { |
| _priorityOrder = Source.EMPTY_ARRAY; |
| } else { |
| while (sources.remove(null)) { |
| // Nothing else to do. |
| } |
| if (sources.isEmpty) { |
| _priorityOrder = Source.EMPTY_ARRAY; |
| } |
| // |
| // Cap the size of the priority list to being less than the cache size. |
| // Failure to do so can result in an infinite loop in |
| // performAnalysisTask() because re-caching one AST structure |
| // can cause another priority source's AST structure to be flushed. |
| // |
| int count = |
| math.min(sources.length, _options.cacheSize - _PRIORITY_ORDER_SIZE_DELTA); |
| _priorityOrder = new List<Source>(count); |
| for (int i = 0; i < count; i++) { |
| _priorityOrder[i] = sources[i]; |
| } |
| } |
| } |
| |
| @override |
| set contentCache(ContentCache value) { |
| _contentCache = value; |
| } |
| |
| @override |
| DeclaredVariables get declaredVariables => _declaredVariables; |
| |
| @override |
| List<Source> get htmlSources => _getSources(SourceKind.HTML); |
| |
| @override |
| bool get isDisposed => _disposed; |
| |
| @override |
| 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>(); |
| MapIterator<Source, SourceEntry> iterator = _cache.iterator(); |
| while (iterator.moveNext()) { |
| Source source = iterator.key; |
| SourceEntry sourceEntry = iterator.value; |
| if (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 sources; |
| } |
| |
| @override |
| List<Source> get launchableServerLibrarySources { |
| // TODO(brianwilkerson) This needs to filter out libraries that reference |
| // dart:html, either directly or indirectly. |
| List<Source> sources = new List<Source>(); |
| MapIterator<Source, SourceEntry> iterator = _cache.iterator(); |
| while (iterator.moveNext()) { |
| Source source = iterator.key; |
| SourceEntry sourceEntry = iterator.value; |
| if (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 sources; |
| } |
| |
| @override |
| List<Source> get librarySources => _getSources(SourceKind.LIBRARY); |
| |
| /** |
| * Look through the cache for a task that needs to be performed. Return the task that was found, |
| * or `null` if there is no more work to be done. |
| * |
| * @return the next task that needs to be performed |
| */ |
| AnalysisTask get nextAnalysisTask { |
| bool hintsEnabled = _options.hint; |
| bool lintsEnabled = _options.lint; |
| bool hasBlockedTask = false; |
| // |
| // Look for incremental analysis |
| // |
| if (_incrementalAnalysisCache != null && |
| _incrementalAnalysisCache.hasWork) { |
| AnalysisTask task = |
| new IncrementalAnalysisTask(this, _incrementalAnalysisCache); |
| _incrementalAnalysisCache = null; |
| return task; |
| } |
| // |
| // Look for a source that needs to be analyzed because it has futures |
| // pending. |
| // |
| if (_pendingFutureSources.isNotEmpty) { |
| List<Source> sourcesToRemove = <Source>[]; |
| AnalysisTask task; |
| for (Source source in _pendingFutureSources.keys) { |
| SourceEntry sourceEntry = _cache.get(source); |
| List<PendingFuture> pendingFutures = _pendingFutureSources[source]; |
| for (int i = 0; i < pendingFutures.length; ) { |
| if (pendingFutures[i].evaluate(sourceEntry)) { |
| pendingFutures.removeAt(i); |
| } else { |
| i++; |
| } |
| } |
| if (pendingFutures.isEmpty) { |
| sourcesToRemove.add(source); |
| continue; |
| } |
| AnalysisContextImpl_TaskData taskData = _getNextAnalysisTaskForSource( |
| source, |
| sourceEntry, |
| true, |
| hintsEnabled, |
| lintsEnabled); |
| task = taskData.task; |
| if (task != null) { |
| break; |
| } else if (taskData.isBlocked) { |
| hasBlockedTask = true; |
| } else { |
| // There is no more work to do for this task, so forcibly complete |
| // all its pending futures. |
| for (PendingFuture pendingFuture in pendingFutures) { |
| pendingFuture.forciblyComplete(); |
| } |
| sourcesToRemove.add(source); |
| } |
| } |
| for (Source source in sourcesToRemove) { |
| _pendingFutureSources.remove(source); |
| } |
| if (task != null) { |
| return task; |
| } |
| } |
| // |
| // Look for a priority source that needs to be analyzed. |
| // |
| int priorityCount = _priorityOrder.length; |
| for (int i = 0; i < priorityCount; i++) { |
| Source source = _priorityOrder[i]; |
| AnalysisContextImpl_TaskData taskData = _getNextAnalysisTaskForSource( |
| source, |
| _cache.get(source), |
| true, |
| hintsEnabled, |
| lintsEnabled); |
| AnalysisTask task = taskData.task; |
| if (task != null) { |
| return task; |
| } else if (taskData.isBlocked) { |
| hasBlockedTask = true; |
| } |
| } |
| if (_neededForResolution != null) { |
| List<Source> sourcesToRemove = new List<Source>(); |
| for (Source source in _neededForResolution) { |
| SourceEntry sourceEntry = _cache.get(source); |
| if (sourceEntry is DartEntry) { |
| DartEntry dartEntry = sourceEntry; |
| if (!dartEntry.hasResolvableCompilationUnit) { |
| if (dartEntry.getState(DartEntry.PARSED_UNIT) == CacheState.ERROR) { |
| sourcesToRemove.add(source); |
| } else { |
| AnalysisContextImpl_TaskData taskData = |
| _createParseDartTask(source, dartEntry); |
| AnalysisTask task = taskData.task; |
| if (task != null) { |
| return task; |
| } else if (taskData.isBlocked) { |
| hasBlockedTask = true; |
| } |
| } |
| } |
| } |
| } |
| int count = sourcesToRemove.length; |
| for (int i = 0; i < count; i++) { |
| _neededForResolution.remove(sourcesToRemove[i]); |
| } |
| } |
| // |
| // Look for a non-priority source that needs to be analyzed. |
| // |
| List<Source> sourcesToRemove = new List<Source>(); |
| WorkManager_WorkIterator sources = _workManager.iterator(); |
| try { |
| while (sources.hasNext) { |
| Source source = sources.next(); |
| AnalysisContextImpl_TaskData taskData = _getNextAnalysisTaskForSource( |
| source, |
| _cache.get(source), |
| false, |
| hintsEnabled, |
| lintsEnabled); |
| AnalysisTask task = taskData.task; |
| if (task != null) { |
| return task; |
| } else if (taskData.isBlocked) { |
| hasBlockedTask = true; |
| } else { |
| sourcesToRemove.add(source); |
| } |
| } |
| } finally { |
| int count = sourcesToRemove.length; |
| for (int i = 0; i < count; i++) { |
| _workManager.remove(sourcesToRemove[i]); |
| } |
| } |
| if (hasBlockedTask) { |
| // All of the analysis work is blocked waiting for an asynchronous task |
| // to complete. |
| return WaitForAsyncTask.instance; |
| } |
| return null; |
| } |
| |
| @override |
| Stream<SourcesChangedEvent> get onSourcesChanged => |
| _onSourcesChangedController.stream; |
| |
| /** |
| * Make _pendingFutureSources available to unit tests. |
| */ |
| HashMap<Source, List<PendingFuture>> get pendingFutureSources_forTesting => |
| _pendingFutureSources; |
| |
| @override |
| List<Source> get prioritySources => _priorityOrder; |
| |
| @override |
| List<Source> get refactoringUnsafeSources { |
| List<Source> sources = new List<Source>(); |
| MapIterator<Source, SourceEntry> iterator = _cache.iterator(); |
| while (iterator.moveNext()) { |
| SourceEntry sourceEntry = iterator.value; |
| if (sourceEntry is DartEntry) { |
| Source source = iterator.key; |
| if (!source.isInSystemLibrary && !sourceEntry.isRefactoringSafe) { |
| sources.add(source); |
| } |
| } |
| } |
| return sources; |
| } |
| |
| @override |
| SourceFactory get sourceFactory => _sourceFactory; |
| |
| @override |
| void set sourceFactory(SourceFactory factory) { |
| if (identical(_sourceFactory, factory)) { |
| return; |
| } else if (factory.context != null) { |
| throw new IllegalStateException( |
| "Source factories cannot be shared between contexts"); |
| } |
| if (_sourceFactory != null) { |
| _sourceFactory.context = null; |
| } |
| factory.context = this; |
| _sourceFactory = factory; |
| _coreLibrarySource = _sourceFactory.forUri(DartSdk.DART_CORE); |
| _cache = createCacheFromSourceFactory(factory); |
| _invalidateAllLocalResolutionInformation(true); |
| } |
| |
| /** |
| * Return a list of the sources that would be processed by [performAnalysisTask]. This |
| * method duplicates, and must therefore be kept in sync with, [getNextAnalysisTask]. |
| * This method is intended to be used for testing purposes only. |
| * |
| * @return a list of the sources that would be processed by [performAnalysisTask] |
| */ |
| List<Source> get sourcesNeedingProcessing { |
| HashSet<Source> sources = new HashSet<Source>(); |
| bool hintsEnabled = _options.hint; |
| bool lintsEnabled = _options.lint; |
| |
| // |
| // Look for priority sources that need to be analyzed. |
| // |
| for (Source source in _priorityOrder) { |
| _getSourcesNeedingProcessing( |
| source, |
| _cache.get(source), |
| true, |
| hintsEnabled, |
| lintsEnabled, |
| sources); |
| } |
| // |
| // Look for non-priority sources that need to be analyzed. |
| // |
| WorkManager_WorkIterator iterator = _workManager.iterator(); |
| while (iterator.hasNext) { |
| Source source = iterator.next(); |
| _getSourcesNeedingProcessing( |
| source, |
| _cache.get(source), |
| false, |
| hintsEnabled, |
| lintsEnabled, |
| sources); |
| } |
| return new List<Source>.from(sources); |
| } |
| |
| @override |
| AnalysisContextStatistics get statistics { |
| AnalysisContextStatisticsImpl statistics = |
| new AnalysisContextStatisticsImpl(); |
| visitCacheItems(statistics._internalPutCacheItem); |
| statistics.partitionData = _cache.partitionData; |
| return statistics; |
| } |
| |
| IncrementalAnalysisCache get test_incrementalAnalysisCache { |
| return _incrementalAnalysisCache; |
| } |
| |
| set test_incrementalAnalysisCache(IncrementalAnalysisCache value) { |
| _incrementalAnalysisCache = value; |
| } |
| |
| List<Source> get test_priorityOrder => _priorityOrder; |
| |
| @override |
| TypeProvider get typeProvider { |
| Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE); |
| if (coreSource == null) { |
| throw new AnalysisException("Could not create a source for dart:core"); |
| } |
| LibraryElement coreElement = computeLibraryElement(coreSource); |
| if (coreElement == null) { |
| throw new AnalysisException("Could not create an element for dart:core"); |
| } |
| return new TypeProviderImpl(coreElement); |
| } |
| |
| @override |
| void addListener(AnalysisListener listener) { |
| if (!_listeners.contains(listener)) { |
| _listeners.add(listener); |
| } |
| } |
| |
| @override |
| void addSourceInfo(Source source, SourceEntry info) { |
| // This implementation assumes that the access to the cache does not need to |
| // be synchronized because no other object can have access to this context |
| // while this method is being invoked. |
| _cache.put(source, info); |
| } |
| |
| @override |
| void applyAnalysisDelta(AnalysisDelta delta) { |
| ChangeSet changeSet = new ChangeSet(); |
| delta.analysisLevels.forEach((Source source, AnalysisLevel level) { |
| if (level == AnalysisLevel.NONE) { |
| changeSet.removedSource(source); |
| } else { |
| changeSet.addedSource(source); |
| } |
| }); |
| applyChanges(changeSet); |
| } |
| |
| @override |
| void applyChanges(ChangeSet changeSet) { |
| if (changeSet.isEmpty) { |
| return; |
| } |
| // |
| // First, compute the list of sources that have been removed. |
| // |
| List<Source> removedSources = |
| new List<Source>.from(changeSet.removedSources); |
| for (SourceContainer container in changeSet.removedContainers) { |
| _addSourcesInContainer(removedSources, container); |
| } |
| // |
| // Then determine which cached results are no longer valid. |
| // |
| bool addedDartSource = false; |
| for (Source source in changeSet.addedSources) { |
| if (_sourceAvailable(source)) { |
| addedDartSource = true; |
| } |
| } |
| for (Source source in changeSet.changedSources) { |
| if (_contentCache.getContents(source) != null) { |
| // This source is overridden in the content cache, so the change will |
| // have no effect. Just ignore it to avoid wasting time doing |
| // re-analysis. |
| continue; |
| } |
| _sourceChanged(source); |
| } |
| changeSet.changedContents.forEach((Source key, String value) { |
| _contentsChanged(key, value, false); |
| }); |
| changeSet.changedRanges.forEach( |
| (Source source, ChangeSet_ContentChange change) { |
| _contentRangeChanged( |
| source, |
| change.contents, |
| change.offset, |
| change.oldLength, |
| change.newLength); |
| }); |
| for (Source source in changeSet.deletedSources) { |
| _sourceDeleted(source); |
| } |
| for (Source source in removedSources) { |
| _sourceRemoved(source); |
| } |
| if (addedDartSource) { |
| // TODO(brianwilkerson) This is hugely inefficient, but we need to |
| // re-analyze any libraries that might have been referencing the |
| // not-yet-existing source that was just added. Longer term we need to |
| // keep track of which libraries are referencing non-existing sources and |
| // only re-analyze those libraries. |
| // logInformation("Added Dart sources, invalidating all resolution information"); |
| List<Source> sourcesToInvalidate = new List<Source>(); |
| MapIterator<Source, SourceEntry> iterator = _cache.iterator(); |
| while (iterator.moveNext()) { |
| Source source = iterator.key; |
| SourceEntry sourceEntry = iterator.value; |
| if (!source.isInSystemLibrary && |
| (sourceEntry is DartEntry || sourceEntry is HtmlEntry)) { |
| sourcesToInvalidate.add(source); |
| } |
| } |
| int count = sourcesToInvalidate.length; |
| for (int i = 0; i < count; i++) { |
| Source source = sourcesToInvalidate[i]; |
| SourceEntry entry = _getReadableSourceEntry(source); |
| if (entry is DartEntry) { |
| entry.invalidateParseInformation(); |
| _workManager.add(source, _computePriority(entry)); |
| } else if (entry is HtmlEntry) { |
| entry.invalidateParseInformation(); |
| _workManager.add(source, SourcePriority.HTML); |
| } |
| } |
| } |
| _onSourcesChangedController.add(new SourcesChangedEvent(changeSet)); |
| } |
| |
| @override |
| String computeDocumentationComment(Element element) { |
| if (element == null) { |
| return null; |
| } |
| Source source = element.source; |
| if (source == null) { |
| return null; |
| } |
| CompilationUnit unit = parseCompilationUnit(source); |
| if (unit == null) { |
| return null; |
| } |
| NodeLocator locator = new NodeLocator.con1(element.nameOffset); |
| AstNode nameNode = locator.searchWithin(unit); |
| while (nameNode != null) { |
| if (nameNode is AnnotatedNode) { |
| Comment comment = (nameNode as AnnotatedNode).documentationComment; |
| if (comment == null) { |
| return null; |
| } |
| StringBuffer buffer = new StringBuffer(); |
| List<Token> tokens = comment.tokens; |
| for (int i = 0; i < tokens.length; i++) { |
| if (i > 0) { |
| buffer.write("\n"); |
| } |
| buffer.write(tokens[i].lexeme); |
| } |
| return buffer.toString(); |
| } |
| nameNode = nameNode.parent; |
| } |
| return null; |
| } |
| |
| @override |
| List<AnalysisError> computeErrors(Source source) { |
| bool enableHints = _options.hint; |
| bool enableLints = _options.lint; |
| |
| SourceEntry sourceEntry = _getReadableSourceEntry(source); |
| if (sourceEntry is DartEntry) { |
| List<AnalysisError> errors = new List<AnalysisError>(); |
| try { |
| DartEntry dartEntry = sourceEntry; |
| ListUtilities.addAll( |
| errors, |
| _getDartScanData(source, dartEntry, DartEntry.SCAN_ERRORS)); |
| dartEntry = _getReadableDartEntry(source); |
| ListUtilities.addAll( |
| errors, |
| _getDartParseData(source, dartEntry, DartEntry.PARSE_ERRORS)); |
| dartEntry = _getReadableDartEntry(source); |
| if (dartEntry.getValue(DartEntry.SOURCE_KIND) == SourceKind.LIBRARY) { |
| ListUtilities.addAll( |
| errors, |
| _getDartResolutionData(source, source, dartEntry, DartEntry.RESOLUTION_ERRORS)); |
| dartEntry = _getReadableDartEntry(source); |
| ListUtilities.addAll( |
| errors, |
| _getDartVerificationData( |
| source, |
| source, |
| dartEntry, |
| DartEntry.VERIFICATION_ERRORS)); |
| if (enableHints) { |
| dartEntry = _getReadableDartEntry(source); |
| ListUtilities.addAll( |
| errors, |
| _getDartHintData(source, source, dartEntry, DartEntry.HINTS)); |
| } |
| if (enableLints) { |
| dartEntry = _getReadableDartEntry(source); |
| ListUtilities.addAll( |
| errors, |
| _getDartLintData(source, source, dartEntry, DartEntry.LINTS)); |
| } |
| } else { |
| List<Source> libraries = getLibrariesContaining(source); |
| for (Source librarySource in libraries) { |
| ListUtilities.addAll( |
| errors, |
| _getDartResolutionData( |
| source, |
| librarySource, |
| dartEntry, |
| DartEntry.RESOLUTION_ERRORS)); |
| dartEntry = _getReadableDartEntry(source); |
| ListUtilities.addAll( |
| errors, |
| _getDartVerificationData( |
| source, |
| librarySource, |
| dartEntry, |
| DartEntry.VERIFICATION_ERRORS)); |
| if (enableHints) { |
| dartEntry = _getReadableDartEntry(source); |
| ListUtilities.addAll( |
| errors, |
| _getDartHintData(source, librarySource, dartEntry, DartEntry.HINTS)); |
| } |
| if (enableLints) { |
| dartEntry = _getReadableDartEntry(source); |
| ListUtilities.addAll( |
| errors, |
| _getDartLintData(source, librarySource, dartEntry, DartEntry.LINTS)); |
| } |
| } |
| } |
| } on ObsoleteSourceAnalysisException catch (exception, stackTrace) { |
| AnalysisEngine.instance.logger.logInformation( |
| "Could not compute errors", |
| new CaughtException(exception, stackTrace)); |
| } |
| if (errors.isEmpty) { |
| return AnalysisError.NO_ERRORS; |
| } |
| return errors; |
| } else if (sourceEntry is HtmlEntry) { |
| HtmlEntry htmlEntry = sourceEntry; |
| try { |
| return _getHtmlResolutionData2( |
| source, |
| htmlEntry, |
| HtmlEntry.RESOLUTION_ERRORS); |
| } on ObsoleteSourceAnalysisException catch (exception, stackTrace) { |
| AnalysisEngine.instance.logger.logInformation( |
| "Could not compute errors", |
| new CaughtException(exception, stackTrace)); |
| } |
| } |
| return AnalysisError.NO_ERRORS; |
| } |
| |
| @override |
| List<Source> computeExportedLibraries(Source source) => |
| _getDartParseData2(source, DartEntry.EXPORTED_LIBRARIES, Source.EMPTY_ARRAY); |
| |
| @override |
| HtmlElement computeHtmlElement(Source source) => |
| _getHtmlResolutionData(source, HtmlEntry.ELEMENT, null); |
| |
| @override |
| List<Source> computeImportedLibraries(Source source) => |
| _getDartParseData2(source, DartEntry.IMPORTED_LIBRARIES, Source.EMPTY_ARRAY); |
| |
| @override |
| SourceKind computeKindOf(Source source) { |
| SourceEntry sourceEntry = _getReadableSourceEntry(source); |
| if (sourceEntry == null) { |
| return SourceKind.UNKNOWN; |
| } else if (sourceEntry is DartEntry) { |
| try { |
| return _getDartParseData(source, sourceEntry, DartEntry.SOURCE_KIND); |
| } on AnalysisException catch (exception) { |
| return SourceKind.UNKNOWN; |
| } |
| } |
| return sourceEntry.kind; |
| } |
| |
| @override |
| LibraryElement computeLibraryElement(Source source) => |
| _getDartResolutionData2(source, source, DartEntry.ELEMENT, null); |
| |
| @override |
| LineInfo computeLineInfo(Source source) { |
| SourceEntry sourceEntry = _getReadableSourceEntry(source); |
| try { |
| if (sourceEntry is HtmlEntry) { |
| return _getHtmlParseData(source, SourceEntry.LINE_INFO, null); |
| } else if (sourceEntry is DartEntry) { |
| return _getDartScanData2(source, SourceEntry.LINE_INFO, null); |
| } |
| } on ObsoleteSourceAnalysisException catch (exception, stackTrace) { |
| AnalysisEngine.instance.logger.logInformation( |
| "Could not compute ${SourceEntry.LINE_INFO}", |
| new CaughtException(exception, stackTrace)); |
| } |
| return null; |
| } |
| |
| @override |
| CompilationUnit computeResolvableCompilationUnit(Source source) { |
| DartEntry dartEntry = _getReadableDartEntry(source); |
| if (dartEntry == null) { |
| throw new AnalysisException( |
| "computeResolvableCompilationUnit for non-Dart: ${source.fullName}"); |
| } |
| dartEntry = _cacheDartParseData(source, dartEntry, DartEntry.PARSED_UNIT); |
| CompilationUnit unit = dartEntry.resolvableCompilationUnit; |
| if (unit == null) { |
| throw new AnalysisException( |
| "Internal error: computeResolvableCompilationUnit could not parse ${source.fullName}", |
| new CaughtException(dartEntry.exception, null)); |
| } |
| return unit; |
| } |
| |
| @override |
| CancelableFuture<CompilationUnit> |
| computeResolvedCompilationUnitAsync(Source unitSource, Source librarySource) { |
| return new _AnalysisFutureHelper<CompilationUnit>( |
| this).computeAsync(unitSource, (SourceEntry sourceEntry) { |
| if (sourceEntry is DartEntry) { |
| if (sourceEntry.getStateInLibrary( |
| DartEntry.RESOLVED_UNIT, |
| librarySource) == |
| CacheState.ERROR) { |
| throw sourceEntry.exception; |
| } |
| return sourceEntry.getValueInLibrary( |
| DartEntry.RESOLVED_UNIT, |
| librarySource); |
| } |
| throw new AnalysisNotScheduledError(); |
| }); |
| } |
| |
| /** |
| * Create an analysis cache based on the given source factory. |
| * |
| * @param factory the source factory containing the information needed to create the cache |
| * @return the cache that was created |
| */ |
| AnalysisCache createCacheFromSourceFactory(SourceFactory factory) { |
| if (factory == null) { |
| return new AnalysisCache(<CachePartition>[_privatePartition]); |
| } |
| DartSdk sdk = factory.dartSdk; |
| if (sdk == null) { |
| return new AnalysisCache(<CachePartition>[_privatePartition]); |
| } |
| return new AnalysisCache( |
| <CachePartition>[ |
| AnalysisEngine.instance.partitionManager.forSdk(sdk), |
| _privatePartition]); |
| } |
| |
| @override |
| void dispose() { |
| _disposed = true; |
| for (List<PendingFuture> pendingFutures in _pendingFutureSources.values) { |
| for (PendingFuture pendingFuture in pendingFutures) { |
| pendingFuture.forciblyComplete(); |
| } |
| } |
| _pendingFutureSources.clear(); |
| } |
| |
| @override |
| bool exists(Source source) { |
| if (source == null) { |
| return false; |
| } |
| if (_contentCache.getContents(source) != null) { |
| return true; |
| } |
| return source.exists(); |
| } |
| |
| Element findElementById(int id) { |
| _ElementByIdFinder finder = new _ElementByIdFinder(id); |
| try { |
| MapIterator<Source, SourceEntry> iterator = _cache.iterator(); |
| while (iterator.moveNext()) { |
| SourceEntry sourceEntry = iterator.value; |
| if (sourceEntry.kind == SourceKind.LIBRARY) { |
| DartEntry dartEntry = sourceEntry; |
| LibraryElement library = dartEntry.getValue(DartEntry.ELEMENT); |
| if (library != null) { |
| library.accept(finder); |
| } |
| } |
| } |
| } on _ElementByIdFinderException catch (e) { |
| return finder.result; |
| } |
| return null; |
| } |
| |
| @override |
| CompilationUnitElement getCompilationUnitElement(Source unitSource, |
| Source librarySource) { |
| LibraryElement libraryElement = getLibraryElement(librarySource); |
| if (libraryElement != null) { |
| // try defining unit |
| CompilationUnitElement definingUnit = |
| libraryElement.definingCompilationUnit; |
| if (definingUnit.source == unitSource) { |
| return definingUnit; |
| } |
| // try parts |
| for (CompilationUnitElement partUnit in libraryElement.parts) { |
| if (partUnit.source == unitSource) { |
| return partUnit; |
| } |
| } |
| } |
| return null; |
| } |
| |
| @override |
| TimestampedData<String> getContents(Source source) { |
| String contents = _contentCache.getContents(source); |
| if (contents != null) { |
| return new TimestampedData<String>( |
| _contentCache.getModificationStamp(source), |
| contents); |
| } |
| return source.contents; |
| } |
| |
| @override |
| InternalAnalysisContext getContextFor(Source source) { |
| InternalAnalysisContext context = _cache.getContextFor(source); |
| return context == null ? this : context; |
| } |
| |
| @override |
| Element getElement(ElementLocation location) { |
| // TODO(brianwilkerson) This should not be a "get" method. |
| try { |
| List<String> components = location.components; |
| Source source = _computeSourceFromEncoding(components[0]); |
| String sourceName = source.shortName; |
| if (AnalysisEngine.isDartFileName(sourceName)) { |
| ElementImpl element = computeLibraryElement(source) as ElementImpl; |
| for (int i = 1; i < components.length; i++) { |
| if (element == null) { |
| return null; |
| } |
| element = element.getChild(components[i]); |
| } |
| return element; |
| } |
| if (AnalysisEngine.isHtmlFileName(sourceName)) { |
| return computeHtmlElement(source); |
| } |
| } on AnalysisException catch (exception) { |
| } |
| return null; |
| } |
| |
| @override |
| AnalysisErrorInfo getErrors(Source 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); |
| } |
| |
| @override |
| HtmlElement getHtmlElement(Source source) { |
| SourceEntry sourceEntry = getReadableSourceEntryOrNull(source); |
| if (sourceEntry is HtmlEntry) { |
| return sourceEntry.getValue(HtmlEntry.ELEMENT); |
| } |
| return null; |
| } |
| |
| @override |
| List<Source> getHtmlFilesReferencing(Source source) { |
| SourceKind sourceKind = getKindOf(source); |
| if (sourceKind == null) { |
| return Source.EMPTY_ARRAY; |
| } |
| List<Source> htmlSources = new List<Source>(); |
| while (true) { |
| if (sourceKind == SourceKind.PART) { |
| List<Source> librarySources = getLibrariesContaining(source); |
| MapIterator<Source, SourceEntry> partIterator = _cache.iterator(); |
| while (partIterator.moveNext()) { |
| SourceEntry sourceEntry = partIterator.value; |
| if (sourceEntry.kind == SourceKind.HTML) { |
| List<Source> referencedLibraries = |
| (sourceEntry as HtmlEntry).getValue(HtmlEntry.REFERENCED_LIBRARIES); |
| if (_containsAny(referencedLibraries, librarySources)) { |
| htmlSources.add(partIterator.key); |
| } |
| } |
| } |
| } else { |
| MapIterator<Source, SourceEntry> iterator = _cache.iterator(); |
| while (iterator.moveNext()) { |
| SourceEntry sourceEntry = iterator.value; |
| if (sourceEntry.kind == SourceKind.HTML) { |
| List<Source> referencedLibraries = |
| (sourceEntry as HtmlEntry).getValue(HtmlEntry.REFERENCED_LIBRARIES); |
| if (_contains(referencedLibraries, source)) { |
| htmlSources.add(iterator.key); |
| } |
| } |
| } |
| } |
| break; |
| } |
| if (htmlSources.isEmpty) { |
| return Source.EMPTY_ARRAY; |
| } |
| return htmlSources; |
| } |
| |
| @override |
| SourceKind getKindOf(Source source) { |
| SourceEntry sourceEntry = getReadableSourceEntryOrNull(source); |
| if (sourceEntry == null) { |
| return SourceKind.UNKNOWN; |
| } |
| return sourceEntry.kind; |
| } |
| |
| @override |
| List<Source> getLibrariesContaining(Source source) { |
| SourceEntry sourceEntry = getReadableSourceEntryOrNull(source); |
| if (sourceEntry is DartEntry) { |
| return sourceEntry.containingLibraries; |
| } |
| return Source.EMPTY_ARRAY; |
| } |
| |
| @override |
| List<Source> getLibrariesDependingOn(Source librarySource) { |
| List<Source> dependentLibraries = new List<Source>(); |
| MapIterator<Source, SourceEntry> iterator = _cache.iterator(); |
| while (iterator.moveNext()) { |
| SourceEntry sourceEntry = iterator.value; |
| if (sourceEntry.kind == SourceKind.LIBRARY) { |
| if (_contains( |
| (sourceEntry as DartEntry).getValue(DartEntry.EXPORTED_LIBRARIES), |
| librarySource)) { |
| dependentLibraries.add(iterator.key); |
| } |
| if (_contains( |
| (sourceEntry as DartEntry).getValue(DartEntry.IMPORTED_LIBRARIES), |
| librarySource)) { |
| dependentLibraries.add(iterator.key); |
| } |
| } |
| } |
| if (dependentLibraries.isEmpty) { |
| return Source.EMPTY_ARRAY; |
| } |
| return dependentLibraries; |
| } |
| |
| @override |
| List<Source> getLibrariesReferencedFromHtml(Source htmlSource) { |
| SourceEntry sourceEntry = getReadableSourceEntryOrNull(htmlSource); |
| if (sourceEntry is HtmlEntry) { |
| HtmlEntry htmlEntry = sourceEntry; |
| return htmlEntry.getValue(HtmlEntry.REFERENCED_LIBRARIES); |
| } |
| return Source.EMPTY_ARRAY; |
| } |
| |
| @override |
| LibraryElement getLibraryElement(Source source) { |
| SourceEntry sourceEntry = getReadableSourceEntryOrNull(source); |
| if (sourceEntry is DartEntry) { |
| return sourceEntry.getValue(DartEntry.ELEMENT); |
| } |
| return null; |
| } |
| |
| @override |
| LineInfo getLineInfo(Source source) { |
| SourceEntry sourceEntry = getReadableSourceEntryOrNull(source); |
| if (sourceEntry != null) { |
| return sourceEntry.getValue(SourceEntry.LINE_INFO); |
| } |
| return null; |
| } |
| |
| @override |
| int getModificationStamp(Source source) { |
| int stamp = _contentCache.getModificationStamp(source); |
| if (stamp != null) { |
| return stamp; |
| } |
| return source.modificationStamp; |
| } |
| |
| @override |
| Namespace getPublicNamespace(LibraryElement library) { |
| // TODO(brianwilkerson) Rename this to not start with 'get'. |
| // Note that this is not part of the API of the interface. |
| Source source = library.definingCompilationUnit.source; |
| DartEntry dartEntry = _getReadableDartEntry(source); |
| if (dartEntry == null) { |
| return null; |
| } |
| Namespace namespace = null; |
| if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) { |
| namespace = dartEntry.getValue(DartEntry.PUBLIC_NAMESPACE); |
| } |
| if (namespace == null) { |
| NamespaceBuilder builder = new NamespaceBuilder(); |
| namespace = builder.createPublicNamespaceForLibrary(library); |
| if (dartEntry == null) { |
| AnalysisEngine.instance.logger.logError( |
| "Could not compute the public namespace for ${library.source.fullName}", |
| new CaughtException( |
| new AnalysisException("A Dart file became a non-Dart file: ${source.fullName}"), |
| null)); |
| return null; |
| } |
| if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) { |
| dartEntry.setValue(DartEntry.PUBLIC_NAMESPACE, namespace); |
| } |
| } |
| return namespace; |
| } |
| |
| /** |
| * 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); |
| |
| @override |
| CompilationUnit getResolvedCompilationUnit(Source unitSource, |
| LibraryElement library) { |
| if (library == null) { |
| return null; |
| } |
| return getResolvedCompilationUnit2(unitSource, library.source); |
| } |
| |
| @override |
| CompilationUnit getResolvedCompilationUnit2(Source unitSource, |
| Source librarySource) { |
| SourceEntry sourceEntry = getReadableSourceEntryOrNull(unitSource); |
| if (sourceEntry is DartEntry) { |
| return sourceEntry.getValueInLibrary( |
| DartEntry.RESOLVED_UNIT, |
| librarySource); |
| } |
| return null; |
| } |
| |
| @override |
| ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource) { |
| SourceEntry sourceEntry = getReadableSourceEntryOrNull(htmlSource); |
| if (sourceEntry is HtmlEntry) { |
| HtmlEntry htmlEntry = sourceEntry; |
| return htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT); |
| } |
| return null; |
| } |
| |
| @override |
| bool handleContentsChanged(Source source, String originalContents, |
| String newContents, bool notify) { |
| SourceEntry sourceEntry = _cache.get(source); |
| if (sourceEntry == null) { |
| return false; |
| } |
| bool changed = newContents != originalContents; |
| if (newContents != null) { |
| if (newContents != originalContents) { |
| _incrementalAnalysisCache = |
| IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source); |
| if (!analysisOptions.incremental || |
| !_tryPoorMansIncrementalResolution(source, newContents)) { |
| _sourceChanged(source); |
| } |
| if (sourceEntry != null) { |
| sourceEntry.modificationTime = |
| _contentCache.getModificationStamp(source); |
| sourceEntry.setValue(SourceEntry.CONTENT, newContents); |
| } |
| } else { |
| if (sourceEntry != null) { |
| sourceEntry.modificationTime = |
| _contentCache.getModificationStamp(source); |
| } |
| } |
| } else if (originalContents != null) { |
| _incrementalAnalysisCache = |
| IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source); |
| changed = newContents != originalContents; |
| // We are removing the overlay for the file, check if the file's |
| // contents is the same as it was in the overlay. |
| if (sourceEntry != null) { |
| try { |
| TimestampedData<String> fileContents = getContents(source); |
| String fileContentsData = fileContents.data; |
| if (fileContentsData == originalContents) { |
| sourceEntry.modificationTime = fileContents.modificationTime; |
| sourceEntry.setValue(SourceEntry.CONTENT, fileContentsData); |
| changed = false; |
| } |
| } catch (e) { |
| } |
| } |
| // If not the same content (e.g. the file is being closed without save), |
| // then force analysis. |
| if (changed) { |
| _sourceChanged(source); |
| } |
| } |
| if (notify && changed) { |
| _onSourcesChangedController.add( |
| new SourcesChangedEvent.changedContent(source, newContents)); |
| } |
| return changed; |
| } |
| |
| @override |
| 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; |
| } |
| |
| @override |
| 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; |
| } |
| |
| @override |
| CompilationUnit parseCompilationUnit(Source source) => |
| _getDartParseData2(source, DartEntry.PARSED_UNIT, null); |
| |
| @override |
| ht.HtmlUnit parseHtmlUnit(Source source) => |
| _getHtmlParseData(source, HtmlEntry.PARSED_UNIT, null); |
| |
| @override |
| AnalysisResult performAnalysisTask() { |
| if (_TRACE_PERFORM_TASK) { |
| print("----------------------------------------"); |
| } |
| int getStart = JavaSystem.currentTimeMillis(); |
| AnalysisTask task = nextAnalysisTask; |
| int getEnd = JavaSystem.currentTimeMillis(); |
| if (task == null && _validateCacheConsistency()) { |
| task = nextAnalysisTask; |
| } |
| if (task == null) { |
| _validateLastIncrementalResolutionResult(); |
| if (_performAnalysisTaskStopwatch != null) { |
| AnalysisEngine.instance.instrumentationService.logPerformance( |
| AnalysisPerformanceKind.FULL, |
| _performAnalysisTaskStopwatch, |
| 'context_id=$_id'); |
| _performAnalysisTaskStopwatch = null; |
| } |
| return new AnalysisResult( |
| _getChangeNotices(true), |
| getEnd - getStart, |
| null, |
| -1); |
| } |
| if (_performAnalysisTaskStopwatch == null) { |
| _performAnalysisTaskStopwatch = new Stopwatch()..start(); |
| } |
| String taskDescription = task.toString(); |
| _notifyAboutToPerformTask(taskDescription); |
| if (_TRACE_PERFORM_TASK) { |
| print(taskDescription); |
| } |
| int performStart = JavaSystem.currentTimeMillis(); |
| try { |
| task.perform(_resultRecorder); |
| } on ObsoleteSourceAnalysisException catch (exception, stackTrace) { |
| AnalysisEngine.instance.logger.logInformation( |
| "Could not perform analysis task: $taskDescription", |
| new CaughtException(exception, stackTrace)); |
| } on AnalysisException catch (exception, stackTrace) { |
| if (exception.cause is! JavaIOException) { |
| AnalysisEngine.instance.logger.logError( |
| "Internal error while performing the task: $task", |
| new CaughtException(exception, stackTrace)); |
| } |
| } |
| int performEnd = JavaSystem.currentTimeMillis(); |
| List<ChangeNotice> notices = _getChangeNotices(false); |
| int noticeCount = notices.length; |
| for (int i = 0; i < noticeCount; i++) { |
| ChangeNotice notice = notices[i]; |
| Source source = notice.source; |
| // TODO(brianwilkerson) Figure out whether the compilation unit is always |
| // resolved, or whether we need to decide whether to invoke the "parsed" |
| // or "resolved" method. This might be better done when recording task |
| // results in order to reduce the chance of errors. |
| // if (notice.getCompilationUnit() != null) { |
| // notifyResolvedDart(source, notice.getCompilationUnit()); |
| // } else if (notice.getHtmlUnit() != null) { |
| // notifyResolvedHtml(source, notice.getHtmlUnit()); |
| // } |
| _notifyErrors(source, notice.errors, notice.lineInfo); |
| } |
| return new AnalysisResult( |
| notices, |
| getEnd - getStart, |
| task.runtimeType.toString(), |
| performEnd - performStart); |
| } |
| |
| @override |
| void recordLibraryElements(Map<Source, LibraryElement> elementMap) { |
| Source htmlSource = _sourceFactory.forUri(DartSdk.DART_HTML); |
| elementMap.forEach((Source librarySource, LibraryElement library) { |
| // |
| // Cache the element in the library's info. |
| // |
| DartEntry dartEntry = _getReadableDartEntry(librarySource); |
| if (dartEntry != null) { |
| _recordElementData(dartEntry, library, library.source, htmlSource); |
| dartEntry.setState(SourceEntry.CONTENT, CacheState.FLUSHED); |
| dartEntry.setValue(SourceEntry.LINE_INFO, new LineInfo(<int>[0])); |
| // DartEntry.ELEMENT - set in recordElementData |
| dartEntry.setValue(DartEntry.EXPORTED_LIBRARIES, Source.EMPTY_ARRAY); |
| dartEntry.setValue(DartEntry.IMPORTED_LIBRARIES, Source.EMPTY_ARRAY); |
| dartEntry.setValue(DartEntry.INCLUDED_PARTS, Source.EMPTY_ARRAY); |
| // DartEntry.IS_CLIENT - set in recordElementData |
| // DartEntry.IS_LAUNCHABLE - set in recordElementData |
| dartEntry.setValue(DartEntry.PARSE_ERRORS, AnalysisError.NO_ERRORS); |
| dartEntry.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED); |
| dartEntry.setState(DartEntry.PUBLIC_NAMESPACE, CacheState.FLUSHED); |
| dartEntry.setValue(DartEntry.SCAN_ERRORS, AnalysisError.NO_ERRORS); |
| dartEntry.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY); |
| dartEntry.setState(DartEntry.TOKEN_STREAM, CacheState.FLUSHED); |
| dartEntry.setValueInLibrary( |
| DartEntry.RESOLUTION_ERRORS, |
| librarySource, |
| AnalysisError.NO_ERRORS); |
| dartEntry.setStateInLibrary( |
| DartEntry.RESOLVED_UNIT, |
| librarySource, |
| CacheState.FLUSHED); |
| dartEntry.setValueInLibrary( |
| DartEntry.VERIFICATION_ERRORS, |
| librarySource, |
| AnalysisError.NO_ERRORS); |
| dartEntry.setValueInLibrary( |
| DartEntry.HINTS, |
| librarySource, |
| AnalysisError.NO_ERRORS); |
| dartEntry.setValueInLibrary( |
| DartEntry.LINTS, |
| librarySource, |
| AnalysisError.NO_ERRORS); |
| } |
| }); |
| } |
| |
| /** |
| * Record the results produced by performing a [task] and return the cache |
| * entry associated with the results. |
| */ |
| DartEntry |
| recordResolveDartLibraryCycleTaskResults(ResolveDartLibraryCycleTask task) { |
| LibraryResolver2 resolver = task.libraryResolver; |
| CaughtException thrownException = task.exception; |
| Source unitSource = task.unitSource; |
| DartEntry unitEntry = _getReadableDartEntry(unitSource); |
| if (resolver != null) { |
| // |
| // The resolver should only be null if an exception was thrown before (or |
| // while) it was being created. |
| // |
| List<ResolvableLibrary> resolvedLibraries = resolver.resolvedLibraries; |
| if (resolvedLibraries == null) { |
| // |
| // The resolved libraries should only be null if an exception was thrown |
| // during resolution. |
| // |
| if (thrownException == null) { |
| var message = |
| "In recordResolveDartLibraryCycleTaskResults, " |
| "resolvedLibraries was null and there was no thrown exception"; |
| unitEntry.recordResolutionError( |
| new CaughtException(new AnalysisException(message), null)); |
| } else { |
| unitEntry.recordResolutionError(thrownException); |
| } |
| _cache.remove(unitSource); |
| if (thrownException != null) { |
| throw new AnalysisException('<rethrow>', thrownException); |
| } |
| return unitEntry; |
| } |
| Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML); |
| RecordingErrorListener errorListener = resolver.errorListener; |
| for (ResolvableLibrary library in resolvedLibraries) { |
| Source librarySource = library.librarySource; |
| for (Source source in library.compilationUnitSources) { |
| CompilationUnit unit = library.getAST(source); |
| List<AnalysisError> errors = errorListener.getErrorsForSource(source); |
| LineInfo lineInfo = getLineInfo(source); |
| DartEntry dartEntry = _cache.get(source); |
| if (thrownException == null) { |
| dartEntry.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED); |
| dartEntry.setValueInLibrary( |
| DartEntry.RESOLVED_UNIT, |
| librarySource, |
| unit); |
| dartEntry.setValueInLibrary( |
| DartEntry.RESOLUTION_ERRORS, |
| librarySource, |
| errors); |
| if (source == librarySource) { |
| _recordElementData( |
| dartEntry, |
| library.libraryElement, |
| librarySource, |
| htmlSource); |
| } |
| _cache.storedAst(source); |
| } else { |
| dartEntry.recordResolutionErrorInLibrary( |
| librarySource, |
| thrownException); |
| } |
| if (source != librarySource) { |
| _workManager.add(source, SourcePriority.PRIORITY_PART); |
| } |
| ChangeNoticeImpl notice = _getNotice(source); |
| notice.resolvedDartUnit = unit; |
| notice.setErrors(dartEntry.allErrors, lineInfo); |
| } |
| } |
| } |
| if (thrownException != null) { |
| throw new AnalysisException('<rethrow>', thrownException); |
| } |
| return unitEntry; |
| } |
| |
| /** |
| * Record the results produced by performing a [task] and return the cache |
| * entry associated with the results. |
| */ |
| DartEntry recordResolveDartLibraryTaskResults(ResolveDartLibraryTask task) { |
| LibraryResolver resolver = task.libraryResolver; |
| CaughtException thrownException = task.exception; |
| Source unitSource = task.unitSource; |
| DartEntry unitEntry = _getReadableDartEntry(unitSource); |
| if (resolver != null) { |
| // |
| // The resolver should only be null if an exception was thrown before (or |
| // while) it was being created. |
| // |
| Set<Library> resolvedLibraries = resolver.resolvedLibraries; |
| if (resolvedLibraries == null) { |
| // |
| // The resolved libraries should only be null if an exception was thrown |
| // during resolution. |
| // |
| if (thrownException == null) { |
| String message = |
| "In recordResolveDartLibraryTaskResults, " |
| "resolvedLibraries was null and there was no thrown exception"; |
| unitEntry.recordResolutionError( |
| new CaughtException(new AnalysisException(message), null)); |
| } else { |
| unitEntry.recordResolutionError(thrownException); |
| } |
| _cache.remove(unitSource); |
| if (thrownException != null) { |
| throw new AnalysisException('<rethrow>', thrownException); |
| } |
| return unitEntry; |
| } |
| Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML); |
| RecordingErrorListener errorListener = resolver.errorListener; |
| for (Library library in resolvedLibraries) { |
| Source librarySource = library.librarySource; |
| for (Source source in library.compilationUnitSources) { |
| CompilationUnit unit = library.getAST(source); |
| List<AnalysisError> errors = errorListener.getErrorsForSource(source); |
| LineInfo lineInfo = getLineInfo(source); |
| DartEntry dartEntry = _cache.get(source); |
| if (thrownException == null) { |
| dartEntry.setValue(SourceEntry.LINE_INFO, lineInfo); |
| dartEntry.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED); |
| dartEntry.setValueInLibrary( |
| DartEntry.RESOLVED_UNIT, |
| librarySource, |
| unit); |
| dartEntry.setValueInLibrary( |
| DartEntry.RESOLUTION_ERRORS, |
| librarySource, |
| errors); |
| if (source == librarySource) { |
| _recordElementData( |
| dartEntry, |
| library.libraryElement, |
| librarySource, |
| htmlSource); |
| } |
| _cache.storedAst(source); |
| } else { |
| dartEntry.recordResolutionErrorInLibrary( |
| librarySource, |
| thrownException); |
| _cache.remove(source); |
| } |
| if (source != librarySource) { |
| _workManager.add(source, SourcePriority.PRIORITY_PART); |
| } |
| ChangeNoticeImpl notice = _getNotice(source); |
| notice.resolvedDartUnit = unit; |
| notice.setErrors(dartEntry.allErrors, lineInfo); |
| } |
| } |
| } |
| if (thrownException != null) { |
| throw new AnalysisException('<rethrow>', thrownException); |
| } |
| return unitEntry; |
| } |
| |
| @override |
| void removeListener(AnalysisListener listener) { |
| _listeners.remove(listener); |
| } |
| |
| @override |
| CompilationUnit resolveCompilationUnit(Source unitSource, |
| LibraryElement library) { |
| if (library == null) { |
| return null; |
| } |
| return resolveCompilationUnit2(unitSource, library.source); |
| } |
| |
| @override |
| CompilationUnit resolveCompilationUnit2(Source unitSource, |
| Source librarySource) => |
| _getDartResolutionData2( |
| unitSource, |
| librarySource, |
| DartEntry.RESOLVED_UNIT, |
| null); |
| |
| @override |
| ht.HtmlUnit resolveHtmlUnit(Source htmlSource) { |
| computeHtmlElement(htmlSource); |
| return parseHtmlUnit(htmlSource); |
| } |
| |
| @override |
| void setChangedContents(Source source, String contents, int offset, |
| int oldLength, int newLength) { |
| if (_contentRangeChanged(source, contents, offset, oldLength, newLength)) { |
| _onSourcesChangedController.add( |
| new SourcesChangedEvent.changedRange( |
| source, |
| contents, |
| offset, |
| oldLength, |
| newLength)); |
| } |
| } |
| |
| @override |
| void setContents(Source source, String contents) { |
| _contentsChanged(source, contents, true); |
| } |
| |
| @override |
| void visitCacheItems(void callback(Source source, SourceEntry dartEntry, |
| DataDescriptor rowDesc, CacheState state)) { |
| bool hintsEnabled = _options.hint; |
| bool lintsEnabled = _options.lint; |
| MapIterator<Source, SourceEntry> iterator = _cache.iterator(); |
| while (iterator.moveNext()) { |
| Source source = iterator.key; |
| SourceEntry sourceEntry = iterator.value; |
| for (DataDescriptor descriptor in sourceEntry.descriptors) { |
| if (descriptor == DartEntry.SOURCE_KIND) { |
| // The source kind is always valid, so the state isn't interesting. |
| continue; |
| } else if (descriptor == DartEntry.CONTAINING_LIBRARIES) { |
| // The list of containing libraries is always valid, so the state |
| // isn't interesting. |
| continue; |
| } else if (descriptor == DartEntry.PUBLIC_NAMESPACE) { |
| // The public namespace isn't computed by performAnalysisTask() |
| // and therefore isn't interesting. |
| continue; |
| } else if (descriptor == HtmlEntry.HINTS) { |
| // We are not currently recording any hints related to HTML. |
| continue; |
| } |
| callback( |
| source, |
| sourceEntry, |
| descriptor, |
| sourceEntry.getState(descriptor)); |
| } |
| if (sourceEntry is DartEntry) { |
| // get library-specific values |
| List<Source> librarySources = getLibrariesContaining(source); |
| for (Source librarySource in librarySources) { |
| for (DataDescriptor descriptor in sourceEntry.libraryDescriptors) { |
| if (descriptor == DartEntry.BUILT_ELEMENT || |
| descriptor == DartEntry.BUILT_UNIT) { |
| // These values are not currently being computed, so their state |
| // is not interesting. |
| continue; |
| } else if (source.isInSystemLibrary && |
| !_generateSdkErrors && |
| (descriptor == DartEntry.VERIFICATION_ERRORS || |
| descriptor == DartEntry.HINTS || |
| descriptor == DartEntry.LINTS)) { |
| continue; |
| } else if (!hintsEnabled && descriptor == DartEntry.HINTS) { |
| continue; |
| } else if (!lintsEnabled && descriptor == DartEntry.LINTS) { |
| continue; |
| } |
| callback( |
| librarySource, |
| sourceEntry, |
| descriptor, |
| sourceEntry.getStateInLibrary(descriptor, librarySource)); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Visit all entries of the content cache. |
| */ |
| void visitContentCache(ContentCacheVisitor visitor) { |
| _contentCache.accept(visitor); |
| } |
| |
| /** |
| * Record that we have accessed the AST structure associated with the given source. At the moment, |
| * there is no differentiation between the parsed and resolved forms of the AST. |
| * |
| * @param source the source whose AST structure was accessed |
| */ |
| void _accessedAst(Source source) { |
| _cache.accessedAst(source); |
| } |
| |
| /** |
| * Add all of the sources contained in the given source container to the given list of sources. |
| * |
| * Note: This method must only be invoked while we are synchronized on [cacheLock]. |
| * |
| * @param sources the list to which sources are to be added |
| * @param container the source container containing the sources to be added to the list |
| */ |
| void _addSourcesInContainer(List<Source> sources, SourceContainer container) { |
| MapIterator<Source, SourceEntry> iterator = _cache.iterator(); |
| while (iterator.moveNext()) { |
| Source source = iterator.key; |
| if (container.contains(source)) { |
| sources.add(source); |
| } |
| } |
| } |
| |
| /** |
| * Given a source for a Dart file and the library that contains it, return a cache entry in which |
| * the state of the data represented by the given descriptor is either [CacheState.VALID] or |
| * [CacheStateERROR]. This method assumes that the data can be produced by generating hints |
| * for the library if the data is not already cached. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param unitSource the source representing the Dart file |
| * @param librarySource the source representing the library containing the Dart file |
| * @param dartEntry the cache entry associated with the Dart file |
| * @param descriptor the descriptor representing the data to be returned |
| * @return a cache entry containing the required data |
| * @throws AnalysisException if data could not be returned because the source could not be parsed |
| */ |
| DartEntry _cacheDartHintData(Source unitSource, Source librarySource, |
| DartEntry dartEntry, DataDescriptor descriptor) { |
| // |
| // Check to see whether we already have the information being requested. |
| // |
| CacheState state = dartEntry.getStateInLibrary(descriptor, librarySource); |
| while (state != CacheState.ERROR && state != CacheState.VALID) { |
| // |
| // If not, compute the information. |
| // Unless the modification date of the source continues to change, |
| // this loop will eventually terminate. |
| // |
| DartEntry libraryEntry = _getReadableDartEntry(librarySource); |
| libraryEntry = _cacheDartResolutionData( |
| librarySource, |
| librarySource, |
| libraryEntry, |
| DartEntry.ELEMENT); |
| LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT); |
| CompilationUnitElement definingUnit = |
| libraryElement.definingCompilationUnit; |
| List<CompilationUnitElement> parts = libraryElement.parts; |
| List<TimestampedData<CompilationUnit>> units = |
| new List<TimestampedData>(parts.length + 1); |
| units[0] = _getResolvedUnit(definingUnit, librarySource); |
| if (units[0] == null) { |
| Source source = definingUnit.source; |
| units[0] = new TimestampedData<CompilationUnit>( |
| getModificationStamp(source), |
| resolveCompilationUnit(source, libraryElement)); |
| } |
| for (int i = 0; i < parts.length; i++) { |
| units[i + 1] = _getResolvedUnit(parts[i], librarySource); |
| if (units[i + 1] == null) { |
| Source source = parts[i].source; |
| units[i + |
| 1] = new TimestampedData<CompilationUnit>( |
| getModificationStamp(source), |
| resolveCompilationUnit(source, libraryElement)); |
| } |
| } |
| dartEntry = new GenerateDartHintsTask( |
| this, |
| units, |
| getLibraryElement(librarySource)).perform(_resultRecorder) as DartEntry; |
| state = dartEntry.getStateInLibrary(descriptor, librarySource); |
| } |
| return dartEntry; |
| } |
| |
| /** |
| * Given a source for a Dart file and the library that contains it, return a cache entry in which |
| * the state of the data represented by the given descriptor is either [CacheState.VALID] or |
| * [CacheStateERROR]. This method assumes that the data can be produced by generating lints |
| * for the library if the data is not already cached. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param unitSource the source representing the Dart file |
| * @param librarySource the source representing the library containing the Dart file |
| * @param dartEntry the cache entry associated with the Dart file |
| * @param descriptor the descriptor representing the data to be returned |
| * @return a cache entry containing the required data |
| * @throws AnalysisException if data could not be returned because the source could not be parsed |
| */ |
| DartEntry _cacheDartLintData(Source unitSource, Source librarySource, |
| DartEntry dartEntry, DataDescriptor descriptor) { |
| // |
| // Check to see whether we already have the information being requested. |
| // |
| CacheState state = dartEntry.getStateInLibrary(descriptor, librarySource); |
| while (state != CacheState.ERROR && state != CacheState.VALID) { |
| // |
| // If not, compute the information. |
| // Unless the modification date of the source continues to change, |
| // this loop will eventually terminate. |
| // |
| DartEntry libraryEntry = _getReadableDartEntry(librarySource); |
| libraryEntry = _cacheDartResolutionData( |
| librarySource, |
| librarySource, |
| libraryEntry, |
| DartEntry.ELEMENT); |
| LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT); |
| CompilationUnitElement definingUnit = |
| libraryElement.definingCompilationUnit; |
| List<CompilationUnitElement> parts = libraryElement.parts; |
| List<TimestampedData<CompilationUnit>> units = |
| new List<TimestampedData>(parts.length + 1); |
| units[0] = _getResolvedUnit(definingUnit, librarySource); |
| if (units[0] == null) { |
| Source source = definingUnit.source; |
| units[0] = new TimestampedData<CompilationUnit>( |
| getModificationStamp(source), |
| resolveCompilationUnit(source, libraryElement)); |
| } |
| for (int i = 0; i < parts.length; i++) { |
| units[i + 1] = _getResolvedUnit(parts[i], librarySource); |
| if (units[i + 1] == null) { |
| Source source = parts[i].source; |
| units[i + |
| 1] = new TimestampedData<CompilationUnit>( |
| getModificationStamp(source), |
| resolveCompilationUnit(source, libraryElement)); |
| } |
| } |
| //TODO(pquitslund): revisit if we need all units or whether one will do |
| dartEntry = new GenerateDartLintsTask( |
| this, |
| units, |
| getLibraryElement(librarySource)).perform(_resultRecorder) as DartEntry; |
| state = dartEntry.getStateInLibrary(descriptor, librarySource); |
| } |
| return dartEntry; |
| } |
| |
| /** |
| * Given a source for a Dart file, return a cache entry in which the state of the data represented |
| * by the given descriptor is either [CacheState.VALID] or [CacheState.ERROR]. This |
| * method assumes that the data can be produced by parsing the source if it is not already cached. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param source the source representing the Dart file |
| * @param dartEntry the cache entry associated with the Dart file |
| * @param descriptor the descriptor representing the data to be returned |
| * @return a cache entry containing the required data |
| * @throws AnalysisException if data could not be returned because the source could not be parsed |
| */ |
| DartEntry _cacheDartParseData(Source source, DartEntry dartEntry, |
| DataDescriptor descriptor) { |
| if (identical(descriptor, DartEntry.PARSED_UNIT)) { |
| if (dartEntry.hasResolvableCompilationUnit) { |
| return dartEntry; |
| } |
| } |
| // |
| // Check to see whether we already have the information being requested. |
| // |
| CacheState state = dartEntry.getState(descriptor); |
| while (state != CacheState.ERROR && state != CacheState.VALID) { |
| // |
| // If not, compute the information. Unless the modification date of the |
| // source continues to change, this loop will eventually terminate. |
| // |
| dartEntry = _cacheDartScanData(source, dartEntry, DartEntry.TOKEN_STREAM); |
| dartEntry = new ParseDartTask( |
| this, |
| source, |
| dartEntry.getValue(DartEntry.TOKEN_STREAM), |
| dartEntry.getValue( |
| SourceEntry.LINE_INFO)).perform(_resultRecorder) as DartEntry; |
| state = dartEntry.getState(descriptor); |
| } |
| return dartEntry; |
| } |
| |
| /** |
| * Given a source for a Dart file and the library that contains it, return a cache entry in which |
| * the state of the data represented by the given descriptor is either [CacheState.VALID] or |
| * [CacheState.ERROR]. This method assumes that the data can be produced by resolving the |
| * source in the context of the library if it is not already cached. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param unitSource the source representing the Dart file |
| * @param librarySource the source representing the library containing the Dart file |
| * @param dartEntry the cache entry associated with the Dart file |
| * @param descriptor the descriptor representing the data to be returned |
| * @return a cache entry containing the required data |
| * @throws AnalysisException if data could not be returned because the source could not be parsed |
| */ |
| DartEntry _cacheDartResolutionData(Source unitSource, Source librarySource, |
| DartEntry dartEntry, DataDescriptor descriptor) { |
| // |
| // Check to see whether we already have the information being requested. |
| // |
| CacheState state = (identical(descriptor, DartEntry.ELEMENT)) ? |
| dartEntry.getState(descriptor) : |
| dartEntry.getStateInLibrary(descriptor, librarySource); |
| while (state != CacheState.ERROR && state != CacheState.VALID) { |
| // |
| // If not, compute the information. Unless the modification date of the |
| // source continues to change, this loop will eventually terminate. |
| // |
| // TODO(brianwilkerson) As an optimization, if we already have the |
| // element model for the library we can use ResolveDartUnitTask to produce |
| // the resolved AST structure much faster. |
| dartEntry = new ResolveDartLibraryTask( |
| this, |
| unitSource, |
| librarySource).perform(_resultRecorder) as DartEntry; |
| state = (identical(descriptor, DartEntry.ELEMENT)) ? |
| dartEntry.getState(descriptor) : |
| dartEntry.getStateInLibrary(descriptor, librarySource); |
| } |
| return dartEntry; |
| } |
| |
| /** |
| * Given a source for a Dart file, return a cache entry in which the state of the data represented |
| * by the given descriptor is either [CacheState.VALID] or [CacheState.ERROR]. This |
| * method assumes that the data can be produced by scanning the source if it is not already |
| * cached. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param source the source representing the Dart file |
| * @param dartEntry the cache entry associated with the Dart file |
| * @param descriptor the descriptor representing the data to be returned |
| * @return a cache entry containing the required data |
| * @throws AnalysisException if data could not be returned because the source could not be scanned |
| */ |
| DartEntry _cacheDartScanData(Source source, DartEntry dartEntry, |
| DataDescriptor descriptor) { |
| // |
| // Check to see whether we already have the information being requested. |
| // |
| CacheState state = dartEntry.getState(descriptor); |
| while (state != CacheState.ERROR && state != CacheState.VALID) { |
| // |
| // If not, compute the information. Unless the modification date of the |
| // source continues to change, this loop will eventually terminate. |
| // |
| try { |
| if (dartEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) { |
| dartEntry = |
| new GetContentTask(this, source).perform(_resultRecorder) as DartEntry; |
| } |
| dartEntry = new ScanDartTask( |
| this, |
| source, |
| dartEntry.getValue(SourceEntry.CONTENT)).perform(_resultRecorder) as DartEntry; |
| } on AnalysisException catch (exception) { |
| throw exception; |
| } catch (exception, stackTrace) { |
| throw new AnalysisException( |
| "Exception", |
| new CaughtException(exception, stackTrace)); |
| } |
| state = dartEntry.getState(descriptor); |
| } |
| return dartEntry; |
| } |
| |
| /** |
| * Given a source for a Dart file and the library that contains it, return a cache entry in which |
| * the state of the data represented by the given descriptor is either [CacheState.VALID] or |
| * [CacheState.ERROR]. This method assumes that the data can be produced by verifying the |
| * source in the given library if the data is not already cached. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param unitSource the source representing the Dart file |
| * @param librarySource the source representing the library containing the Dart file |
| * @param dartEntry the cache entry associated with the Dart file |
| * @param descriptor the descriptor representing the data to be returned |
| * @return a cache entry containing the required data |
| * @throws AnalysisException if data could not be returned because the source could not be parsed |
| */ |
| DartEntry _cacheDartVerificationData(Source unitSource, Source librarySource, |
| DartEntry dartEntry, DataDescriptor descriptor) { |
| // |
| // Check to see whether we already have the information being requested. |
| // |
| CacheState state = dartEntry.getStateInLibrary(descriptor, librarySource); |
| while (state != CacheState.ERROR && state != CacheState.VALID) { |
| // |
| // If not, compute the information. Unless the modification date of the |
| // source continues to change, this loop will eventually terminate. |
| // |
| LibraryElement library = computeLibraryElement(librarySource); |
| CompilationUnit unit = resolveCompilationUnit(unitSource, library); |
| if (unit == null) { |
| throw new AnalysisException( |
| "Could not resolve compilation unit ${unitSource.fullName} in ${librarySource.fullName}"); |
| } |
| dartEntry = new GenerateDartErrorsTask( |
| this, |
| unitSource, |
| unit, |
| library).perform(_resultRecorder) as DartEntry; |
| state = dartEntry.getStateInLibrary(descriptor, librarySource); |
| } |
| return dartEntry; |
| } |
| |
| /** |
| * Given a source for an HTML file, return a cache entry in which all of the data represented by |
| * the state of the given descriptors is either [CacheState.VALID] or |
| * [CacheState.ERROR]. This method assumes that the data can be produced by parsing the |
| * source if it is not already cached. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param source the source representing the HTML file |
| * @param htmlEntry the cache entry associated with the HTML file |
| * @param descriptor the descriptor representing the data to be returned |
| * @return a cache entry containing the required data |
| * @throws AnalysisException if data could not be returned because the source could not be |
| * resolved |
| */ |
| HtmlEntry _cacheHtmlParseData(Source source, HtmlEntry htmlEntry, |
| DataDescriptor descriptor) { |
| if (identical(descriptor, HtmlEntry.PARSED_UNIT)) { |
| ht.HtmlUnit unit = htmlEntry.anyParsedUnit; |
| if (unit != null) { |
| return htmlEntry; |
| } |
| } |
| // |
| // Check to see whether we already have the information being requested. |
| // |
| CacheState state = htmlEntry.getState(descriptor); |
| while (state != CacheState.ERROR && state != CacheState.VALID) { |
| // |
| // If not, compute the information. Unless the modification date of the |
| // source continues to change, this loop will eventually terminate. |
| // |
| try { |
| if (htmlEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) { |
| htmlEntry = |
| new GetContentTask(this, source).perform(_resultRecorder) as HtmlEntry; |
| } |
| htmlEntry = new ParseHtmlTask( |
| this, |
| source, |
| htmlEntry.getValue(SourceEntry.CONTENT)).perform(_resultRecorder) as HtmlEntry; |
| } on AnalysisException catch (exception) { |
| throw exception; |
| } catch (exception, stackTrace) { |
| throw new AnalysisException( |
| "Exception", |
| new CaughtException(exception, stackTrace)); |
| } |
| state = htmlEntry.getState(descriptor); |
| } |
| return htmlEntry; |
| } |
| |
| /** |
| * Given a source for an HTML file, return a cache entry in which the state of the data |
| * represented by the given descriptor is either [CacheState.VALID] or |
| * [CacheState.ERROR]. This method assumes that the data can be produced by resolving the |
| * source if it is not already cached. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param source the source representing the HTML file |
| * @param dartEntry the cache entry associated with the HTML file |
| * @param descriptor the descriptor representing the data to be returned |
| * @return a cache entry containing the required data |
| * @throws AnalysisException if data could not be returned because the source could not be |
| * resolved |
| */ |
| HtmlEntry _cacheHtmlResolutionData(Source source, HtmlEntry htmlEntry, |
| DataDescriptor descriptor) { |
| // |
| // Check to see whether we already have the information being requested. |
| // |
| CacheState state = htmlEntry.getState(descriptor); |
| while (state != CacheState.ERROR && state != CacheState.VALID) { |
| // |
| // If not, compute the information. Unless the modification date of the |
| // source continues to change, this loop will eventually terminate. |
| // |
| htmlEntry = _cacheHtmlParseData(source, htmlEntry, HtmlEntry.PARSED_UNIT); |
| htmlEntry = new ResolveHtmlTask( |
| this, |
| source, |
| htmlEntry.modificationTime, |
| htmlEntry.getValue( |
| HtmlEntry.PARSED_UNIT)).perform(_resultRecorder) as HtmlEntry; |
| state = htmlEntry.getState(descriptor); |
| } |
| return htmlEntry; |
| } |
| |
| /** |
| * Remove the given [pendingFuture] from [_pendingFutureSources], since the |
| * client has indicated its computation is not needed anymore. |
| */ |
| void _cancelFuture(PendingFuture pendingFuture) { |
| List<PendingFuture> pendingFutures = |
| _pendingFutureSources[pendingFuture.source]; |
| if (pendingFutures != null) { |
| pendingFutures.remove(pendingFuture); |
| if (pendingFutures.isEmpty) { |
| _pendingFutureSources.remove(pendingFuture.source); |
| } |
| } |
| } |
| |
| /** |
| * Compute the transitive closure of all libraries that depend on the given library by adding such |
| * libraries to the given collection. |
| * |
| * @param library the library on which the other libraries depend |
| * @param librariesToInvalidate the libraries that depend on the given library |
| */ |
| void _computeAllLibrariesDependingOn(Source library, |
| HashSet<Source> librariesToInvalidate) { |
| if (librariesToInvalidate.add(library)) { |
| for (Source dependentLibrary in getLibrariesDependingOn(library)) { |
| _computeAllLibrariesDependingOn( |
| dependentLibrary, |
| librariesToInvalidate); |
| } |
| } |
| } |
| |
| /** |
| * Compute the priority that should be used when the source associated with the given entry is |
| * added to the work manager. |
| * |
| * @param dartEntry the entry associated with the source |
| * @return the priority that was computed |
| */ |
| SourcePriority _computePriority(DartEntry dartEntry) { |
| SourceKind kind = dartEntry.kind; |
| if (kind == SourceKind.LIBRARY) { |
| return SourcePriority.LIBRARY; |
| } else if (kind == SourceKind.PART) { |
| return SourcePriority.NORMAL_PART; |
| } |
| return SourcePriority.UNKNOWN; |
| } |
| |
| /** |
| * Given the encoded form of a source, use the source factory to reconstitute the original source. |
| * |
| * @param encoding the encoded form of a source |
| * @return the source represented by the encoding |
| */ |
| Source _computeSourceFromEncoding(String encoding) => |
| _sourceFactory.fromEncoding(encoding); |
| |
| /** |
| * Return `true` if the given array of sources contains the given source. |
| * |
| * @param sources the sources being searched |
| * @param targetSource the source being searched for |
| * @return `true` if the given source is in the array |
| */ |
| bool _contains(List<Source> sources, Source targetSource) { |
| for (Source source in sources) { |
| if (source == targetSource) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Return `true` if the given array of sources contains any of the given target sources. |
| * |
| * @param sources the sources being searched |
| * @param targetSources the sources being searched for |
| * @return `true` if any of the given target sources are in the array |
| */ |
| bool _containsAny(List<Source> sources, List<Source> targetSources) { |
| for (Source targetSource in targetSources) { |
| if (_contains(sources, targetSource)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Set the contents of the given source to the given contents and mark the source as having |
| * changed. The additional offset and length information is used by the context to determine what |
| * reanalysis is necessary. [setChangedContents] triggers a source changed event |
| * where as this method does not. |
| * |
| * @param source the source whose contents are being overridden |
| * @param contents the text to replace the range in the current contents |
| * @param offset the offset into the current contents |
| * @param oldLength the number of characters in the original contents that were replaced |
| * @param newLength the number of characters in the replacement text |
| */ |
| bool _contentRangeChanged(Source source, String contents, int offset, |
| int oldLength, int newLength) { |
| bool changed = false; |
| String originalContents = _contentCache.setContents(source, contents); |
| if (contents != null) { |
| if (contents != originalContents) { |
| if (_options.incremental) { |
| _incrementalAnalysisCache = IncrementalAnalysisCache.update( |
| _incrementalAnalysisCache, |
| source, |
| originalContents, |
| contents, |
| offset, |
| oldLength, |
| newLength, |
| _getReadableSourceEntry(source)); |
| } |
| _sourceChanged(source); |
| changed = true; |
| SourceEntry sourceEntry = _cache.get(source); |
| if (sourceEntry != null) { |
| sourceEntry.modificationTime = |
| _contentCache.getModificationStamp(source); |
| sourceEntry.setValue(SourceEntry.CONTENT, contents); |
| } |
| } |
| } else if (originalContents != null) { |
| _incrementalAnalysisCache = |
| IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source); |
| _sourceChanged(source); |
| changed = true; |
| } |
| return changed; |
| } |
| |
| /** |
| * Set the contents of the given source to the given contents and mark the source as having |
| * changed. This has the effect of overriding the default contents of the source. If the contents |
| * are `null` the override is removed so that the default contents will be returned. |
| * |
| * If [notify] is true, a source changed event is triggered. |
| * |
| * @param source the source whose contents are being overridden |
| * @param contents the new contents of the source |
| */ |
| void _contentsChanged(Source source, String contents, bool notify) { |
| String originalContents = _contentCache.setContents(source, contents); |
| handleContentsChanged(source, originalContents, contents, notify); |
| } |
| |
| // /** |
| // * Create a [BuildUnitElementTask] for the given [source]. |
| // */ |
| // AnalysisContextImpl_TaskData _createBuildUnitElementTask(Source source, |
| // DartEntry dartEntry, Source librarySource) { |
| // CompilationUnit unit = dartEntry.resolvableCompilationUnit; |
| // if (unit == null) { |
| // return _createParseDartTask(source, dartEntry); |
| // } |
| // return new AnalysisContextImpl_TaskData( |
| // new BuildUnitElementTask(this, source, librarySource, unit), |
| // false); |
| // } |
| |
| /** |
| * Create a [GenerateDartErrorsTask] for the given source, marking the verification errors |
| * as being in-process. The compilation unit and the library can be the same if the compilation |
| * unit is the defining compilation unit of the library. |
| * |
| * @param unitSource the source for the compilation unit to be verified |
| * @param unitEntry the entry for the compilation unit |
| * @param librarySource the source for the library containing the compilation unit |
| * @param libraryEntry the entry for the library |
| * @return task data representing the created task |
| */ |
| AnalysisContextImpl_TaskData _createGenerateDartErrorsTask(Source unitSource, |
| DartEntry unitEntry, Source librarySource, DartEntry libraryEntry) { |
| if (unitEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource) != |
| CacheState.VALID || |
| libraryEntry.getState(DartEntry.ELEMENT) != CacheState.VALID) { |
| return _createResolveDartLibraryTask(librarySource, libraryEntry); |
| } |
| CompilationUnit unit = |
| unitEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource); |
| if (unit == null) { |
| CaughtException exception = new CaughtException( |
| new AnalysisException( |
| "Entry has VALID state for RESOLVED_UNIT but null value for ${unitSource.fullName} in ${librarySource.fullName}"), |
| null); |
| AnalysisEngine.instance.logger.logInformation( |
| exception.toString(), |
| exception); |
| unitEntry.recordResolutionError(exception); |
| return new AnalysisContextImpl_TaskData(null, false); |
| } |
| LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT); |
| unitEntry.setStateInLibrary( |
| DartEntry.VERIFICATION_ERRORS, |
| librarySource, |
| CacheState.IN_PROCESS); |
| return new AnalysisContextImpl_TaskData( |
| new GenerateDartErrorsTask(this, unitSource, unit, libraryElement), |
| false); |
| } |
| |
| /** |
| * Create a [GenerateDartHintsTask] for the given source, marking the hints as being |
| * in-process. |
| * |
| * @param source the source whose content is to be verified |
| * @param dartEntry the entry for the source |
| * @param librarySource the source for the library containing the source |
| * @param libraryEntry the entry for the library |
| * @return task data representing the created task |
| */ |
| AnalysisContextImpl_TaskData _createGenerateDartHintsTask(Source source, |
| DartEntry dartEntry, Source librarySource, DartEntry libraryEntry) { |
| if (libraryEntry.getState(DartEntry.ELEMENT) != CacheState.VALID) { |
| return _createResolveDartLibraryTask(librarySource, libraryEntry); |
| } |
| LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT); |
| CompilationUnitElement definingUnit = |
| libraryElement.definingCompilationUnit; |
| List<CompilationUnitElement> parts = libraryElement.parts; |
| List<TimestampedData<CompilationUnit>> units = |
| new List<TimestampedData>(parts.length + 1); |
| units[0] = _getResolvedUnit(definingUnit, librarySource); |
| if (units[0] == null) { |
| // TODO(brianwilkerson) We should return a ResolveDartUnitTask |
| // (unless there are multiple ASTs that need to be resolved). |
| return _createResolveDartLibraryTask(librarySource, libraryEntry); |
| } |
| for (int i = 0; i < parts.length; i++) { |
| units[i + 1] = _getResolvedUnit(parts[i], librarySource); |
| if (units[i + 1] == null) { |
| // TODO(brianwilkerson) We should return a ResolveDartUnitTask |
| // (unless there are multiple ASTs that need to be resolved). |
| return _createResolveDartLibraryTask(librarySource, libraryEntry); |
| } |
| } |
| dartEntry.setStateInLibrary( |
| DartEntry.HINTS, |
| librarySource, |
| CacheState.IN_PROCESS); |
| return new AnalysisContextImpl_TaskData( |
| new GenerateDartHintsTask(this, units, libraryElement), |
| false); |
| } |
| |
| /** |
| * Create a [GenerateDartLintsTask] for the given source, marking the lints as |
| * being in-process. |
| * |
| * @param source the source whose content is to be verified |
| * @param dartEntry the entry for the source |
| * @param librarySource the source for the library containing the source |
| * @param libraryEntry the entry for the library |
| * @return task data representing the created task |
| */ |
| AnalysisContextImpl_TaskData _createGenerateDartLintsTask(Source source, |
| DartEntry dartEntry, Source librarySource, DartEntry libraryEntry) { |
| if (libraryEntry.getState(DartEntry.ELEMENT) != CacheState.VALID) { |
| return _createResolveDartLibraryTask(librarySource, libraryEntry); |
| } |
| LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT); |
| CompilationUnitElement definingUnit = |
| libraryElement.definingCompilationUnit; |
| List<CompilationUnitElement> parts = libraryElement.parts; |
| List<TimestampedData<CompilationUnit>> units = |
| new List<TimestampedData>(parts.length + 1); |
| units[0] = _getResolvedUnit(definingUnit, librarySource); |
| if (units[0] == null) { |
| // TODO(brianwilkerson) We should return a ResolveDartUnitTask |
| // (unless there are multiple ASTs that need to be resolved). |
| return _createResolveDartLibraryTask(librarySource, libraryEntry); |
| } |
| for (int i = 0; i < parts.length; i++) { |
| units[i + 1] = _getResolvedUnit(parts[i], librarySource); |
| if (units[i + 1] == null) { |
| // TODO(brianwilkerson) We should return a ResolveDartUnitTask |
| // (unless there are multiple ASTs that need to be resolved). |
| return _createResolveDartLibraryTask(librarySource, libraryEntry); |
| } |
| } |
| dartEntry.setStateInLibrary( |
| DartEntry.LINTS, |
| librarySource, |
| CacheState.IN_PROCESS); |
| //TODO(pquitslund): revisit if we need all units or whether one will do |
| return new AnalysisContextImpl_TaskData( |
| new GenerateDartLintsTask(this, units, libraryElement), |
| false); |
| } |
| |
| /** |
| * Create a [GetContentTask] for the given source, marking the content as being in-process. |
| * |
| * @param source the source whose content is to be accessed |
| * @param sourceEntry the entry for the source |
| * @return task data representing the created task |
| */ |
| AnalysisContextImpl_TaskData _createGetContentTask(Source source, |
| SourceEntry sourceEntry) { |
| sourceEntry.setState(SourceEntry.CONTENT, CacheState.IN_PROCESS); |
| return new AnalysisContextImpl_TaskData( |
| new GetContentTask(this, source), |
| false); |
| } |
| |
| /** |
| * Create a [ParseDartTask] for the given [source]. |
| */ |
| AnalysisContextImpl_TaskData _createParseDartTask(Source source, |
| DartEntry dartEntry) { |
| if (dartEntry.getState(DartEntry.TOKEN_STREAM) != CacheState.VALID || |
| dartEntry.getState(SourceEntry.LINE_INFO) != CacheState.VALID) { |
| return _createScanDartTask(source, dartEntry); |
| } |
| Token tokenStream = dartEntry.getValue(DartEntry.TOKEN_STREAM); |
| dartEntry.setState(DartEntry.TOKEN_STREAM, CacheState.FLUSHED); |
| dartEntry.setState(DartEntry.PARSE_ERRORS, CacheState.IN_PROCESS); |
| return new AnalysisContextImpl_TaskData( |
| new ParseDartTask( |
| this, |
| source, |
| tokenStream, |
| dartEntry.getValue(SourceEntry.LINE_INFO)), |
| false); |
| } |
| |
| /** |
| * Create a [ParseHtmlTask] for the given [source]. |
| */ |
| AnalysisContextImpl_TaskData _createParseHtmlTask(Source source, |
| HtmlEntry htmlEntry) { |
| if (htmlEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) { |
| return _createGetContentTask(source, htmlEntry); |
| } |
| String content = htmlEntry.getValue(SourceEntry.CONTENT); |
| htmlEntry.setState(SourceEntry.CONTENT, CacheState.FLUSHED); |
| htmlEntry.setState(HtmlEntry.PARSE_ERRORS, CacheState.IN_PROCESS); |
| return new AnalysisContextImpl_TaskData( |
| new ParseHtmlTask(this, source, content), |
| false); |
| } |
| |
| /** |
| * Create a [ResolveDartLibraryTask] for the given source, marking ? as being in-process. |
| * |
| * @param source the source whose content is to be resolved |
| * @param dartEntry the entry for the source |
| * @return task data representing the created task |
| */ |
| AnalysisContextImpl_TaskData _createResolveDartLibraryTask(Source source, |
| DartEntry dartEntry) { |
| try { |
| AnalysisContextImpl_CycleBuilder builder = |
| new AnalysisContextImpl_CycleBuilder(this); |
| builder.computeCycleContaining(source); |
| AnalysisContextImpl_TaskData taskData = builder.taskData; |
| if (taskData != null) { |
| return taskData; |
| } |
| return new AnalysisContextImpl_TaskData( |
| new ResolveDartLibraryCycleTask(this, source, source, builder.librariesInCycle), |
| false); |
| } on AnalysisException catch (exception, stackTrace) { |
| dartEntry.recordResolutionError( |
| new CaughtException(exception, stackTrace)); |
| AnalysisEngine.instance.logger.logError( |
| "Internal error trying to create a ResolveDartLibraryTask", |
| new CaughtException(exception, stackTrace)); |
| } |
| return new AnalysisContextImpl_TaskData(null, false); |
| } |
| |
| /** |
| * Create a [ResolveHtmlTask] for the given source, marking the resolved unit as being |
| * in-process. |
| * |
| * @param source the source whose content is to be resolved |
| * @param htmlEntry the entry for the source |
| * @return task data representing the created task |
| */ |
| AnalysisContextImpl_TaskData _createResolveHtmlTask(Source source, |
| HtmlEntry htmlEntry) { |
| if (htmlEntry.getState(HtmlEntry.PARSED_UNIT) != CacheState.VALID) { |
| return _createParseHtmlTask(source, htmlEntry); |
| } |
| htmlEntry.setState(HtmlEntry.RESOLVED_UNIT, CacheState.IN_PROCESS); |
| return new AnalysisContextImpl_TaskData( |
| new ResolveHtmlTask( |
| this, |
| source, |
| htmlEntry.modificationTime, |
| htmlEntry.getValue(HtmlEntry.PARSED_UNIT)), |
| false); |
| } |
| |
| /** |
| * Create a [ScanDartTask] for the given source, marking the scan errors as being |
| * in-process. |
| * |
| * @param source the source whose content is to be scanned |
| * @param dartEntry the entry for the source |
| * @return task data representing the created task |
| */ |
| AnalysisContextImpl_TaskData _createScanDartTask(Source source, |
| DartEntry dartEntry) { |
| if (dartEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) { |
| return _createGetContentTask(source, dartEntry); |
| } |
| String content = dartEntry.getValue(SourceEntry.CONTENT); |
| dartEntry.setState(SourceEntry.CONTENT, CacheState.FLUSHED); |
| dartEntry.setState(DartEntry.SCAN_ERRORS, CacheState.IN_PROCESS); |
| return new AnalysisContextImpl_TaskData( |
| new ScanDartTask(this, source, content), |
| false); |
| } |
| |
| /** |
| * Create a source information object suitable for the given source. Return the source information |
| * object that was created, or `null` if the source should not be tracked by this context. |
| * |
| * @param source the source for which an information object is being created |
| * @param explicitlyAdded `true` if the source was explicitly added to the context |
| * @return the source information object that was created |
| */ |
| SourceEntry _createSourceEntry(Source source, bool explicitlyAdded) { |
| String name = source.shortName; |
| if (AnalysisEngine.isHtmlFileName(name)) { |
| HtmlEntry htmlEntry = new HtmlEntry(); |
| htmlEntry.modificationTime = getModificationStamp(source); |
| htmlEntry.explicitlyAdded = explicitlyAdded; |
| _cache.put(source, htmlEntry); |
| return htmlEntry; |
| } else { |
| DartEntry dartEntry = new DartEntry(); |
| dartEntry.modificationTime = getModificationStamp(source); |
| dartEntry.explicitlyAdded = explicitlyAdded; |
| _cache.put(source, dartEntry); |
| return dartEntry; |
| } |
| } |
| |
| /** |
| * Return an array containing all of the change notices that are waiting to be returned. If there |
| * are no notices, then return either `null` or an empty array, depending on the value of |
| * the argument. |
| * |
| * @param nullIfEmpty `true` if `null` should be returned when there are no notices |
| * @return the change notices that are waiting to be returned |
| */ |
| List<ChangeNotice> _getChangeNotices(bool nullIfEmpty) { |
| if (_pendingNotices.isEmpty) { |
| if (nullIfEmpty) { |
| return null; |
| } |
| return ChangeNoticeImpl.EMPTY_ARRAY; |
| } |
| List<ChangeNotice> notices = new List.from(_pendingNotices.values); |
| _pendingNotices.clear(); |
| return notices; |
| } |
| |
| /** |
| * Given a source for a Dart file and the library that contains it, return the data represented by |
| * the given descriptor that is associated with that source. This method assumes that the data can |
| * be produced by generating hints for the library if it is not already cached. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param unitSource the source representing the Dart file |
| * @param librarySource the source representing the library containing the Dart file |
| * @param dartEntry the entry representing the Dart file |
| * @param descriptor the descriptor representing the data to be returned |
| * @return the requested data about the given source |
| * @throws AnalysisException if data could not be returned because the source could not be |
| * resolved |
| */ |
| Object _getDartHintData(Source unitSource, Source librarySource, |
| DartEntry dartEntry, DataDescriptor descriptor) { |
| dartEntry = |
| _cacheDartHintData(unitSource, librarySource, dartEntry, descriptor); |
| if (identical(descriptor, DartEntry.ELEMENT)) { |
| return dartEntry.getValue(descriptor); |
| } |
| return dartEntry.getValueInLibrary(descriptor, librarySource); |
| } |
| |
| /** |
| * Given a source for a Dart file and the library that contains it, return the data represented by |
| * the given descriptor that is associated with that source. This method assumes that the data can |
| * be produced by generating lints for the library if it is not already cached. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param unitSource the source representing the Dart file |
| * @param librarySource the source representing the library containing the Dart file |
| * @param dartEntry the entry representing the Dart file |
| * @param descriptor the descriptor representing the data to be returned |
| * @return the requested data about the given source |
| * @throws AnalysisException if data could not be returned because the source could not be |
| * resolved |
| */ |
| Object _getDartLintData(Source unitSource, Source librarySource, |
| DartEntry dartEntry, DataDescriptor descriptor) { |
| dartEntry = |
| _cacheDartLintData(unitSource, librarySource, dartEntry, descriptor); |
| if (identical(descriptor, DartEntry.ELEMENT)) { |
| return dartEntry.getValue(descriptor); |
| } |
| return dartEntry.getValueInLibrary(descriptor, librarySource); |
| } |
| |
| /** |
| * Given a source for a Dart file, return the data represented by the given descriptor that is |
| * associated with that source. This method assumes that the data can be produced by parsing the |
| * source if it is not already cached. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param source the source representing the Dart file |
| * @param dartEntry the cache entry associated with the Dart file |
| * @param descriptor the descriptor representing the data to be returned |
| * @return the requested data about the given source |
| * @throws AnalysisException if data could not be returned because the source could not be parsed |
| */ |
| Object _getDartParseData(Source source, DartEntry dartEntry, |
| DataDescriptor descriptor) { |
| dartEntry = _cacheDartParseData(source, dartEntry, descriptor); |
| if (identical(descriptor, DartEntry.PARSED_UNIT)) { |
| _accessedAst(source); |
| return dartEntry.anyParsedCompilationUnit; |
| } |
| return dartEntry.getValue(descriptor); |
| } |
| |
| /** |
| * Given a source for a Dart file, return the data represented by the given descriptor that is |
| * associated with that source, or the given default value if the source is not a Dart file. This |
| * method assumes that the data can be produced by parsing the source if it is not already cached. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param source the source representing the Dart file |
| * @param descriptor the descriptor representing the data to be returned |
| * @param defaultValue the value to be returned if the source is not a Dart file |
| * @return the requested data about the given source |
| * @throws AnalysisException if data could not be returned because the source could not be parsed |
| */ |
| Object _getDartParseData2(Source source, DataDescriptor descriptor, |
| Object defaultValue) { |
| DartEntry dartEntry = _getReadableDartEntry(source); |
| if (dartEntry == null) { |
| return defaultValue; |
| } |
| try { |
| return _getDartParseData(source, dartEntry, descriptor); |
| } on ObsoleteSourceAnalysisException catch (exception, stackTrace) { |
| AnalysisEngine.instance.logger.logInformation( |
| "Could not compute $descriptor", |
| new CaughtException(exception, stackTrace)); |
| return defaultValue; |
| } |
| } |
| |
| /** |
| * Given a source for a Dart file and the library that contains it, return the data represented by |
| * the given descriptor that is associated with that source. This method assumes that the data can |
| * be produced by resolving the source in the context of the library if it is not already cached. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param unitSource the source representing the Dart file |
| * @param librarySource the source representing the library containing the Dart file |
| * @param dartEntry the entry representing the Dart file |
| * @param descriptor the descriptor representing the data to be returned |
| * @return the requested data about the given source |
| * @throws AnalysisException if data could not be returned because the source could not be |
| * resolved |
| */ |
| Object _getDartResolutionData(Source unitSource, Source librarySource, |
| DartEntry dartEntry, DataDescriptor descriptor) { |
| dartEntry = |
| _cacheDartResolutionData(unitSource, librarySource, dartEntry, descriptor); |
| if (identical(descriptor, DartEntry.ELEMENT)) { |
| return dartEntry.getValue(descriptor); |
| } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) { |
| _accessedAst(unitSource); |
| } |
| return dartEntry.getValueInLibrary(descriptor, librarySource); |
| } |
| |
| /** |
| * Given a source for a Dart file and the library that contains it, return the data represented by |
| * the given descriptor that is associated with that source, or the given default value if the |
| * source is not a Dart file. This method assumes that the data can be produced by resolving the |
| * source in the context of the library if it is not already cached. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param unitSource the source representing the Dart file |
| * @param librarySource the source representing the library containing the Dart file |
| * @param descriptor the descriptor representing the data to be returned |
| * @param defaultValue the value to be returned if the source is not a Dart file |
| * @return the requested data about the given source |
| * @throws AnalysisException if data could not be returned because the source could not be |
| * resolved |
| */ |
| Object _getDartResolutionData2(Source unitSource, Source librarySource, |
| DataDescriptor descriptor, Object defaultValue) { |
| DartEntry dartEntry = _getReadableDartEntry(unitSource); |
| if (dartEntry == null) { |
| return defaultValue; |
| } |
| try { |
| return _getDartResolutionData( |
| unitSource, |
| librarySource, |
| dartEntry, |
| descriptor); |
| } on ObsoleteSourceAnalysisException catch (exception, stackTrace) { |
| AnalysisEngine.instance.logger.logInformation( |
| "Could not compute $descriptor", |
| new CaughtException(exception, stackTrace)); |
| return defaultValue; |
| } |
| } |
| |
| /** |
| * Given a source for a Dart file, return the data represented by the given descriptor that is |
| * associated with that source. This method assumes that the data can be produced by scanning the |
| * source if it is not already cached. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param source the source representing the Dart file |
| * @param dartEntry the cache entry associated with the Dart file |
| * @param descriptor the descriptor representing the data to be returned |
| * @return the requested data about the given source |
| * @throws AnalysisException if data could not be returned because the source could not be scanned |
| */ |
| Object _getDartScanData(Source source, DartEntry dartEntry, |
| DataDescriptor descriptor) { |
| dartEntry = _cacheDartScanData(source, dartEntry, descriptor); |
| return dartEntry.getValue(descriptor); |
| } |
| |
| /** |
| * Given a source for a Dart file, return the data represented by the given descriptor that is |
| * associated with that source, or the given default value if the source is not a Dart file. This |
| * method assumes that the data can be produced by scanning the source if it is not already |
| * cached. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param source the source representing the Dart file |
| * @param descriptor the descriptor representing the data to be returned |
| * @param defaultValue the value to be returned if the source is not a Dart file |
| * @return the requested data about the given source |
| * @throws AnalysisException if data could not be returned because the source could not be scanned |
| */ |
| Object _getDartScanData2(Source source, DataDescriptor descriptor, |
| Object defaultValue) { |
| DartEntry dartEntry = _getReadableDartEntry(source); |
| if (dartEntry == null) { |
| return defaultValue; |
| } |
| try { |
| return _getDartScanData(source, dartEntry, descriptor); |
| } on ObsoleteSourceAnalysisException catch (exception, stackTrace) { |
| AnalysisEngine.instance.logger.logInformation( |
| "Could not compute $descriptor", |
| new CaughtException(exception, stackTrace)); |
| return defaultValue; |
| } |
| } |
| |
| /** |
| * Given a source for a Dart file and the library that contains it, return the data represented by |
| * the given descriptor that is associated with that source. This method assumes that the data can |
| * be produced by verifying the source within the given library if it is not already cached. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param unitSource the source representing the Dart file |
| * @param librarySource the source representing the library containing the Dart file |
| * @param dartEntry the entry representing the Dart file |
| * @param descriptor the descriptor representing the data to be returned |
| * @return the requested data about the given source |
| * @throws AnalysisException if data could not be returned because the source could not be |
| * resolved |
| */ |
| Object _getDartVerificationData(Source unitSource, Source librarySource, |
| DartEntry dartEntry, DataDescriptor descriptor) { |
| dartEntry = |
| _cacheDartVerificationData(unitSource, librarySource, dartEntry, descriptor); |
| return dartEntry.getValueInLibrary(descriptor, librarySource); |
| } |
| |
| /** |
| * Given a source for an HTML file, return the data represented by the given descriptor that is |
| * associated with that source, or the given default value if the source is not an HTML file. This |
| * method assumes that the data can be produced by parsing the source if it is not already cached. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param source the source representing the Dart file |
| * @param descriptor the descriptor representing the data to be returned |
| * @param defaultValue the value to be returned if the source is not an HTML file |
| * @return the requested data about the given source |
| * @throws AnalysisException if data could not be returned because the source could not be parsed |
| */ |
| Object _getHtmlParseData(Source source, DataDescriptor descriptor, |
| Object defaultValue) { |
| HtmlEntry htmlEntry = _getReadableHtmlEntry(source); |
| if (htmlEntry == null) { |
| return defaultValue; |
| } |
| htmlEntry = _cacheHtmlParseData(source, htmlEntry, descriptor); |
| if (identical(descriptor, HtmlEntry.PARSED_UNIT)) { |
| _accessedAst(source); |
| return htmlEntry.anyParsedUnit; |
| } |
| return htmlEntry.getValue(descriptor); |
| } |
| |
| /** |
| * Given a source for an HTML file, return the data represented by the given descriptor that is |
| * associated with that source, or the given default value if the source is not an HTML file. This |
| * method assumes that the data can be produced by resolving the source if it is not already |
| * cached. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param source the source representing the HTML file |
| * @param descriptor the descriptor representing the data to be returned |
| * @param defaultValue the value to be returned if the source is not an HTML file |
| * @return the requested data about the given source |
| * @throws AnalysisException if data could not be returned because the source could not be |
| * resolved |
| */ |
| Object _getHtmlResolutionData(Source source, DataDescriptor descriptor, |
| Object defaultValue) { |
| HtmlEntry htmlEntry = _getReadableHtmlEntry(source); |
| if (htmlEntry == null) { |
| return defaultValue; |
| } |
| try { |
| return _getHtmlResolutionData2(source, htmlEntry, descriptor); |
| } on ObsoleteSourceAnalysisException catch (exception, stackTrace) { |
| AnalysisEngine.instance.logger.logInformation( |
| "Could not compute $descriptor", |
| new CaughtException(exception, stackTrace)); |
| return defaultValue; |
| } |
| } |
| |
| /** |
| * Given a source for an HTML file, return the data represented by the given descriptor that is |
| * associated with that source. This method assumes that the data can be produced by resolving the |
| * source if it is not already cached. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment. |
| * |
| * @param source the source representing the HTML file |
| * @param htmlEntry the entry representing the HTML file |
| * @param descriptor the descriptor representing the data to be returned |
| * @return the requested data about the given source |
| * @throws AnalysisException if data could not be returned because the source could not be |
| * resolved |
| */ |
| Object _getHtmlResolutionData2(Source source, HtmlEntry htmlEntry, |
| DataDescriptor descriptor) { |
| htmlEntry = _cacheHtmlResolutionData(source, htmlEntry, descriptor); |
| if (identical(descriptor, HtmlEntry.RESOLVED_UNIT)) { |
| _accessedAst(source); |
| } |
| return htmlEntry.getValue(descriptor); |
| } |
| |
| /** |
| * Look at the given source to see whether a task needs to be performed related to it. Return the |
| * task that should be performed, or `null` if there is no more work to be done for the |
| * source. |
| * |
| * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock]. |
| * |
| * @param source the source to be checked |
| * @param sourceEntry the cache entry associated with the source |
| * @param isPriority `true` if the source is a priority source |
| * @param hintsEnabled `true` if hints are currently enabled |
| * @param lintsEnabled `true` if lints are currently enabled |
| * @return the next task that needs to be performed for the given source |
| */ |
| AnalysisContextImpl_TaskData _getNextAnalysisTaskForSource(Source source, |
| SourceEntry sourceEntry, bool isPriority, bool hintsEnabled, |
| bool lintsEnabled) { |
| // Refuse to generate tasks for html based files that are above 1500 KB |
| if (_isTooBigHtmlSourceEntry(source, sourceEntry)) { |
| // TODO (jwren) we still need to report an error of some kind back to the |
| // client. |
| return new AnalysisContextImpl_TaskData(null, false); |
| } |
| if (sourceEntry == null) { |
| return new AnalysisContextImpl_TaskData(null, false); |
| } |
| CacheState contentState = sourceEntry.getState(SourceEntry.CONTENT); |
| if (contentState == CacheState.INVALID) { |
| return _createGetContentTask(source, sourceEntry); |
| } else if (contentState == CacheState.IN_PROCESS) { |
| // We are already in the process of getting the content. |
| // There's nothing else we can do with this source until that's complete. |
| return new AnalysisContextImpl_TaskData(null, true); |
| } else if (contentState == CacheState.ERROR) { |
| // We have done all of the analysis we can for this source because we |
| // cannot get its content. |
| return new AnalysisContextImpl_TaskData(null, false); |
| } |
| if (sourceEntry is DartEntry) { |
| DartEntry dartEntry = sourceEntry; |
| CacheState scanErrorsState = dartEntry.getState(DartEntry.SCAN_ERRORS); |
| if (scanErrorsState == CacheState.INVALID || |
| (isPriority && scanErrorsState == CacheState.FLUSHED)) { |
| return _createScanDartTask(source, dartEntry); |
| } |
| CacheState parseErrorsState = dartEntry.getState(DartEntry.PARSE_ERRORS); |
| if (parseErrorsState == CacheState.INVALID || |
| (isPriority && parseErrorsState == CacheState.FLUSHED)) { |
| return _createParseDartTask(source, dartEntry); |
| } |
| if (isPriority && parseErrorsState != CacheState.ERROR) { |
| if (!dartEntry.hasResolvableCompilationUnit) { |
| return _createParseDartTask(source, dartEntry); |
| } |
| } |
| SourceKind kind = dartEntry.getValue(DartEntry.SOURCE_KIND); |
| if (kind == SourceKind.UNKNOWN) { |
| return _createParseDartTask(source, dartEntry); |
| } else if (kind == SourceKind.LIBRARY) { |
| CacheState elementState = dartEntry.getState(DartEntry.ELEMENT); |
| if (elementState == CacheState.INVALID) { |
| return _createResolveDartLibraryTask(source, dartEntry); |
| } |
| } |
| List<Source> librariesContaining = dartEntry.containingLibraries; |
| for (Source librarySource in librariesContaining) { |
| SourceEntry librarySourceEntry = _cache.get(librarySource); |
| if (librarySourceEntry is DartEntry) { |
| DartEntry libraryEntry = librarySourceEntry; |
| CacheState elementState = libraryEntry.getState(DartEntry.ELEMENT); |
| if (elementState == CacheState.INVALID || |
| (isPriority && elementState == CacheState.FLUSHED)) { |
| // return createResolveDartLibraryTask(librarySource, (DartEntry) libraryEntry); |
| libraryEntry.setState(DartEntry.ELEMENT, CacheState.IN_PROCESS); |
| return new AnalysisContextImpl_TaskData( |
| new ResolveDartLibraryTask(this, source, librarySource), |
| false); |
| } |
| CacheState resolvedUnitState = |
| dartEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource); |
| if (resolvedUnitState == CacheState.INVALID || |
| (isPriority && resolvedUnitState == CacheState.FLUSHED)) { |
| // |
| // The commented out lines below are an optimization that doesn't |
| // quite work yet. The problem is that if the source was not |
| // resolved because it wasn't part of any library, then there won't |
| // be any elements in the element model that we can use to resolve |
| // it. |
| // |
| // LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT); |
| // if (libraryElement != null) { |
| // return new ResolveDartUnitTask(this, source, libraryElement); |
| // } |
| // Possibly replace with: |
| // return createResolveDartLibraryTask(librarySource, (DartEntry) libraryEntry); |
| dartEntry.setStateInLibrary( |
| DartEntry.RESOLVED_UNIT, |
| librarySource, |
| CacheState.IN_PROCESS); |
| return new AnalysisContextImpl_TaskData( |
| new ResolveDartLibraryTask(this, source, librarySource), |
| false); |
| } |
| if (_generateSdkErrors || !source.isInSystemLibrary) { |
| CacheState verificationErrorsState = |
| dartEntry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource); |
| if (verificationErrorsState == CacheState.INVALID || |
| (isPriority && verificationErrorsState == CacheState.FLUSHED)) { |
| return _createGenerateDartErrorsTask( |
| source, |
| dartEntry, |
| librarySource, |
| libraryEntry); |
| } |
| if (hintsEnabled) { |
| CacheState hintsState = |
| dartEntry.getStateInLibrary(DartEntry.HINTS, librarySource); |
| if (hintsState == CacheState.INVALID || |
| (isPriority && hintsState == CacheState.FLUSHED)) { |
| return _createGenerateDartHintsTask( |
| source, |
| dartEntry, |
| librarySource, |
| libraryEntry); |
| } |
| } |
| if (lintsEnabled) { |
| CacheState lintsState = |
| dartEntry.getStateInLibrary(DartEntry.LINTS, librarySource); |
| if (lintsState == CacheState.INVALID || |
| (isPriority && lintsState == CacheState.FLUSHED)) { |
| return _createGenerateDartLintsTask( |
| source, |
| dartEntry, |
| librarySource, |
| libraryEntry); |
| } |
| } |
| } |
| } |
| } |
| } else if (sourceEntry is HtmlEntry) { |
| HtmlEntry htmlEntry = sourceEntry; |
| CacheState parseErrorsState = htmlEntry.getState(HtmlEntry.PARSE_ERRORS); |
| if (parseErrorsState == CacheState.INVALID || |
| (isPriority && parseErrorsState == CacheState.FLUSHED)) { |
| return _createParseHtmlTask(source, htmlEntry); |
| } |
| if (isPriority && parseErrorsState != CacheState.ERROR) { |
| ht.HtmlUnit parsedUnit = htmlEntry.anyParsedUnit; |
| if (parsedUnit == null) { |
| return _createParseHtmlTask(source, htmlEntry); |
| } |
| } |
| CacheState resolvedUnitState = |
| htmlEntry.getState(HtmlEntry.RESOLVED_UNIT); |
| if (resolvedUnitState == CacheState.INVALID || |
| (isPriority && resolvedUnitState == CacheState.FLUSHED)) { |
| return _createResolveHtmlTask(source, htmlEntry); |
| } |
| } |
| return new AnalysisContextImpl_TaskData(null, false); |
| } |
| |
| /** |
| * Return a change notice for the given source, creating one if one does not already exist. |
| * |
| * @param source the source for which changes are being reported |
| * @return a change notice for the given source |
| */ |
| ChangeNoticeImpl _getNotice(Source source) { |
| ChangeNoticeImpl notice = _pendingNotices[source]; |
| if (notice == null) { |
| notice = new ChangeNoticeImpl(source); |
| _pendingNotices[source] = notice; |
| } |
| return notice; |
| } |
| |
| /** |
| * Return the cache entry associated with the given source, or `null` if the source is not a |
| * Dart file. |
| * |
| * @param source the source for which a cache entry is being sought |
| * @return the source cache entry associated with the given source |
| */ |
| DartEntry _getReadableDartEntry(Source source) { |
| SourceEntry sourceEntry = _cache.get(source); |
| if (sourceEntry == null) { |
| sourceEntry = _createSourceEntry(source, false); |
| } |
| if (sourceEntry is DartEntry) { |
| return sourceEntry as DartEntry; |
| } |
| return null; |
| } |
| |
| /** |
| * Return the cache entry associated with the given source, or `null` if the source is not |
| * an HTML file. |
| * |
| * @param source the source for which a cache entry is being sought |
| * @return the source cache entry associated with the given source |
| */ |
| HtmlEntry _getReadableHtmlEntry(Source source) { |
| SourceEntry sourceEntry = _cache.get(source); |
| if (sourceEntry == null) { |
| sourceEntry = _createSourceEntry(source, false); |
| } |
| if (sourceEntry is HtmlEntry) { |
| return sourceEntry as HtmlEntry; |
| } |
| return null; |
| } |
| |
| /** |
| * 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, false); |
| } |
| return sourceEntry; |
| } |
| |
| /** |
| * Return a resolved compilation unit corresponding to the given element in the given library, or |
| * `null` if the information is not cached. |
| * |
| * @param element the element representing the compilation unit |
| * @param librarySource the source representing the library containing the unit |
| * @return the specified resolved compilation unit |
| */ |
| TimestampedData<CompilationUnit> |
| _getResolvedUnit(CompilationUnitElement element, Source librarySource) { |
| SourceEntry sourceEntry = _cache.get(element.source); |
| if (sourceEntry is DartEntry) { |
| DartEntry dartEntry = sourceEntry; |
| if (dartEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource) == |
| CacheState.VALID) { |
| return new TimestampedData<CompilationUnit>( |
| dartEntry.modificationTime, |
| dartEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource)); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * 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>(); |
| MapIterator<Source, SourceEntry> iterator = _cache.iterator(); |
| while (iterator.moveNext()) { |
| if (iterator.value.kind == kind) { |
| sources.add(iterator.key); |
| } |
| } |
| return sources; |
| } |
| |
| /** |
| * Look at the given source to see whether a task needs to be performed related to it. If so, add |
| * the source to the set of sources that need to be processed. This method duplicates, and must |
| * therefore be kept in sync with, |
| * [getNextAnalysisTask]. This method is intended to |
| * be used for testing purposes only. |
| * |
| * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock]. |
| * |
| * @param source the source to be checked |
| * @param sourceEntry the cache entry associated with the source |
| * @param isPriority `true` if the source is a priority source |
| * @param hintsEnabled `true` if hints are currently enabled |
| * @param lintsEnabled `true` if lints are currently enabled |
| * @param sources the set to which sources should be added |
| */ |
| void _getSourcesNeedingProcessing(Source source, SourceEntry sourceEntry, |
| bool isPriority, bool hintsEnabled, bool lintsEnabled, |
| HashSet<Source> sources) { |
| if (sourceEntry is DartEntry) { |
| DartEntry dartEntry = sourceEntry; |
| CacheState scanErrorsState = dartEntry.getState(DartEntry.SCAN_ERRORS); |
| if (scanErrorsState == CacheState.INVALID || |
| (isPriority && scanErrorsState == CacheState.FLUSHED)) { |
| sources.add(source); |
| return; |
| } |
| CacheState parseErrorsState = dartEntry.getState(DartEntry.PARSE_ERRORS); |
| if (parseErrorsState == CacheState.INVALID || |
| (isPriority && parseErrorsState == CacheState.FLUSHED)) { |
| sources.add(source); |
| return; |
| } |
| if (isPriority) { |
| if (!dartEntry.hasResolvableCompilationUnit) { |
| sources.add(source); |
| return; |
| } |
| } |
| for (Source librarySource in getLibrariesContaining(source)) { |
| SourceEntry libraryEntry = _cache.get(librarySource); |
| if (libraryEntry is DartEntry) { |
| CacheState elementState = libraryEntry.getState(DartEntry.ELEMENT); |
| if (elementState == CacheState.INVALID || |
| (isPriority && elementState == CacheState.FLUSHED)) { |
| sources.add(source); |
| return; |
| } |
| CacheState resolvedUnitState = |
| dartEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource); |
| if (resolvedUnitState == CacheState.INVALID || |
| (isPriority && resolvedUnitState == CacheState.FLUSHED)) { |
| LibraryElement libraryElement = |
| libraryEntry.getValue(DartEntry.ELEMENT); |
| if (libraryElement != null) { |
| sources.add(source); |
| return; |
| } |
| } |
| if (_generateSdkErrors || !source.isInSystemLibrary) { |
| CacheState verificationErrorsState = |
| dartEntry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource); |
| if (verificationErrorsState == CacheState.INVALID || |
| (isPriority && verificationErrorsState == CacheState.FLUSHED)) { |
| LibraryElement libraryElement = |
| libraryEntry.getValue(DartEntry.ELEMENT); |
| if (libraryElement != null) { |
| sources.add(source); |
| return; |
| } |
| } |
| if (hintsEnabled) { |
| CacheState hintsState = |
| dartEntry.getStateInLibrary(DartEntry.HINTS, librarySource); |
| if (hintsState == CacheState.INVALID || |
| (isPriority && hintsState == CacheState.FLUSHED)) { |
| LibraryElement libraryElement = |
| libraryEntry.getValue(DartEntry.ELEMENT); |
| if (libraryElement != null) { |
| sources.add(source); |
| return; |
| } |
| } |
| } |
| if (lintsEnabled) { |
| CacheState lintsState = |
| dartEntry.getStateInLibrary(DartEntry.LINTS, librarySource); |
| if (lintsState == CacheState.INVALID || |
| (isPriority && lintsState == CacheState.FLUSHED)) { |
| LibraryElement libraryElement = |
| libraryEntry.getValue(DartEntry.ELEMENT); |
| if (libraryElement != null) { |
| sources.add(source); |
| return; |
| } |
| } |
| } |
| } |
| } |
| } |
| } else if (sourceEntry is HtmlEntry) { |
| HtmlEntry htmlEntry = sourceEntry; |
| CacheState parsedUnitState = htmlEntry.getState(HtmlEntry.PARSED_UNIT); |
| if (parsedUnitState == CacheState.INVALID || |
| (isPriority && parsedUnitState == CacheState.FLUSHED)) { |
| sources.add(source); |
| return; |
| } |
| CacheState resolvedUnitState = |
| htmlEntry.getState(HtmlEntry.RESOLVED_UNIT); |
| if (resolvedUnitState == CacheState.INVALID || |
| (isPriority && resolvedUnitState == CacheState.FLUSHED)) { |
| sources.add(source); |
| return; |
| } |
| } |
| } |
| |
| /** |
| * Invalidate all of the resolution results computed by this context. |
| * |
| * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock]. |
| * |
| * @param invalidateUris `true` if the cached results of converting URIs to source files |
| * should also be invalidated. |
| */ |
| void _invalidateAllLocalResolutionInformation(bool invalidateUris) { |
| HashMap<Source, List<Source>> oldPartMap = |
| new HashMap<Source, List<Source>>(); |
| MapIterator<Source, SourceEntry> iterator = _privatePartition.iterator(); |
| while (iterator.moveNext()) { |
| Source source = iterator.key; |
| SourceEntry sourceEntry = iterator.value; |
| if (sourceEntry is HtmlEntry) { |
| HtmlEntry htmlEntry = sourceEntry; |
| htmlEntry.invalidateAllResolutionInformation(invalidateUris); |
| iterator.value = htmlEntry; |
| _workManager.add(source, SourcePriority.HTML); |
| } else if (sourceEntry is DartEntry) { |
| DartEntry dartEntry = sourceEntry; |
| oldPartMap[source] = dartEntry.getValue(DartEntry.INCLUDED_PARTS); |
| dartEntry.invalidateAllResolutionInformation(invalidateUris); |
| iterator.value = dartEntry; |
| _workManager.add(source, _computePriority(dartEntry)); |
| } |
| } |
| _removeFromPartsUsingMap(oldPartMap); |
| } |
| |
| /** |
| * In response to a change to at least one of the compilation units in the given library, |
| * invalidate any results that are dependent on the result of resolving that library. |
| * |
| * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock]. |
| * |
| * <b>Note:</b> Any cache entries that were accessed before this method was invoked must be |
| * re-accessed after this method returns. |
| * |
| * @param librarySource the source of the library being invalidated |
| */ |
| void _invalidateLibraryResolution(Source librarySource) { |
| // TODO(brianwilkerson) This could be optimized. There's no need to flush |
| // all of these entries if the public namespace hasn't changed, which will |
| // be a fairly common case. The question is whether we can afford the time |
| // to compute the namespace to look for differences. |
| DartEntry libraryEntry = _getReadableDartEntry(librarySource); |
| if (libraryEntry != null) { |
| List<Source> includedParts = |
| libraryEntry.getValue(DartEntry.INCLUDED_PARTS); |
| libraryEntry.invalidateAllResolutionInformation(false); |
| _workManager.add(librarySource, SourcePriority.LIBRARY); |
| for (Source partSource in includedParts) { |
| SourceEntry partEntry = _cache.get(partSource); |
| if (partEntry is DartEntry) { |
| partEntry.invalidateAllResolutionInformation(false); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Return `true` if this library is, or depends on, dart:html. |
| * |
| * @param library the library being tested |
| * @param visitedLibraries a collection of the libraries that have been visited, used to prevent |
| * infinite recursion |
| * @return `true` if this library is, or depends on, dart:html |
| */ |
| bool _isClient(LibraryElement library, Source htmlSource, |
| HashSet<LibraryElement> visitedLibraries) { |
| if (visitedLibraries.contains(library)) { |
| return false; |
| } |
| if (library.source == htmlSource) { |
| return true; |
| } |
| visitedLibraries.add(library); |
| for (LibraryElement imported in library.importedLibraries) { |
| if (_isClient(imported, htmlSource, visitedLibraries)) { |
| return true; |
| } |
| } |
| for (LibraryElement exported in library.exportedLibraries) { |
| if (_isClient(exported, htmlSource, visitedLibraries)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| bool _isTooBigHtmlSourceEntry(Source source, SourceEntry sourceEntry) => |
| false; |
| |
| /** |
| * Log the given debugging information. |
| * |
| * @param message the message to be added to the log |
| */ |
| void _logInformation(String message) { |
| AnalysisEngine.instance.logger.logInformation(message); |
| } |
| |
| /** |
| * Notify all of the analysis listeners that a task is about to be performed. |
| * |
| * @param taskDescription a human readable description of the task that is about to be performed |
| */ |
| void _notifyAboutToPerformTask(String taskDescription) { |
| int count = _listeners.length; |
| for (int i = 0; i < count; i++) { |
| _listeners[i].aboutToPerformTask(this, taskDescription); |
| } |
| } |
| |
| /** |
| * Notify all of the analysis listeners that the errors associated with the given source has been |
| * updated to the given errors. |
| * |
| * @param source the source containing the errors that were computed |
| * @param errors the errors that were computed |
| * @param lineInfo the line information associated with the source |
| */ |
| void _notifyErrors(Source source, List<AnalysisError> errors, |
| LineInfo lineInfo) { |
| int count = _listeners.length; |
| for (int i = 0; i < count; i++) { |
| _listeners[i].computedErrors(this, source, errors, lineInfo); |
| } |
| } |
| |
| /** |
| * Record the results produced by performing a [task] and return the cache |
| * entry associated with the results. |
| */ |
| DartEntry _recordBuildUnitElementTask(BuildUnitElementTask task) { |
| Source source = task.source; |
| Source library = task.library; |
| DartEntry dartEntry = _cache.get(source); |
| CaughtException thrownException = task.exception; |
| if (thrownException != null) { |
| dartEntry.recordBuildElementErrorInLibrary(library, thrownException); |
| throw new AnalysisException('<rethrow>', thrownException); |
| } |
| dartEntry.setValueInLibrary(DartEntry.BUILT_UNIT, library, task.unit); |
| dartEntry.setValueInLibrary( |
| DartEntry.BUILT_ELEMENT, |
| library, |
| task.unitElement); |
| ChangeNoticeImpl notice = _getNotice(source); |
| LineInfo lineInfo = dartEntry.getValue(SourceEntry.LINE_INFO); |
| notice.setErrors(dartEntry.allErrors, lineInfo); |
| return dartEntry; |
| } |
| |
| // /** |
| // * Notify all of the analysis listeners that the given source is no longer included in the set of |
| // * sources that are being analyzed. |
| // * |
| // * @param source the source that is no longer being analyzed |
| // */ |
| // void _notifyExcludedSource(Source source) { |
| // int count = _listeners.length; |
| // for (int i = 0; i < count; i++) { |
| // _listeners[i].excludedSource(this, source); |
| // } |
| // } |
| |
| // /** |
| // * Notify all of the analysis listeners that the given source is now included in the set of |
| // * sources that are being analyzed. |
| // * |
| // * @param source the source that is now being analyzed |
| // */ |
| // void _notifyIncludedSource(Source source) { |
| // int count = _listeners.length; |
| // for (int i = 0; i < count; i++) { |
| // _listeners[i].includedSource(this, source); |
| // } |
| // } |
| |
| // /** |
| // * Notify all of the analysis listeners that the given Dart source was parsed. |
| // * |
| // * @param source the source that was parsed |
| // * @param unit the result of parsing the source |
| // */ |
| // void _notifyParsedDart(Source source, CompilationUnit unit) { |
| // int count = _listeners.length; |
| // for (int i = 0; i < count; i++) { |
| // _listeners[i].parsedDart(this, source, unit); |
| // } |
| // } |
| |
| // /** |
| // * Notify all of the analysis listeners that the given HTML source was parsed. |
| // * |
| // * @param source the source that was parsed |
| // * @param unit the result of parsing the source |
| // */ |
| // void _notifyParsedHtml(Source source, ht.HtmlUnit unit) { |
| // int count = _listeners.length; |
| // for (int i = 0; i < count; i++) { |
| // _listeners[i].parsedHtml(this, source, unit); |
| // } |
| // } |
| |
| // /** |
| // * Notify all of the analysis listeners that the given Dart source was resolved. |
| // * |
| // * @param source the source that was resolved |
| // * @param unit the result of resolving the source |
| // */ |
| // void _notifyResolvedDart(Source source, CompilationUnit unit) { |
| // int count = _listeners.length; |
| // for (int i = 0; i < count; i++) { |
| // _listeners[i].resolvedDart(this, source, unit); |
| // } |
| // } |
| |
| // /** |
| // * Notify all of the analysis listeners that the given HTML source was resolved. |
| // * |
| // * @param source the source that was resolved |
| // * @param unit the result of resolving the source |
| // */ |
| // void _notifyResolvedHtml(Source source, ht.HtmlUnit unit) { |
| // int count = _listeners.length; |
| // for (int i = 0; i < count; i++) { |
| // _listeners[i].resolvedHtml(this, source, unit); |
| // } |
| // } |
| |
| /** |
| * Given a cache entry and a library element, record the library element and other information |
| * gleaned from the element in the cache entry. |
| * |
| * @param dartCopy the cache entry in which data is to be recorded |
| * @param library the library element used to record information |
| * @param librarySource the source for the library used to record information |
| * @param htmlSource the source for the HTML library |
| */ |
| void _recordElementData(DartEntry dartEntry, LibraryElement library, |
| Source librarySource, Source htmlSource) { |
| dartEntry.setValue(DartEntry.ELEMENT, library); |
| dartEntry.setValue(DartEntry.IS_LAUNCHABLE, library.entryPoint != null); |
| dartEntry.setValue( |
| DartEntry.IS_CLIENT, |
| _isClient(library, htmlSource, new HashSet<LibraryElement>())); |
| } |
| |
| /** |
| * Record the results produced by performing a [task] and return the cache |
| * entry associated with the results. |
| */ |
| DartEntry _recordGenerateDartErrorsTask(GenerateDartErrorsTask task) { |
| Source source = task.source; |
| DartEntry dartEntry = _cache.get(source); |
| Source librarySource = task.libraryElement.source; |
| CaughtException thrownException = task.exception; |
| if (thrownException != null) { |
| dartEntry.recordVerificationErrorInLibrary( |
| librarySource, |
| thrownException); |
| throw new AnalysisException('<rethrow>', thrownException); |
| } |
| dartEntry.setValueInLibrary( |
| DartEntry.VERIFICATION_ERRORS, |
| librarySource, |
| task.errors); |
| ChangeNoticeImpl notice = _getNotice(source); |
| LineInfo lineInfo = dartEntry.getValue(SourceEntry.LINE_INFO); |
| notice.setErrors(dartEntry.allErrors, lineInfo); |
| return dartEntry; |
| } |
| |
| /** |
| * Record the results produced by performing a [task] and return the cache |
| * entry associated with the results. |
| */ |
| DartEntry _recordGenerateDartHintsTask(GenerateDartHintsTask task) { |
| Source librarySource = task.libraryElement.source; |
| CaughtException thrownException = task.exception; |
| DartEntry libraryEntry = null; |
| HashMap<Source, List<AnalysisError>> hintMap = task.hintMap; |
| if (hintMap == null) { |
| // We don't have any information about which sources to mark as invalid |
| // other than the library source. |
| DartEntry libraryEntry = _cache.get(librarySource); |
| if (thrownException == null) { |
| String message = |
| "GenerateDartHintsTask returned a null hint map " |
| "without throwing an exception: ${librarySource.fullName}"; |
| thrownException = |
| new CaughtException(new AnalysisException(message), null); |
| } |
| libraryEntry.recordHintErrorInLibrary(librarySource, thrownException); |
| throw new AnalysisException('<rethrow>', thrownException); |
| } |
| hintMap.forEach((Source unitSource, List<AnalysisError> hints) { |
| DartEntry dartEntry = _cache.get(unitSource); |
| if (unitSource == librarySource) { |
| libraryEntry = dartEntry; |
| } |
| if (thrownException == null) { |
| dartEntry.setValueInLibrary(DartEntry.HINTS, librarySource, hints); |
| ChangeNoticeImpl notice = _getNotice(unitSource); |
| LineInfo lineInfo = dartEntry.getValue(SourceEntry.LINE_INFO); |
| notice.setErrors(dartEntry.allErrors, lineInfo); |
| } else { |
| dartEntry.recordHintErrorInLibrary(librarySource, thrownException); |
| } |
| }); |
| if (thrownException != null) { |
| throw new AnalysisException('<rethrow>', thrownException); |
| } |
| return libraryEntry; |
| } |
| |
| /** |
| * Record the results produced by performing a [task] and return the cache |
| * entry associated with the results. |
| */ |
| DartEntry _recordGenerateDartLintsTask(GenerateDartLintsTask task) { |
| Source librarySource = task.libraryElement.source; |
| CaughtException thrownException = task.exception; |
| DartEntry libraryEntry = null; |
| HashMap<Source, List<AnalysisError>> lintMap = task.lintMap; |
| if (lintMap == null) { |
| // We don't have any information about which sources to mark as invalid |
| // other than the library source. |
| DartEntry libraryEntry = _cache.get(librarySource); |
| if (thrownException == null) { |
| String message = |
| "GenerateDartLintsTask returned a null lint map " |
| "without throwing an exception: ${librarySource.fullName}"; |
| thrownException = |
| new CaughtException(new AnalysisException(message), null); |
| } |
| libraryEntry.recordLintErrorInLibrary(librarySource, thrownException); |
| throw new AnalysisException('<rethrow>', thrownException); |
| } |
| lintMap.forEach((Source unitSource, List<AnalysisError> lints) { |
| DartEntry dartEntry = _cache.get(unitSource); |
| if (unitSource == librarySource) { |
| libraryEntry = dartEntry; |
| } |
| if (thrownException == null) { |
| dartEntry.setValueInLibrary(DartEntry.LINTS, librarySource, lints); |
| ChangeNoticeImpl notice = _getNotice(unitSource); |
| LineInfo lineInfo = dartEntry.getValue(SourceEntry.LINE_INFO); |
| notice.setErrors(dartEntry.allErrors, lineInfo); |
| } else { |
| dartEntry.recordLintErrorInLibrary(librarySource, thrownException); |
| } |
| }); |
| if (thrownException != null) { |
| throw new AnalysisException('<rethrow>', thrownException); |
| } |
| return libraryEntry; |
| } |
| |
| /** |
| * Record the results produced by performing a [task] and return the cache |
| * entry associated with the results. |
| */ |
| SourceEntry _recordGetContentsTask(GetContentTask task) { |
| if (!task.isComplete) { |
| return null; |
| } |
| Source source = task.source; |
| SourceEntry sourceEntry = _cache.get(source); |
| CaughtException thrownException = task.exception; |
| if (thrownException != null) { |
| sourceEntry.recordContentError(thrownException); |
| _workManager.remove(source); |
| throw new AnalysisException('<rethrow>', thrownException); |
| } |
| sourceEntry.modificationTime = task.modificationTime; |
| sourceEntry.setValue(SourceEntry.CONTENT, task.content); |
| return sourceEntry; |
| } |
| |
| /** |
| * Record the results produced by performing a [IncrementalAnalysisTask]. |
| * |
| * @param task the task that was performed |
| * @return an entry containing the computed results |
| * @throws AnalysisException if the results could not be recorded |
| */ |
| DartEntry |
| _recordIncrementalAnalysisTaskResults(IncrementalAnalysisTask task) { |
| CompilationUnit unit = task.compilationUnit; |
| if (unit != null) { |
| ChangeNoticeImpl notice = _getNotice(task.source); |
| notice.resolvedDartUnit = unit; |
| _incrementalAnalysisCache = |
| IncrementalAnalysisCache.cacheResult(task.cache, unit); |
| } |
| return null; |
| } |
| |
| /** |
| * Record the results produced by performing a [task] and return the cache |
| * entry associated with the results. |
| */ |
| DartEntry _recordParseDartTaskResults(ParseDartTask task) { |
| Source source = task.source; |
| DartEntry dartEntry = _cache.get(source); |
| _removeFromParts(source, dartEntry); |
| CaughtException thrownException = task.exception; |
| if (thrownException != null) { |
| _removeFromParts(source, dartEntry); |
| dartEntry.recordParseError(thrownException); |
| _cache.removedAst(source); |
| throw new AnalysisException('<rethrow>', thrownException); |
| } |
| if (task.hasNonPartOfDirective) { |
| dartEntry.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY); |
| dartEntry.containingLibrary = source; |
| _workManager.add(source, SourcePriority.LIBRARY); |
| } else if (task.hasPartOfDirective) { |
| dartEntry.setValue(DartEntry.SOURCE_KIND, SourceKind.PART); |
| dartEntry.removeContainingLibrary(source); |
| _workManager.add(source, SourcePriority.NORMAL_PART); |
| } else { |
| // The file contains no directives. |
| List<Source> containingLibraries = dartEntry.containingLibraries; |
| if (containingLibraries.length > 1 || |
| (containingLibraries.length == 1 && containingLibraries[0] != source)) { |
| dartEntry.setValue(DartEntry.SOURCE_KIND, SourceKind.PART); |
| dartEntry.removeContainingLibrary(source); |
| _workManager.add(source, SourcePriority.NORMAL_PART); |
| } else { |
| dartEntry.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY); |
| dartEntry.containingLibrary = source; |
| _workManager.add(source, SourcePriority.LIBRARY); |
| } |
| } |
| List<Source> newParts = task.includedSources; |
| for (int i = 0; i < newParts.length; i++) { |
| Source partSource = newParts[i]; |
| DartEntry partEntry = _getReadableDartEntry(partSource); |
| if (partEntry != null && !identical(partEntry, dartEntry)) { |
| // TODO(brianwilkerson) Change the kind of the "part" if it was marked |
| // as a library and it has no directives. |
| partEntry.addContainingLibrary(source); |
| } |
| } |
| dartEntry.setValue(DartEntry.PARSED_UNIT, task.compilationUnit); |
| dartEntry.setValue(DartEntry.PARSE_ERRORS, task.errors); |
| dartEntry.setValue(DartEntry.EXPORTED_LIBRARIES, task.exportedSources); |
| dartEntry.setValue(DartEntry.IMPORTED_LIBRARIES, task.importedSources); |
| dartEntry.setValue(DartEntry.INCLUDED_PARTS, newParts); |
| _cache.storedAst(source); |
| ChangeNoticeImpl notice = _getNotice(source); |
| if (notice.resolvedDartUnit == null) { |
| notice.parsedDartUnit = task.compilationUnit; |
| } |
| notice.setErrors(dartEntry.allErrors, task.lineInfo); |
| // Verify that the incrementally parsed and resolved unit in the incremental |
| // cache is structurally equivalent to the fully parsed unit |
| _incrementalAnalysisCache = IncrementalAnalysisCache.verifyStructure( |
| _incrementalAnalysisCache, |
| source, |
| task.compilationUnit); |
| return dartEntry; |
| } |
| |
| /** |
| * Record the results produced by performing a [task] and return the cache |
| * entry associated with the results. |
| */ |
| HtmlEntry _recordParseHtmlTaskResults(ParseHtmlTask task) { |
| Source source = task.source; |
| HtmlEntry htmlEntry = _cache.get(source); |
| CaughtException thrownException = task.exception; |
| if (thrownException != null) { |
| htmlEntry.recordParseError(thrownException); |
| _cache.removedAst(source); |
| throw new AnalysisException('<rethrow>', thrownException); |
| } |
| LineInfo lineInfo = task.lineInfo; |
| htmlEntry.setValue(SourceEntry.LINE_INFO, lineInfo); |
| htmlEntry.setValue(HtmlEntry.PARSED_UNIT, task.htmlUnit); |
| htmlEntry.setValue(HtmlEntry.PARSE_ERRORS, task.errors); |
| htmlEntry.setValue( |
| HtmlEntry.REFERENCED_LIBRARIES, |
| task.referencedLibraries); |
| _cache.storedAst(source); |
| ChangeNoticeImpl notice = _getNotice(source); |
| notice.setErrors(htmlEntry.allErrors, lineInfo); |
| return htmlEntry; |
| } |
| |
| /** |
| * Record the results produced by performing a [task] and return the cache |
| * entry associated with the results. |
| */ |
| DartEntry _recordResolveDartUnitTaskResults(ResolveDartUnitTask task) { |
| Source unitSource = task.source; |
| DartEntry dartEntry = _cache.get(unitSource); |
| Source librarySource = task.librarySource; |
| CaughtException thrownException = task.exception; |
| if (thrownException != null) { |
| dartEntry.recordResolutionErrorInLibrary(librarySource, thrownException); |
| _cache.removedAst(unitSource); |
| throw new AnalysisException('<rethrow>', thrownException); |
| } |
| dartEntry.setValueInLibrary( |
| DartEntry.RESOLVED_UNIT, |
| librarySource, |
| task.resolvedUnit); |
| _cache.storedAst(unitSource); |
| return dartEntry; |
| } |
| |
| /** |
| * Record the results produced by performing a [task] and return the cache |
| * entry associated with the results. |
| */ |
| HtmlEntry _recordResolveHtmlTaskResults(ResolveHtmlTask task) { |
| Source source = task.source; |
| HtmlEntry htmlEntry = _cache.get(source); |
| CaughtException thrownException = task.exception; |
| if (thrownException != null) { |
| htmlEntry.recordResolutionError(thrownException); |
| _cache.removedAst(source); |
| throw new AnalysisException('<rethrow>', thrownException); |
| } |
| htmlEntry.setState(HtmlEntry.PARSED_UNIT, CacheState.FLUSHED); |
| htmlEntry.setValue(HtmlEntry.RESOLVED_UNIT, task.resolvedUnit); |
| htmlEntry.setValue(HtmlEntry.ELEMENT, task.element); |
| htmlEntry.setValue(HtmlEntry.RESOLUTION_ERRORS, task.resolutionErrors); |
| _cache.storedAst(source); |
| ChangeNoticeImpl notice = _getNotice(source); |
| notice.resolvedHtmlUnit = task.resolvedUnit; |
| LineInfo lineInfo = htmlEntry.getValue(SourceEntry.LINE_INFO); |
| notice.setErrors(htmlEntry.allErrors, lineInfo); |
| return htmlEntry; |
| } |
| |
| /** |
| * Record the results produced by performing a [task] and return the cache |
| * entry associated with the results. |
| */ |
| DartEntry _recordScanDartTaskResults(ScanDartTask task) { |
| Source source = task.source; |
| DartEntry dartEntry = _cache.get(source); |
| CaughtException thrownException = task.exception; |
| if (thrownException != null) { |
| _removeFromParts(source, dartEntry); |
| dartEntry.recordScanError(thrownException); |
| _cache.removedAst(source); |
| throw new AnalysisException('<rethrow>', thrownException); |
| } |
| LineInfo lineInfo = task.lineInfo; |
| dartEntry.setValue(SourceEntry.LINE_INFO, lineInfo); |
| dartEntry.setValue(DartEntry.TOKEN_STREAM, task.tokenStream); |
| dartEntry.setValue(DartEntry.SCAN_ERRORS, task.errors); |
| _cache.storedAst(source); |
| ChangeNoticeImpl notice = _getNotice(source); |
| notice.setErrors(dartEntry.allErrors, lineInfo); |
| return dartEntry; |
| } |
| |
| /** |
| * Remove the given library from the list of containing libraries for all of the parts referenced |
| * by the given entry. |
| * |
| * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock]. |
| * |
| * @param librarySource the library to be removed |
| * @param dartEntry the entry containing the list of included parts |
| */ |
| void _removeFromParts(Source librarySource, DartEntry dartEntry) { |
| List<Source> oldParts = dartEntry.getValue(DartEntry.INCLUDED_PARTS); |
| for (int i = 0; i < oldParts.length; i++) { |
| Source partSource = oldParts[i]; |
| DartEntry partEntry = _getReadableDartEntry(partSource); |
| if (partEntry != null && !identical(partEntry, dartEntry)) { |
| partEntry.removeContainingLibrary(librarySource); |
| if (partEntry.containingLibraries.length == 0 && !exists(partSource)) { |
| _cache.remove(partSource); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Remove the given libraries that are keys in the given map from the list of containing libraries |
| * for each of the parts in the corresponding value. |
| * |
| * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock]. |
| * |
| * @param oldPartMap the table containing the parts associated with each library |
| */ |
| void _removeFromPartsUsingMap(HashMap<Source, List<Source>> oldPartMap) { |
| oldPartMap.forEach((Source librarySource, List<Source> oldParts) { |
| for (int i = 0; i < oldParts.length; i++) { |
| Source partSource = oldParts[i]; |
| if (partSource != librarySource) { |
| DartEntry partEntry = _getReadableDartEntry(partSource); |
| if (partEntry != null) { |
| partEntry.removeContainingLibrary(librarySource); |
| if (partEntry.containingLibraries.length == 0 && |
| !exists(partSource)) { |
| _cache.remove(partSource); |
| } |
| } |
| } |
| } |
| }); |
| } |
| |
| /** |
| * Remove the given source from the priority order if it is in the list. |
| * |
| * @param source the source to be removed |
| */ |
| void _removeFromPriorityOrder(Source source) { |
| int count = _priorityOrder.length; |
| List<Source> newOrder = new List<Source>(); |
| for (int i = 0; i < count; i++) { |
| if (_priorityOrder[i] != source) { |
| newOrder.add(_priorityOrder[i]); |
| } |
| } |
| if (newOrder.length < count) { |
| analysisPriorityOrder = newOrder; |
| } |
| } |
| |
| /** |
| * Create an entry for the newly added source. Return `true` if the new source is a Dart |
| * file. |
| * |
| * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock]. |
| * |
| * @param source the source that has been added |
| * @return `true` if the new source is a Dart file |
| */ |
| bool _sourceAvailable(Source source) { |
| SourceEntry sourceEntry = _cache.get(source); |
| if (sourceEntry == null) { |
| sourceEntry = _createSourceEntry(source, true); |
| } else { |
| _sourceChanged(source); |
| sourceEntry = _cache.get(source); |
| } |
| if (sourceEntry is HtmlEntry) { |
| _workManager.add(source, SourcePriority.HTML); |
| } else if (sourceEntry is DartEntry) { |
| _workManager.add(source, _computePriority(sourceEntry as DartEntry)); |
| } |
| return sourceEntry is DartEntry; |
| } |
| |
| /** |
| * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock]. |
| * |
| * @param source the source that has been changed |
| */ |
| void _sourceChanged(Source source) { |
| SourceEntry sourceEntry = _cache.get(source); |
| if (sourceEntry == null || |
| sourceEntry.modificationTime == getModificationStamp(source)) { |
| // Either we have removed this source, in which case we don't care that |
| // it is changed, or we have already invalidated the cache and don't need |
| // to invalidate it again. |
| return; |
| } |
| if (sourceEntry is HtmlEntry) { |
| HtmlEntry htmlEntry = sourceEntry; |
| htmlEntry.modificationTime = getModificationStamp(source); |
| htmlEntry.invalidateAllInformation(); |
| _cache.removedAst(source); |
| _workManager.add(source, SourcePriority.HTML); |
| } else if (sourceEntry is DartEntry) { |
| List<Source> containingLibraries = getLibrariesContaining(source); |
| HashSet<Source> librariesToInvalidate = new HashSet<Source>(); |
| for (Source containingLibrary in containingLibraries) { |
| _computeAllLibrariesDependingOn( |
| containingLibrary, |
| librariesToInvalidate); |
| } |
| for (Source library in librariesToInvalidate) { |
| _invalidateLibraryResolution(library); |
| } |
| DartEntry dartEntry = _cache.get(source); |
| _removeFromParts(source, dartEntry); |
| dartEntry.modificationTime = getModificationStamp(source); |
| dartEntry.invalidateAllInformation(); |
| _cache.removedAst(source); |
| _workManager.add(source, SourcePriority.UNKNOWN); |
| } |
| // reset unit in the notification, it is out of date now |
| ChangeNoticeImpl notice = _pendingNotices[source]; |
| if (notice != null) { |
| notice.resolvedDartUnit = null; |
| notice.resolvedHtmlUnit = null; |
| } |
| } |
| |
| /** |
| * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock]. |
| * |
| * @param source the source that has been deleted |
| */ |
| void _sourceDeleted(Source source) { |
| SourceEntry sourceEntry = _cache.get(source); |
| if (sourceEntry is HtmlEntry) { |
| HtmlEntry htmlEntry = sourceEntry; |
| htmlEntry.recordContentError( |
| new CaughtException( |
| new AnalysisException("This source was marked as being deleted"), |
| null)); |
| } else if (sourceEntry is DartEntry) { |
| DartEntry dartEntry = sourceEntry; |
| HashSet<Source> libraries = new HashSet<Source>(); |
| for (Source librarySource in getLibrariesContaining(source)) { |
| libraries.add(librarySource); |
| for (Source dependentLibrary in getLibrariesDependingOn( |
| librarySource)) { |
| libraries.add(dependentLibrary); |
| } |
| } |
| for (Source librarySource in libraries) { |
| _invalidateLibraryResolution(librarySource); |
| } |
| dartEntry.recordContentError( |
| new CaughtException( |
| new AnalysisException("This source was marked as being deleted"), |
| null)); |
| } |
| _workManager.remove(source); |
| _removeFromPriorityOrder(source); |
| } |
| |
| /** |
| * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock]. |
| * |
| * @param source the source that has been removed |
| */ |
| void _sourceRemoved(Source source) { |
| SourceEntry sourceEntry = _cache.get(source); |
| if (sourceEntry is HtmlEntry) { |
| } else if (sourceEntry is DartEntry) { |
| HashSet<Source> libraries = new HashSet<Source>(); |
| for (Source librarySource in getLibrariesContaining(source)) { |
| libraries.add(librarySource); |
| for (Source dependentLibrary in getLibrariesDependingOn( |
| librarySource)) { |
| libraries.add(dependentLibrary); |
| } |
| } |
| for (Source librarySource in libraries) { |
| _invalidateLibraryResolution(librarySource); |
| } |
| } |
| _cache.remove(source); |
| _workManager.remove(source); |
| _removeFromPriorityOrder(source); |
| } |
| |
| /** |
| * TODO(scheglov) A hackish, limited incremental resolution implementation. |
| */ |
| bool _tryPoorMansIncrementalResolution(Source unitSource, String newCode) { |
| incrementalResolutionValidation_lastUnitSource = null; |
| incrementalResolutionValidation_lastLibrarySource = null; |
| incrementalResolutionValidation_lastUnit = null; |
| // prepare the entry |
| DartEntry dartEntry = _cache.get(unitSource); |
| if (dartEntry == null) { |
| return false; |
| } |
| // prepare the (only) library source |
| List<Source> librarySources = getLibrariesContaining(unitSource); |
| if (librarySources.length != 1) { |
| return false; |
| } |
| Source librarySource = librarySources[0]; |
| // prepare the library element |
| LibraryElement libraryElement = getLibraryElement(librarySource); |
| if (libraryElement == null) { |
| return false; |
| } |
| // prepare the existing library units |
| Map<Source, CompilationUnit> units = <Source, CompilationUnit>{}; |
| for (CompilationUnitElement unitElement in libraryElement.units) { |
| Source unitSource = unitElement.source; |
| CompilationUnit unit = |
| getResolvedCompilationUnit2(unitSource, librarySource); |
| if (unit == null) { |
| return false; |
| } |
| units[unitSource] = unit; |
| } |
| // prepare the existing unit |
| CompilationUnit oldUnit = units[unitSource]; |
| if (oldUnit == null) { |
| return false; |
| } |
| // do resolution |
| Stopwatch perfCounter = new Stopwatch()..start(); |
| PoorMansIncrementalResolver resolver = new PoorMansIncrementalResolver( |
| typeProvider, |
| units, |
| unitSource, |
| dartEntry, |
| analysisOptions.incrementalApi); |
| bool success = resolver.resolve(newCode); |
| AnalysisEngine.instance.instrumentationService.logPerformance( |
| AnalysisPerformanceKind.INCREMENTAL, |
| perfCounter, |
| 'success=$success,context_id=$_id,code_length=${newCode.length}'); |
| if (!success) { |
| return false; |
| } |
| // if validation, remember the result, but throw it away |
| if (analysisOptions.incrementalValidation) { |
| incrementalResolutionValidation_lastUnitSource = oldUnit.element.source; |
| incrementalResolutionValidation_lastLibrarySource = |
| oldUnit.element.library.source; |
| incrementalResolutionValidation_lastUnit = oldUnit; |
| return false; |
| } |
| // prepare notices |
| units.forEach((Source source, CompilationUnit unit) { |
| DartEntry dartEntry = _cache.get(source); |
| LineInfo lineInfo = getLineInfo(source); |
| ChangeNoticeImpl notice = _getNotice(source); |
| notice.resolvedDartUnit = unit; |
| notice.setErrors(dartEntry.allErrors, lineInfo); |
| }); |
| // OK |
| return true; |
| } |
| |
| /** |
| * Check the cache for any invalid entries (entries whose modification time does not match the |
| * modification time of the source associated with the entry). Invalid entries will be marked as |
| * invalid so that the source will be re-analyzed. |
| * |
| * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock]. |
| * |
| * @return `true` if at least one entry was invalid |
| */ |
| bool _validateCacheConsistency() { |
| int consistencyCheckStart = JavaSystem.nanoTime(); |
| List<Source> changedSources = new List<Source>(); |
| List<Source> missingSources = new List<Source>(); |
| MapIterator<Source, SourceEntry> iterator = _cache.iterator(); |
| while (iterator.moveNext()) { |
| Source source = iterator.key; |
| SourceEntry sourceEntry = iterator.value; |
| int sourceTime = getModificationStamp(source); |
| if (sourceTime != sourceEntry.modificationTime) { |
| changedSources.add(source); |
| } |
| if (sourceEntry.exception != null) { |
| if (!exists(source)) { |
| missingSources.add(source); |
| } |
| } |
| } |
| int count = changedSources.length; |
| for (int i = 0; i < count; i++) { |
| _sourceChanged(changedSources[i]); |
| } |
| int consistencyCheckEnd = JavaSystem.nanoTime(); |
| if (changedSources.length > 0 || missingSources.length > 0) { |
| StringBuffer buffer = new StringBuffer(); |
| buffer.write("Consistency check took "); |
| buffer.write((consistencyCheckEnd - consistencyCheckStart) / 1000000.0); |
| buffer.writeln(" ms and found"); |
| buffer.write(" "); |
| buffer.write(changedSources.length); |
| buffer.writeln(" inconsistent entries"); |
| buffer.write(" "); |
| buffer.write(missingSources.length); |
| buffer.writeln(" missing sources"); |
| for (Source source in missingSources) { |
| buffer.write(" "); |
| buffer.writeln(source.fullName); |
| } |
| _logInformation(buffer.toString()); |
| } |
| return changedSources.length > 0; |
| } |
| |
| void _validateLastIncrementalResolutionResult() { |
| if (incrementalResolutionValidation_lastUnitSource == null || |
| incrementalResolutionValidation_lastLibrarySource == null || |
| incrementalResolutionValidation_lastUnit == null) { |
| return; |
| } |
| CompilationUnit fullUnit = getResolvedCompilationUnit2( |
| incrementalResolutionValidation_lastUnitSource, |
| incrementalResolutionValidation_lastLibrarySource); |
| if (fullUnit != null) { |
| try { |
| assertSameResolution( |
| incrementalResolutionValidation_lastUnit, |
| fullUnit); |
| } on IncrementalResolutionMismatch catch (mismatch, stack) { |
| String failure = mismatch.message; |
| String message = |
| 'Incremental resolution mismatch:\n$failure\nat\n$stack'; |
| AnalysisEngine.instance.logger.logError(message); |
| } |
| } |
| incrementalResolutionValidation_lastUnitSource = null; |
| incrementalResolutionValidation_lastLibrarySource = null; |
| incrementalResolutionValidation_lastUnit = null; |
| } |
| } |
| |
| /** |
| * An `AnalysisTaskResultRecorder` is used by an analysis context to record the |
| * results of a task. |
| */ |
| class AnalysisContextImpl_AnalysisTaskResultRecorder implements |
| AnalysisTaskVisitor<SourceEntry> { |
| final AnalysisContextImpl AnalysisContextImpl_this; |
| |
| AnalysisContextImpl_AnalysisTaskResultRecorder(this.AnalysisContextImpl_this); |
| |
| @override |
| DartEntry visitBuildUnitElementTask(BuildUnitElementTask task) => |
| AnalysisContextImpl_this._recordBuildUnitElementTask(task); |
| |
| @override |
| DartEntry visitGenerateDartErrorsTask(GenerateDartErrorsTask task) => |
| AnalysisContextImpl_this._recordGenerateDartErrorsTask(task); |
| |
| @override |
| DartEntry visitGenerateDartHintsTask(GenerateDartHintsTask task) => |
| AnalysisContextImpl_this._recordGenerateDartHintsTask(task); |
| |
| @override |
| DartEntry visitGenerateDartLintsTask(GenerateDartLintsTask task) => |
| AnalysisContextImpl_this._recordGenerateDartLintsTask(task); |
| |
| @override |
| SourceEntry visitGetContentTask(GetContentTask task) => |
| AnalysisContextImpl_this._recordGetContentsTask(task); |
| |
| @override |
| DartEntry visitIncrementalAnalysisTask(IncrementalAnalysisTask task) => |
| AnalysisContextImpl_this._recordIncrementalAnalysisTaskResults(task); |
| |
| @override |
| DartEntry visitParseDartTask(ParseDartTask task) => |
| AnalysisContextImpl_this._recordParseDartTaskResults(task); |
| |
| @override |
| HtmlEntry visitParseHtmlTask(ParseHtmlTask task) => |
| AnalysisContextImpl_this._recordParseHtmlTaskResults(task); |
| |
| @override |
| DartEntry |
| visitResolveDartLibraryCycleTask(ResolveDartLibraryCycleTask task) => |
| AnalysisContextImpl_this.recordResolveDartLibraryCycleTaskResults(task); |
| |
| @override |
| DartEntry visitResolveDartLibraryTask(ResolveDartLibraryTask task) => |
| AnalysisContextImpl_this.recordResolveDartLibraryTaskResults(task); |
| |
| @override |
| DartEntry visitResolveDartUnitTask(ResolveDartUnitTask task) => |
| AnalysisContextImpl_this._recordResolveDartUnitTaskResults(task); |
| |
| @override |
| HtmlEntry visitResolveHtmlTask(ResolveHtmlTask task) => |
| AnalysisContextImpl_this._recordResolveHtmlTaskResults(task); |
| |
| @override |
| DartEntry visitScanDartTask(ScanDartTask task) => |
| AnalysisContextImpl_this._recordScanDartTaskResults(task); |
| } |
| |
| class AnalysisContextImpl_ContextRetentionPolicy implements CacheRetentionPolicy |
| { |
| final AnalysisContextImpl AnalysisContextImpl_this; |
| |
| AnalysisContextImpl_ContextRetentionPolicy(this.AnalysisContextImpl_this); |
| |
| @override |
| RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry) { |
| int priorityCount = AnalysisContextImpl_this._priorityOrder.length; |
| for (int i = 0; i < priorityCount; i++) { |
| if (source == AnalysisContextImpl_this._priorityOrder[i]) { |
| return RetentionPriority.HIGH; |
| } |
| } |
| if (AnalysisContextImpl_this._neededForResolution != null && |
| AnalysisContextImpl_this._neededForResolution.contains(source)) { |
| return RetentionPriority.HIGH; |
| } |
| if (sourceEntry is DartEntry) { |
| DartEntry dartEntry = sourceEntry; |
| if (_astIsNeeded(dartEntry)) { |
| return RetentionPriority.MEDIUM; |
| } |
| } |
| return RetentionPriority.LOW; |
| } |
| |
| bool _astIsNeeded(DartEntry dartEntry) => |
| dartEntry.hasInvalidData(DartEntry.HINTS) || |
| dartEntry.hasInvalidData(DartEntry.LINTS) || |
| dartEntry.hasInvalidData(DartEntry.VERIFICATION_ERRORS) || |
| dartEntry.hasInvalidData(DartEntry.RESOLUTION_ERRORS); |
| } |
| |
| /** |
| * Instances of the class `CycleBuilder` are used to construct a list of the libraries that |
| * must be resolved together in order to resolve any one of the libraries. |
| */ |
| class AnalysisContextImpl_CycleBuilder { |
| final AnalysisContextImpl AnalysisContextImpl_this; |
| |
| /** |
| * A table mapping the sources of the defining compilation units of libraries to the |
| * representation of the library that has the information needed to resolve the library. |
| */ |
| HashMap<Source, ResolvableLibrary> _libraryMap = |
| new HashMap<Source, ResolvableLibrary>(); |
| |
| /** |
| * The dependency graph used to compute the libraries in the cycle. |
| */ |
| DirectedGraph<ResolvableLibrary> _dependencyGraph; |
| |
| /** |
| * A list containing the libraries that are ready to be resolved. |
| */ |
| List<ResolvableLibrary> _librariesInCycle; |
| |
| /** |
| * The analysis task that needs to be performed before the cycle of libraries can be resolved, |
| * or `null` if the libraries are ready to be resolved. |
| */ |
| AnalysisContextImpl_TaskData _taskData; |
| |
| /** |
| * Initialize a newly created cycle builder. |
| */ |
| AnalysisContextImpl_CycleBuilder(this.AnalysisContextImpl_this) : super(); |
| |
| /** |
| * Return a list containing the libraries that are ready to be resolved (assuming that |
| * [getTaskData] returns `null`). |
| * |
| * @return the libraries that are ready to be resolved |
| */ |
| List<ResolvableLibrary> get librariesInCycle => _librariesInCycle; |
| |
| /** |
| * Return a representation of an analysis task that needs to be performed before the cycle of |
| * libraries can be resolved, or `null` if the libraries are ready to be resolved. |
| * |
| * @return the analysis task that needs to be performed before the cycle of libraries can be |
| * resolved |
| */ |
| AnalysisContextImpl_TaskData get taskData => _taskData; |
| |
| /** |
| * Compute a list of the libraries that need to be resolved together in order to resolve the |
| * given library. |
| * |
| * @param librarySource the source of the library to be resolved |
| * @throws AnalysisException if the core library cannot be found |
| */ |
| void computeCycleContaining(Source librarySource) { |
| // |
| // Create the object representing the library being resolved. |
| // |
| ResolvableLibrary targetLibrary = _createLibrary(librarySource); |
| // |
| // Compute the set of libraries that need to be resolved together. |
| // |
| _dependencyGraph = new DirectedGraph<ResolvableLibrary>(); |
| _computeLibraryDependencies(targetLibrary); |
| if (_taskData != null) { |
| return; |
| } |
| _librariesInCycle = _dependencyGraph.findCycleContaining(targetLibrary); |
| // |
| // Ensure that all of the data needed to resolve them has been computed. |
| // |
| _ensureImportsAndExports(); |
| if (_taskData != null) { |
| // At least one imported library needs to be resolved before the target |
| // library. |
| AnalysisTask task = _taskData.task; |
| if (task is ResolveDartLibraryTask) { |
| AnalysisContextImpl_this._workManager.addFirst( |
| task.librarySource, |
| SourcePriority.LIBRARY); |
| } |
| return; |
| } |
| _computePartsInCycle(librarySource); |
| if (_taskData != null) { |
| // At least one part needs to be parsed. |
| return; |
| } |
| // All of the AST's necessary to perform a resolution of the library cycle |
| // have been gathered, so it is no longer necessary to retain them in the |
| // cache. |
| AnalysisContextImpl_this._neededForResolution = null; |
| } |
| |
| /** |
| * Recursively traverse the libraries reachable from the given library, creating instances of |
| * the class [Library] to represent them, and record the references in the library |
| * objects. |
| * |
| * @param library the library to be processed to find libraries that have not yet been traversed |
| * @throws AnalysisException if some portion of the library graph could not be traversed |
| */ |
| void _computeLibraryDependencies(ResolvableLibrary library) { |
| Source librarySource = library.librarySource; |
| DartEntry dartEntry = |
| AnalysisContextImpl_this._getReadableDartEntry(librarySource); |
| List<Source> importedSources = |
| _getSources(librarySource, dartEntry, DartEntry.IMPORTED_LIBRARIES); |
| if (_taskData != null) { |
| return; |
| } |
| List<Source> exportedSources = |
| _getSources(librarySource, dartEntry, DartEntry.EXPORTED_LIBRARIES); |
| if (_taskData != null) { |
| return; |
| } |
| _computeLibraryDependenciesFromDirectives( |
| library, |
| importedSources, |
| exportedSources); |
| } |
| |
| /** |
| * Recursively traverse the libraries reachable from the given library, creating instances of |
| * the class [Library] to represent them, and record the references in the library |
| * objects. |
| * |
| * @param library the library to be processed to find libraries that have not yet been traversed |
| * @param importedSources an array containing the sources that are imported into the given |
| * library |
| * @param exportedSources an array containing the sources that are exported from the given |
| * library |
| */ |
| void _computeLibraryDependenciesFromDirectives(ResolvableLibrary library, |
| List<Source> importedSources, List<Source> exportedSources) { |
| int importCount = importedSources.length; |
| if (importCount > 0) { |
| List<ResolvableLibrary> importedLibraries = new List<ResolvableLibrary>(); |
| bool explicitlyImportsCore = false; |
| for (int i = 0; i < importCount; i++) { |
| Source importedSource = importedSources[i]; |
| if (importedSource == AnalysisContextImpl_this._coreLibrarySource) { |
| explicitlyImportsCore = true; |
| } |
| ResolvableLibrary importedLibrary = _libraryMap[importedSource]; |
| if (importedLibrary == null) { |
| importedLibrary = _createLibraryOrNull(importedSource); |
| if (importedLibrary != null) { |
| _computeLibraryDependencies(importedLibrary); |
| if (_taskData != null) { |
| return; |
| } |
| } |
| } |
| if (importedLibrary != null) { |
| importedLibraries.add(importedLibrary); |
| _dependencyGraph.addEdge(library, importedLibrary); |
| } |
| } |
| library.explicitlyImportsCore = explicitlyImportsCore; |
| if (!explicitlyImportsCore && |
| AnalysisContextImpl_this._coreLibrarySource != library.librarySource) { |
| ResolvableLibrary importedLibrary = |
| _libraryMap[AnalysisContextImpl_this._coreLibrarySource]; |
| if (importedLibrary == null) { |
| importedLibrary = |
| _createLibraryOrNull(AnalysisContextImpl_this._coreLibrarySource); |
| if (importedLibrary != null) { |
| _computeLibraryDependencies(importedLibrary); |
| if (_taskData != null) { |
| return; |
| } |
| } |
| } |
| if (importedLibrary != null) { |
| importedLibraries.add(importedLibrary); |
| _dependencyGraph.addEdge(library, importedLibrary); |
| } |
| } |
| library.importedLibraries = importedLibraries; |
| } else { |
| library.explicitlyImportsCore = false; |
| ResolvableLibrary importedLibrary = |
| _libraryMap[AnalysisContextImpl_this._coreLibrarySource]; |
| if (importedLibrary == null) { |
| importedLibrary = |
| _createLibraryOrNull(AnalysisContextImpl_this._coreLibrarySource); |
| if (importedLibrary != null) { |
| _computeLibraryDependencies(importedLibrary); |
| if (_taskData != null) { |
| return; |
| } |
| } |
| } |
| if (importedLibrary != null) { |
| _dependencyGraph.addEdge(library, importedLibrary); |
| library.importedLibraries = <ResolvableLibrary>[importedLibrary]; |
| } |
| } |
| int exportCount = exportedSources.length; |
| if (exportCount > 0) { |
| List<ResolvableLibrary> exportedLibraries = new List<ResolvableLibrary>(); |
| for (int i = 0; i < exportCount; i++) { |
| Source exportedSource = exportedSources[i]; |
| ResolvableLibrary exportedLibrary = _libraryMap[exportedSource]; |
| if (exportedLibrary == null) { |
| exportedLibrary = _createLibraryOrNull(exportedSource); |
| if (exportedLibrary != null) { |
| _computeLibraryDependencies(exportedLibrary); |
| if (_taskData != null) { |
| return; |
| } |
| } |
| } |
| if (exportedLibrary != null) { |
| exportedLibraries.add(exportedLibrary); |
| _dependencyGraph.addEdge(library, exportedLibrary); |
| } |
| } |
| library.exportedLibraries = exportedLibraries; |
| } |
| } |
| |
| /** |
| * Gather the resolvable AST structures for each of the compilation units in each of the |
| * libraries in the cycle. This is done in two phases: first we ensure that we have cached an |
| * AST structure for each compilation unit, then we gather them. We split the work this way |
| * because getting the AST structures can change the state of the cache in such a way that we |
| * would have more work to do if any compilation unit didn't have a resolvable AST structure. |
| */ |
| void _computePartsInCycle(Source librarySource) { |
| int count = _librariesInCycle.length; |
| List<CycleBuilder_LibraryPair> libraryData = |
| new List<CycleBuilder_LibraryPair>(); |
| for (int i = 0; i < count; i++) { |
| ResolvableLibrary library = _librariesInCycle[i]; |
| libraryData.add( |
| new CycleBuilder_LibraryPair(library, _ensurePartsInLibrary(library))); |
| } |
| AnalysisContextImpl_this._neededForResolution = _gatherSources(libraryData); |
| if (AnalysisContextImpl._TRACE_PERFORM_TASK) { |
| print( |
| " preserve resolution data for ${AnalysisContextImpl_this._neededForResolution.length} sources while resolving ${librarySource.fullName}"); |
| } |
| if (_taskData != null) { |
| return; |
| } |
| for (int i = 0; i < count; i++) { |
| _computePartsInLibrary(libraryData[i]); |
| } |
| } |
| |
| /** |
| * Gather the resolvable compilation units for each of the compilation units in the specified |
| * library. |
| * |
| * @param libraryPair a holder containing both the library and a list of (source, entry) pairs |
| * for all of the compilation units in the library |
| */ |
| void _computePartsInLibrary(CycleBuilder_LibraryPair libraryPair) { |
| ResolvableLibrary library = libraryPair.library; |
| List<CycleBuilder_SourceEntryPair> entryPairs = libraryPair.entryPairs; |
| int count = entryPairs.length; |
| List<ResolvableCompilationUnit> units = |
| new List<ResolvableCompilationUnit>(count); |
| for (int i = 0; i < count; i++) { |
| CycleBuilder_SourceEntryPair entryPair = entryPairs[i]; |
| Source source = entryPair.source; |
| DartEntry dartEntry = entryPair.entry; |
| units[i] = |
| new ResolvableCompilationUnit(source, dartEntry.resolvableCompilationUnit); |
| } |
| library.resolvableCompilationUnits = units; |
| } |
| |
| /** |
| * Create an object to represent the information about the library defined by the compilation |
| * unit with the given source. |
| * |
| * @param librarySource the source of the library's defining compilation unit |
| * @return the library object that was created |
| */ |
| ResolvableLibrary _createLibrary(Source librarySource) { |
| ResolvableLibrary library = new ResolvableLibrary(librarySource); |
| SourceEntry sourceEntry = |
| AnalysisContextImpl_this._cache.get(librarySource); |
| if (sourceEntry is DartEntry) { |
| LibraryElementImpl libraryElement = |
| sourceEntry.getValue(DartEntry.ELEMENT) as LibraryElementImpl; |
| if (libraryElement != null) { |
| library.libraryElement = libraryElement; |
| } |
| } |
| _libraryMap[librarySource] = library; |
| return library; |
| } |
| |
| /** |
| * Create an object to represent the information about the library defined by the compilation |
| * unit with the given source. |
| * |
| * @param librarySource the source of the library's defining compilation unit |
| * @return the library object that was created |
| */ |
| ResolvableLibrary _createLibraryOrNull(Source librarySource) { |
| ResolvableLibrary library = new ResolvableLibrary(librarySource); |
| SourceEntry sourceEntry = |
| AnalysisContextImpl_this._cache.get(librarySource); |
| if (sourceEntry is DartEntry) { |
| LibraryElementImpl libraryElement = |
| sourceEntry.getValue(DartEntry.ELEMENT) as LibraryElementImpl; |
| if (libraryElement != null) { |
| library.libraryElement = libraryElement; |
| } |
| } |
| _libraryMap[librarySource] = library; |
| return library; |
| } |
| |
| /** |
| * Ensure that the given library has an element model built for it. If another task needs to be |
| * executed first in order to build the element model, that task is placed in [taskData]. |
| * |
| * @param library the library which needs an element model. |
| */ |
| void _ensureElementModel(ResolvableLibrary library) { |
| Source librarySource = library.librarySource; |
| DartEntry libraryEntry = |
| AnalysisContextImpl_this._getReadableDartEntry(librarySource); |
| if (libraryEntry != null && |
| libraryEntry.getState(DartEntry.PARSED_UNIT) != CacheState.ERROR) { |
| AnalysisContextImpl_this._workManager.addFirst( |
| librarySource, |
| SourcePriority.LIBRARY); |
| if (_taskData == null) { |
| _taskData = AnalysisContextImpl_this._createResolveDartLibraryTask( |
| librarySource, |
| libraryEntry); |
| } |
| } |
| } |
| |
| /** |
| * Ensure that all of the libraries that are exported by the given library (but are not |
| * themselves in the cycle) have element models built for them. If another task needs to be |
| * executed first in order to build the element model, that task is placed in [taskData]. |
| * |
| * @param library the library being tested |
| */ |
| void _ensureExports(ResolvableLibrary library, |
| HashSet<Source> visitedLibraries) { |
| List<ResolvableLibrary> dependencies = library.exports; |
| int dependencyCount = dependencies.length; |
| for (int i = 0; i < dependencyCount; i++) { |
| ResolvableLibrary dependency = dependencies[i]; |
| if (!_librariesInCycle.contains(dependency) && |
| visitedLibraries.add(dependency.librarySource)) { |
| if (dependency.libraryElement == null) { |
| _ensureElementModel(dependency); |
| } else { |
| _ensureExports(dependency, visitedLibraries); |
| } |
| if (_taskData != null) { |
| return; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Ensure that all of the libraries that are exported by the given library (but are not |
| * themselves in the cycle) have element models built for them. If another task needs to be |
| * executed first in order to build the element model, that task is placed in [taskData]. |
| * |
| * @param library the library being tested |
| */ |
| void _ensureImports(ResolvableLibrary library) { |
| List<ResolvableLibrary> dependencies = library.imports; |
| int dependencyCount = dependencies.length; |
| for (int i = 0; i < dependencyCount; i++) { |
| ResolvableLibrary dependency = dependencies[i]; |
| if (!_librariesInCycle.contains(dependency) && |
| dependency.libraryElement == null) { |
| _ensureElementModel(dependency); |
| if (_taskData != null) { |
| return; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Ensure that all of the libraries that are either imported or exported by libraries in the |
| * cycle (but are not themselves in the cycle) have element models built for them. |
| */ |
| void _ensureImportsAndExports() { |
| HashSet<Source> visitedLibraries = new HashSet<Source>(); |
| int libraryCount = _librariesInCycle.length; |
| for (int i = 0; i < libraryCount; i++) { |
| ResolvableLibrary library = _librariesInCycle[i]; |
| _ensureImports(library); |
| if (_taskData != null) { |
| return; |
| } |
| _ensureExports(library, visitedLibraries); |
| if (_taskData != null) { |
| return; |
| } |
| } |
| } |
| |
| /** |
| * Ensure that there is a resolvable compilation unit available for all of the compilation units |
| * in the given library. |
| * |
| * @param library the library for which resolvable compilation units must be available |
| * @return a list of (source, entry) pairs for all of the compilation units in the library |
| */ |
| List<CycleBuilder_SourceEntryPair> |
| _ensurePartsInLibrary(ResolvableLibrary library) { |
| List<CycleBuilder_SourceEntryPair> pairs = |
| new List<CycleBuilder_SourceEntryPair>(); |
| Source librarySource = library.librarySource; |
| DartEntry libraryEntry = |
| AnalysisContextImpl_this._getReadableDartEntry(librarySource); |
| if (libraryEntry == null) { |
| throw new AnalysisException( |
| "Cannot find entry for ${librarySource.fullName}"); |
| } else if (libraryEntry.getState(DartEntry.PARSED_UNIT) == |
| CacheState.ERROR) { |
| String message = |
| "Cannot compute parsed unit for ${librarySource.fullName}"; |
| CaughtException exception = libraryEntry.exception; |
| if (exception == null) { |
| throw new AnalysisException(message); |
| } |
| throw new AnalysisException( |
| message, |
| new CaughtException(exception, null)); |
| } |
| _ensureResolvableCompilationUnit(librarySource, libraryEntry); |
| pairs.add(new CycleBuilder_SourceEntryPair(librarySource, libraryEntry)); |
| List<Source> partSources = |
| _getSources(librarySource, libraryEntry, DartEntry.INCLUDED_PARTS); |
| int count = partSources.length; |
| for (int i = 0; i < count; i++) { |
| Source partSource = partSources[i]; |
| DartEntry partEntry = |
| AnalysisContextImpl_this._getReadableDartEntry(partSource); |
| if (partEntry != null && |
| partEntry.getState(DartEntry.PARSED_UNIT) != CacheState.ERROR) { |
| _ensureResolvableCompilationUnit(partSource, partEntry); |
| pairs.add(new CycleBuilder_SourceEntryPair(partSource, partEntry)); |
| } |
| } |
| return pairs; |
| } |
| |
| /** |
| * Ensure that there is a resolvable compilation unit available for the given source. |
| * |
| * @param source the source for which a resolvable compilation unit must be available |
| * @param dartEntry the entry associated with the source |
| */ |
| void _ensureResolvableCompilationUnit(Source source, DartEntry dartEntry) { |
| // The entry will be null if the source represents a non-Dart file. |
| if (dartEntry != null && !dartEntry.hasResolvableCompilationUnit) { |
| if (_taskData == null) { |
| _taskData = |
| AnalysisContextImpl_this._createParseDartTask(source, dartEntry); |
| } |
| } |
| } |
| |
| HashSet<Source> _gatherSources(List<CycleBuilder_LibraryPair> libraryData) { |
| int libraryCount = libraryData.length; |
| HashSet<Source> sources = new HashSet<Source>(); |
| for (int i = 0; i < libraryCount; i++) { |
| List<CycleBuilder_SourceEntryPair> entryPairs = libraryData[i].entryPairs; |
| int entryCount = entryPairs.length; |
| for (int j = 0; j < entryCount; j++) { |
| sources.add(entryPairs[j].source); |
| } |
| } |
| return sources; |
| } |
| |
| /** |
| * Return the sources described by the given descriptor. |
| * |
| * @param source the source with which the sources are associated |
| * @param dartEntry the entry corresponding to the source |
| * @param descriptor the descriptor indicating which sources are to be returned |
| * @return the sources described by the given descriptor |
| */ |
| List<Source> _getSources(Source source, DartEntry dartEntry, |
| DataDescriptor<List<Source>> descriptor) { |
| if (dartEntry == null) { |
| return Source.EMPTY_ARRAY; |
| } |
| CacheState exportState = dartEntry.getState(descriptor); |
| if (exportState == CacheState.ERROR) { |
| return Source.EMPTY_ARRAY; |
| } else if (exportState != CacheState.VALID) { |
| if (_taskData == null) { |
| _taskData = |
| AnalysisContextImpl_this._createParseDartTask(source, dartEntry); |
| } |
| return Source.EMPTY_ARRAY; |
| } |
| return dartEntry.getValue(descriptor); |
| } |
| } |
| |
| /** |
| * Instances of the class `TaskData` represent information about the next task to be |
| * performed. Each data has an implicit associated source: the source that might need to be |
| * analyzed. There are essentially three states that can be represented: |
| * * If [getTask] returns a non-`null` value, then that is the task that should |
| * be executed to further analyze the associated source. |
| * * Otherwise, if [isBlocked] returns `true`, then there is no work that can be |
| * done, but analysis for the associated source is not complete. |
| * * Otherwise, [getDependentSource] should return a source that needs to be analyzed |
| * before the analysis of the associated source can be completed. |
| */ |
| class AnalysisContextImpl_TaskData { |
| /** |
| * The task that is to be performed. |
| */ |
| final AnalysisTask task; |
| |
| /** |
| * A flag indicating whether the associated source is blocked waiting for its contents to be |
| * loaded. |
| */ |
| final bool _blocked; |
| |
| /** |
| * Initialize a newly created data holder. |
| * |
| * @param task the task that is to be performed |
| * @param blocked `true` if the associated source is blocked waiting for its contents to |
| * be loaded |
| */ |
| AnalysisContextImpl_TaskData(this.task, this._blocked); |
| |
| /** |
| * Return `true` if the associated source is blocked waiting for its contents to be |
| * loaded. |
| * |
| * @return `true` if the associated source is blocked waiting for its contents to be |
| * loaded |
| */ |
| bool get isBlocked => _blocked; |
| |
| @override |
| String toString() { |
| if (task == null) { |
| return "blocked: $_blocked"; |
| } |
| return task.toString(); |
| } |
| } |
| |
| /** |
| * The interface `AnalysisContextStatistics` defines access to statistics about a single |
| * [AnalysisContext]. |
| */ |
| abstract class AnalysisContextStatistics { |
| /** |
| * Return the statistics for each kind of cached data. |
| */ |
| List<AnalysisContextStatistics_CacheRow> get cacheRows; |
| |
| /** |
| * Return the exceptions that caused some entries to have a state of [CacheState.ERROR]. |
| */ |
| List<CaughtException> get exceptions; |
| |
| /** |
| * Return information about each of the partitions in the cache. |
| */ |
| List<AnalysisContextStatistics_PartitionData> get partitionData; |
| |
| /** |
| * Return an array containing all of the sources in the cache. |
| */ |
| List<Source> get sources; |
| } |
| |
| /** |
| * Information about single piece of data in the cache. |
| */ |
| abstract class AnalysisContextStatistics_CacheRow { |
| /** |
| * List of possible states which can be queried. |
| */ |
| static const List<CacheState> STATES = const <CacheState>[ |
| CacheState.ERROR, |
| CacheState.FLUSHED, |
| CacheState.IN_PROCESS, |
| CacheState.INVALID, |
| CacheState.VALID]; |
| |
| /** |
| * Return the number of entries whose state is [CacheState.ERROR]. |
| */ |
| int get errorCount; |
| |
| /** |
| * Return the number of entries whose state is [CacheState.FLUSHED]. |
| */ |
| int get flushedCount; |
| |
| /** |
| * Return the number of entries whose state is [CacheState.IN_PROCESS]. |
| */ |
| int get inProcessCount; |
| |
| /** |
| * Return the number of entries whose state is [CacheState.INVALID]. |
| */ |
| int get invalidCount; |
| |
| /** |
| * Return the name of the data represented by this object. |
| */ |
| String get name; |
| |
| /** |
| * Return the number of entries whose state is [CacheState.VALID]. |
| */ |
| int get validCount; |
| |
| /** |
| * Return the number of entries whose state is [state]. |
| */ |
| int getCount(CacheState state); |
| } |
| |
| /** |
| * Information about a single partition in the cache. |
| */ |
| abstract class AnalysisContextStatistics_PartitionData { |
| /** |
| * Return the number of entries in the partition that have an AST structure in one state or |
| * another. |
| */ |
| int get astCount; |
| |
| /** |
| * Return the total number of entries in the partition. |
| */ |
| int get totalCount; |
| } |
| |
| /** |
| * Implementation of the [AnalysisContextStatistics]. |
| */ |
| class AnalysisContextStatisticsImpl implements AnalysisContextStatistics { |
| Map<String, AnalysisContextStatistics_CacheRow> _dataMap = |
| new HashMap<String, AnalysisContextStatistics_CacheRow>(); |
| |
| List<Source> _sources = new List<Source>(); |
| |
| HashSet<CaughtException> _exceptions = new HashSet<CaughtException>(); |
| |
| List<AnalysisContextStatistics_PartitionData> _partitionData; |
| |
| @override |
| List<AnalysisContextStatistics_CacheRow> get cacheRows => |
| _dataMap.values.toList(); |
| |
| @override |
| List<CaughtException> get exceptions => new List.from(_exceptions); |
| |
| @override |
| List<AnalysisContextStatistics_PartitionData> get partitionData => |
| _partitionData; |
| |
| /** |
| * Set the partition data returned by this object to the given data. |
| */ |
| void set partitionData(List<AnalysisContextStatistics_PartitionData> data) { |
| _partitionData = data; |
| } |
| |
| @override |
| List<Source> get sources => _sources; |
| |
| void addSource(Source source) { |
| _sources.add(source); |
| } |
| |
| void _internalPutCacheItem(Source source, SourceEntry dartEntry, |
| DataDescriptor rowDesc, CacheState state) { |
| String rowName = rowDesc.toString(); |
| AnalysisContextStatisticsImpl_CacheRowImpl row = |
| _dataMap[rowName] as AnalysisContextStatisticsImpl_CacheRowImpl; |
| if (row == null) { |
| row = new AnalysisContextStatisticsImpl_CacheRowImpl(rowName); |
| _dataMap[rowName] = row; |
| } |
| row._incState(state); |
| if (state == CacheState.ERROR) { |
| CaughtException exception = dartEntry.exception; |
| if (exception != null) { |
| _exceptions.add(exception); |
| } |
| } |
| } |
| } |
| |
| class AnalysisContextStatisticsImpl_CacheRowImpl implements |
| AnalysisContextStatistics_CacheRow { |
| final String name; |
| |
| Map<CacheState, int> _counts = <CacheState, int>{}; |
| |
| AnalysisContextStatisticsImpl_CacheRowImpl(this.name); |
| |
| @override |
| int get errorCount => getCount(CacheState.ERROR); |
| |
| @override |
| int get flushedCount => getCount(CacheState.FLUSHED); |
| |
| @override |
| int get hashCode => name.hashCode; |
| |
| @override |
| int get inProcessCount => getCount(CacheState.IN_PROCESS); |
| |
| @override |
| int get invalidCount => getCount(CacheState.INVALID); |
| |
| @override |
| int get validCount => getCount(CacheState.VALID); |
| |
| @override |
| bool operator ==(Object obj) => |
| obj is AnalysisContextStatisticsImpl_CacheRowImpl && obj.name == name; |
| |
| @override |
| int getCount(CacheState state) { |
| int count = _counts[state]; |
| if (count != null) { |
| return count; |
| } else { |
| return 0; |
| } |
| } |
| |
| void _incState(CacheState state) { |
| if (_counts[state] == null) { |
| _counts[state] = 1; |
| } else { |
| _counts[state]++; |
| } |
| } |
| } |
| |
| class AnalysisContextStatisticsImpl_PartitionDataImpl implements |
| AnalysisContextStatistics_PartitionData { |
| final int astCount; |
| |
| final int totalCount; |
| |
| AnalysisContextStatisticsImpl_PartitionDataImpl(this.astCount, |
| this.totalCount); |
| } |
| |
| /** |
| * Instances of the class `AnalysisDelta` indicate changes to the types of analysis that |
| * should be performed. |
| */ |
| class AnalysisDelta { |
| /** |
| * A mapping from source to what type of analysis should be performed on that source. |
| */ |
| HashMap<Source, AnalysisLevel> _analysisMap = |
| new HashMap<Source, AnalysisLevel>(); |
| |
| /** |
| * Return a collection of the sources that have been added. This is equivalent to calling |
| * [getAnalysisLevels] and collecting all sources that do not have an analysis level of |
| * [AnalysisLevel.NONE]. |
| * |
| * @return a collection of the sources |
| */ |
| List<Source> get addedSources { |
| List<Source> result = new List<Source>(); |
| _analysisMap.forEach((Source source, AnalysisLevel level) { |
| if (level != AnalysisLevel.NONE) { |
| result.add(source); |
| } |
| }); |
| return result; |
| } |
| |
| /** |
| * Return a mapping of sources to the level of analysis that should be performed. |
| * |
| * @return the analysis map |
| */ |
| Map<Source, AnalysisLevel> get analysisLevels => _analysisMap; |
| |
| /** |
| * Record that the specified source should be analyzed at the specified level. |
| * |
| * @param source the source |
| * @param level the level at which the given source should be analyzed |
| */ |
| void setAnalysisLevel(Source source, AnalysisLevel level) { |
| _analysisMap[source] = level; |
| } |
| |
| @override |
| String toString() { |
| StringBuffer buffer = new StringBuffer(); |
| bool needsSeparator = _appendSources(buffer, false, AnalysisLevel.ALL); |
| needsSeparator = |
| _appendSources(buffer, needsSeparator, AnalysisLevel.RESOLVED); |
| _appendSources(buffer, needsSeparator, AnalysisLevel.NONE); |
| return buffer.toString(); |
| } |
| |
| /** |
| * Appendto the given [builder] all sources with the given analysis [level], |
| * prefixed with a label and a separator if [needsSeparator] is `true`. |
| */ |
| bool _appendSources(StringBuffer buffer, bool needsSeparator, |
| AnalysisLevel level) { |
| bool first = true; |
| _analysisMap.forEach((Source source, AnalysisLevel sourceLevel) { |
| if (sourceLevel == level) { |
| if (first) { |
| first = false; |
| if (needsSeparator) { |
| buffer.write("; "); |
| } |
| buffer.write(level); |
| buffer.write(" "); |
| } else { |
| buffer.write(", "); |
| } |
| buffer.write(source.fullName); |
| } |
| }); |
| return needsSeparator || !first; |
| } |
| } |
| |
| /** |
| * The unique instance of the class `AnalysisEngine` serves as the entry point |
| * for the functionality provided by the analysis engine. |
| */ |
| class AnalysisEngine { |
| /** |
| * The suffix used for Dart source files. |
| */ |
| static String SUFFIX_DART = "dart"; |
| |
| /** |
| * The short suffix used for HTML files. |
| */ |
| static String SUFFIX_HTM = "htm"; |
| |
| /** |
| * The long suffix used for HTML files. |
| */ |
| static String SUFFIX_HTML = "html"; |
| |
| /** |
| * 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; |
| |
| /** |
| * The instrumentation service that is to be used by this analysis engine. |
| */ |
| InstrumentationService _instrumentationService = |
| InstrumentationService.NULL_SERVICE; |
| |
| /** |
| * The partition manager being used to manage the shared partitions. |
| */ |
| final PartitionManager partitionManager = new PartitionManager(); |
| |
| /** |
| * A flag indicating whether union types should be used. |
| */ |
| bool enableUnionTypes = false; |
| |
| /** |
| * A flag indicating whether union types should have strict semantics. This option has no effect |
| * when `enabledUnionTypes` is `false`. |
| */ |
| bool strictUnionTypes = false; |
| |
| /** |
| * Return the instrumentation service that is to be used by this analysis |
| * engine. |
| */ |
| InstrumentationService get instrumentationService => _instrumentationService; |
| |
| /** |
| * Set the instrumentation service that is to be used by this analysis engine |
| * to the given [service]. |
| */ |
| void set instrumentationService(InstrumentationService service) { |
| if (service == null) { |
| _instrumentationService = InstrumentationService.NULL_SERVICE; |
| } else { |
| _instrumentationService = service; |
| } |
| } |
| |
| /** |
| * 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 logger) { |
| this._logger = logger == null ? Logger.NULL : logger; |
| } |
| |
| /** |
| * Clear any caches holding on to analysis results so that a full re-analysis will be performed |
| * the next time an analysis context is created. |
| */ |
| void clearCaches() { |
| partitionManager.clearCache(); |
| } |
| |
| /** |
| * Create a new context in which analysis can be performed. |
| * |
| * @return the analysis context that was created |
| */ |
| AnalysisContext createAnalysisContext() { |
| return new AnalysisContextImpl(); |
| } |
| |
| /** |
| * Return `true` if the given file name is assumed to contain Dart source code. |
| * |
| * @param fileName the name of the file being tested |
| * @return `true` if the given file name is assumed to contain Dart source code |
| */ |
| static bool isDartFileName(String fileName) { |
| if (fileName == null) { |
| return false; |
| } |
| return javaStringEqualsIgnoreCase( |
| FileNameUtilities.getExtension(fileName), |
| SUFFIX_DART); |
| } |
| |
| /** |
| * Return `true` if the given file name is assumed to contain HTML. |
| * |
| * @param fileName the name of the file being tested |
| * @return `true` if the given file name is assumed to contain HTML |
| */ |
| static bool isHtmlFileName(String fileName) { |
| if (fileName == null) { |
| return false; |
| } |
| String extension = FileNameUtilities.getExtension(fileName); |
| return javaStringEqualsIgnoreCase(extension, SUFFIX_HTML) || |
| javaStringEqualsIgnoreCase(extension, SUFFIX_HTM); |
| } |
| } |
| |
| /** |
| * The interface `AnalysisErrorInfo` contains the analysis errors and line information for the |
| * errors. |
| */ |
| abstract class AnalysisErrorInfo { |
| /** |
| * Return the errors that as a result of the analysis, or `null` if there were no errors. |
| * |
| * @return the errors as a result of the analysis |
| */ |
| List<AnalysisError> get errors; |
| |
| /** |
| * Return the line information associated with the errors, or `null` if there were no |
| * errors. |
| * |
| * @return the line information associated with the errors |
| */ |
| LineInfo get lineInfo; |
| } |
| |
| /** |
| * Instances of the class `AnalysisErrorInfoImpl` represent the analysis errors and line info |
| * associated with a source. |
| */ |
| class AnalysisErrorInfoImpl implements AnalysisErrorInfo { |
| /** |
| * The analysis errors associated with a source, or `null` if there are no errors. |
| */ |
| final List<AnalysisError> errors; |
| |
| /** |
| * The line information associated with the errors, or `null` if there are no errors. |
| */ |
| final LineInfo lineInfo; |
| |
| /** |
| * Initialize an newly created error info with the errors and line information |
| * |
| * @param errors the errors as a result of analysis |
| * @param lineinfo the line info for the errors |
| */ |
| AnalysisErrorInfoImpl(this.errors, this.lineInfo); |
| } |
| |
| /** |
| * The enumeration `AnalysisLevel` encodes the different levels at which a source can be |
| * analyzed. |
| */ |
| class AnalysisLevel extends Enum<AnalysisLevel> { |
| /** |
| * Indicates a source should be fully analyzed. |
| */ |
| static const AnalysisLevel ALL = const AnalysisLevel('ALL', 0); |
| |
| /** |
| * Indicates a source should be resolved and that errors, warnings and hints are needed. |
| */ |
| static const AnalysisLevel ERRORS = const AnalysisLevel('ERRORS', 1); |
| |
| /** |
| * Indicates a source should be resolved, but that errors, warnings and hints are not needed. |
| */ |
| static const AnalysisLevel RESOLVED = const AnalysisLevel('RESOLVED', 2); |
| |
| /** |
| * Indicates a source is not of interest to the client. |
| */ |
| static const AnalysisLevel NONE = const AnalysisLevel('NONE', 3); |
| |
| static const List<AnalysisLevel> values = const [ALL, ERRORS, RESOLVED, NONE]; |
| |
| const AnalysisLevel(String name, int ordinal) : super(name, ordinal); |
| } |
| |
| /** |
| * The interface `AnalysisListener` defines the behavior of objects that are listening for |
| * results being produced by an analysis context. |
| */ |
| abstract class AnalysisListener { |
| /** |
| * Reports that a task is about to be performed by the given context. |
| * |
| * @param context the context in which the task is to be performed |
| * @param taskDescription a human readable description of the task that is about to be performed |
| */ |
| void aboutToPerformTask(AnalysisContext context, String taskDescription); |
| |
| /** |
| * Reports that the errors associated with the given source in the given context has been updated |
| * to the given errors. |
| * |
| * @param context the context in which the new list of errors was produced |
| * @param source the source containing the errors that were computed |
| * @param errors the errors that were computed |
| * @param lineInfo the line information associated with the source |
| */ |
| void computedErrors(AnalysisContext context, Source source, |
| List<AnalysisError> errors, LineInfo lineInfo); |
| |
| /** |
| * Reports that the given source is no longer included in the set of sources that are being |
| * analyzed by the given analysis context. |
| * |
| * @param context the context in which the source is being analyzed |
| * @param source the source that is no longer being analyzed |
| */ |
| void excludedSource(AnalysisContext context, Source source); |
| |
| /** |
| * Reports that the given source is now included in the set of sources that are being analyzed by |
| * the given analysis context. |
| * |
| * @param context the context in which the source is being analyzed |
| * @param source the source that is now being analyzed |
| */ |
| void includedSource(AnalysisContext context, Source source); |
| |
| /** |
| * Reports that the given Dart source was parsed in the given context. |
| * |
| * @param context the context in which the source was parsed |
| * @param source the source that was parsed |
| * @param unit the result of parsing the source in the given context |
| */ |
| void parsedDart(AnalysisContext context, Source source, CompilationUnit unit); |
| |
| /** |
| * Reports that the given HTML source was parsed in the given context. |
| * |
| * @param context the context in which the source was parsed |
| * @param source the source that was parsed |
| * @param unit the result of parsing the source in the given context |
| */ |
| void parsedHtml(AnalysisContext context, Source source, ht.HtmlUnit unit); |
| |
| /** |
| * Reports that the given Dart source was resolved in the given context. |
| * |
| * @param context the context in which the source was resolved |
| * @param source the source that was resolved |
| * @param unit the result of resolving the source in the given context |
| */ |
| void resolvedDart(AnalysisContext context, Source source, |
| CompilationUnit unit); |
| |
| /** |
| * Reports that the given HTML source was resolved in the given context. |
| * |
| * @param context the context in which the source was resolved |
| * @param source the source that was resolved |
| * @param unit the result of resolving the source in the given context |
| */ |
| void resolvedHtml(AnalysisContext context, Source source, ht.HtmlUnit unit); |
| } |
| |
| /** |
| * Futures returned by [AnalysisContext] for pending analysis results will |
| * complete with this error if it is determined that analysis results will |
| * never become available (e.g. because the requested source is not subject to |
| * analysis, or because the requested source is a part file which is not a part |
| * of any known library). |
| */ |
| class AnalysisNotScheduledError implements Exception { |
| } |
| |
| /** |
| * The interface `AnalysisOptions` defines the behavior of objects that provide access to a |
| * set of analysis options used to control the behavior of an analysis context. |
| */ |
| abstract class AnalysisOptions { |
| /** |
| * Return `true` if analysis is to parse and analyze function bodies. |
| * |
| * @return `true` if analysis is to parse and analyzer function bodies |
| */ |
| bool get analyzeFunctionBodies; |
| |
| /** |
| * Return the maximum number of sources for which AST structures should be kept in the cache. |
| * |
| * @return the maximum number of sources for which AST structures should be kept in the cache |
| */ |
| int get cacheSize; |
| |
| /** |
| * Return `true` if analysis is to generate dart2js related hint results. |
| * |
| * @return `true` if analysis is to generate dart2js related hint results |
| */ |
| bool get dart2jsHint; |
| |
| /** |
| * Return `true` if analysis is to include the new async support. |
| */ |
| @deprecated |
| bool get enableAsync; |
| |
| /** |
| * Return `true` if analysis is to include the new deferred loading support. |
| * |
| * @return `true` if analysis is to include the new deferred loading support |
| */ |
| @deprecated |
| bool get enableDeferredLoading; |
| |
| /** |
| * Return `true` if analysis is to include the new enum support. |
| * |
| * @return `true` if analysis is to include the new enum support |
| */ |
| @deprecated |
| bool get enableEnum; |
| |
| /** |
| * Return `true` if errors, warnings and hints should be generated for sources in the SDK. |
| * The default value is `false`. |
| * |
| * @return `true` if errors, warnings and hints should be generated for the SDK |
| */ |
| bool get generateSdkErrors; |
| |
| /** |
| * Return `true` if analysis is to generate hint results (e.g. type inference based |
| * information and pub best practices). |
| * |
| * @return `true` if analysis is to generate hint results |
| */ |
| bool get hint; |
| |
| /** |
| * Return `true` if incremental analysis should be used. |
| * |
| * @return `true` if incremental analysis should be used |
| */ |
| bool get incremental; |
| |
| /** |
| * A flag indicating whether incremental analysis should be used for API |
| * changes. |
| */ |
| bool get incrementalApi; |
| |
| /** |
| * A flag indicating whether validation should be performed after incremental |
| * analysis. |
| */ |
| bool get incrementalValidation; |
| |
| /** |
| * Return `true` if analysis is to generate lint warnings. |
| * |
| * @return `true` if analysis is to generate lint warnings |
| */ |
| bool get lint; |
| |
| /** |
| * Return `true` if analysis is to parse comments. |
| * |
| * @return `true` if analysis is to parse comments |
| */ |
| bool get preserveComments; |
| } |
| |
| /** |
| * Instances of the class `AnalysisOptions` represent a set of analysis options used to |
| * control the behavior of an analysis context. |
| */ |
| class AnalysisOptionsImpl implements AnalysisOptions { |
| /** |
| * The maximum number of sources for which data should be kept in the cache. |
| */ |
| static const int DEFAULT_CACHE_SIZE = 64; |
| |
| /** |
| * The default value for enabling deferred loading. |
| */ |
| @deprecated |
| static bool DEFAULT_ENABLE_DEFERRED_LOADING = true; |
| |
| /** |
| * The default value for enabling enum support. |
| */ |
| @deprecated |
| static bool DEFAULT_ENABLE_ENUM = false; |
| |
| /** |
| * A flag indicating whether analysis is to parse and analyze function bodies. |
| */ |
| bool analyzeFunctionBodies = true; |
| |
| /** |
| * The maximum number of sources for which AST structures should be kept in the cache. |
| */ |
| int cacheSize = DEFAULT_CACHE_SIZE; |
| |
| /** |
| * A flag indicating whether analysis is to generate dart2js related hint results. |
| */ |
| bool dart2jsHint = true; |
| |
| /** |
| * A flag indicating whether errors, warnings and hints should be generated for sources in the |
| * SDK. |
| */ |
| bool _generateSdkErrors = false; |
| |
| /** |
| * A flag indicating whether analysis is to generate hint results (e.g. type inference based |
| * information and pub best practices). |
| */ |
| bool hint = true; |
| |
| /** |
| * A flag indicating whether incremental analysis should be used. |
| */ |
| bool incremental = false; |
| |
| /** |
| * A flag indicating whether incremental analysis should be used for API |
| * changes. |
| */ |
| bool incrementalApi = false; |
| |
| /** |
| * A flag indicating whether validation should be performed after incremental |
| * analysis. |
| */ |
| bool incrementalValidation = false; |
| |
| /** |
| * A flag indicating whether analysis is to generate lint warnings. |
| */ |
| bool lint = false; |
| |
| /** |
| * A flag indicating whether analysis is to parse comments. |
| */ |
| bool preserveComments = true; |
| |
| /** |
| * Initialize a newly created set of analysis options to have their default values. |
| */ |
| AnalysisOptionsImpl(); |
| |
| /** |
| * Initialize a newly created set of analysis options to have the same values as those in the |
| * given set of analysis options. |
| * |
| * @param options the analysis options whose values are being copied |
| */ |
| AnalysisOptionsImpl.con1(AnalysisOptions options) { |
| analyzeFunctionBodies = options.analyzeFunctionBodies; |
| cacheSize = options.cacheSize; |
| dart2jsHint = options.dart2jsHint; |
| _generateSdkErrors = options.generateSdkErrors; |
| hint = options.hint; |
| incremental = options.incremental; |
| incrementalApi = options.incrementalApi; |
| incrementalValidation = options.incrementalValidation; |
| lint = options.lint; |
| preserveComments = options.preserveComments; |
| } |
| |
| @deprecated |
| @override |
| bool get enableAsync => true; |
| |
| @deprecated |
| void set enableAsync(bool enable) { |
| // Async support cannot be disabled |
| } |
| |
| @deprecated |
| @override |
| bool get enableDeferredLoading => true; |
| |
| @deprecated |
| void set enableDeferredLoading(bool enable) { |
| // Deferred loading support cannot be disabled |
| } |
| |
| @deprecated |
| @override |
| bool get enableEnum => true; |
| |
| @deprecated |
| void set enableEnum(bool enable) { |
| // Enum support cannot be disabled |
| } |
| |
| @override |
| bool get generateSdkErrors => _generateSdkErrors; |
| |
| /** |
| * Set whether errors, warnings and hints should be generated for sources in the SDK to match the |
| * given value. |
| * |
| * @param generate `true` if errors, warnings and hints should be generated for sources in |
| * the SDK |
| */ |
| void set generateSdkErrors(bool generate) { |
| _generateSdkErrors = generate; |
| } |
| } |
| |
| /** |
| * Instances of the class `AnalysisResult` |
| */ |
| class AnalysisResult { |
| /** |
| * The change notices associated with this result, or `null` if there were no changes and |
| * there is no more work to be done. |
| */ |
| final List<ChangeNotice> _notices; |
| |
| /** |
| * The number of milliseconds required to determine which task was to be performed. |
| */ |
| final int getTime; |
| |
| /** |
| * The name of the class of the task that was performed. |
| */ |
| final String taskClassName; |
| |
| /** |
| * The number of milliseconds required to perform the task. |
| */ |
| final int performTime; |
| |
| /** |
| * Initialize a newly created analysis result to have the given values. |
| * |
| * @param notices the change notices associated with this result |
| * @param getTime the number of milliseconds required to determine which task was to be performed |
| * @param taskClassName the name of the class of the task that was performed |
| * @param performTime the number of milliseconds required to perform the task |
| */ |
| AnalysisResult(this._notices, this.getTime, this.taskClassName, |
| this.performTime); |
| |
| /** |
| * Return the change notices associated with this result, or `null` if there were no changes |
| * and there is no more work to be done. |
| * |
| * @return the change notices associated with this result |
| */ |
| List<ChangeNotice> get changeNotices => _notices; |
| |
| /** |
| * Return `true` if there is more to be performed after the task that was performed. |
| * |
| * @return `true` if there is more to be performed after the task that was performed |
| */ |
| bool get hasMoreWork => _notices != null; |
| } |
| |
| /** |
| * The abstract class `AnalysisTask` defines the behavior of objects used to perform an |
| * analysis task. |
| */ |
| abstract class AnalysisTask { |
| /** |
| * The context in which the task is to be performed. |
| */ |
| final InternalAnalysisContext context; |
| |
| /** |
| * The exception that was thrown while performing this task, or `null` if the task completed |
| * successfully. |
| */ |
| CaughtException _thrownException; |
| |
| /** |
| * Initialize a newly created task to perform analysis within the given context. |
| * |
| * @param context the context in which the task is to be performed |
| */ |
| AnalysisTask(this.context); |
| |
| /** |
| * Return the exception that was thrown while performing this task, or `null` if the task |
| * completed successfully. |
| * |
| * @return the exception that was thrown while performing this task |
| */ |
| CaughtException get exception => _thrownException; |
| |
| /** |
| * Return a textual description of this task. |
| * |
| * @return a textual description of this task |
| */ |
| String get taskDescription; |
| |
| /** |
| * Use the given visitor to visit this task. |
| * |
| * @param visitor the visitor that should be used to visit this task |
| * @return the value returned by the visitor |
| * @throws AnalysisException if the visitor throws the exception |
| */ |
| accept(AnalysisTaskVisitor visitor); |
| |
| /** |
| * Perform this analysis task, protected by an exception handler. |
| * |
| * @throws AnalysisException if an exception occurs while performing the task |
| */ |
| void internalPerform(); |
| |
| /** |
| * Perform this analysis task and use the given visitor to visit this task after it has completed. |
| * |
| * @param visitor the visitor used to visit this task after it has completed |
| * @return the value returned by the visitor |
| * @throws AnalysisException if the visitor throws the exception |
| */ |
| Object perform(AnalysisTaskVisitor visitor) { |
| try { |
| _safelyPerform(); |
| } on AnalysisException catch (exception, stackTrace) { |
| _thrownException = new CaughtException(exception, stackTrace); |
| AnalysisEngine.instance.logger.logInformation( |
| "Task failed: $taskDescription", |
| new CaughtException(exception, stackTrace)); |
| } |
| return accept(visitor); |
| } |
| |
| @override |
| String toString() => taskDescription; |
| |
| /** |
| * Perform this analysis task, ensuring that all exceptions are wrapped in an |
| * [AnalysisException]. |
| * |
| * @throws AnalysisException if any exception occurs while performing the task |
| */ |
| void _safelyPerform() { |
| try { |
| internalPerform(); |
| } on AnalysisException catch (exception) { |
| throw exception; |
| } catch (exception, stackTrace) { |
| throw new AnalysisException( |
| exception.toString(), |
| new CaughtException(exception, stackTrace)); |
| } |
| } |
| } |
| |
| /** |
| * An `AnalysisTaskVisitor` visits tasks. While tasks are not structured in any |
| * interesting way, this class provides the ability to dispatch to an |
| * appropriate method. |
| */ |
| abstract class AnalysisTaskVisitor<E> { |
| /** |
| * Visit the given [task], returning the result of the visit. This method will |
| * throw an AnalysisException if the visitor throws an exception. |
| */ |
| E visitBuildUnitElementTask(BuildUnitElementTask task); |
| |
| /** |
| * Visit the given [task], returning the result of the visit. This method will |
| * throw an AnalysisException if the visitor throws an exception. |
| */ |
| E visitGenerateDartErrorsTask(GenerateDartErrorsTask task); |
| |
| /** |
| * Visit the given [task], returning the result of the visit. This method will |
| * throw an AnalysisException if the visitor throws an exception. |
| */ |
| E visitGenerateDartHintsTask(GenerateDartHintsTask task); |
| |
| /** |
| * Visit the given [task], returning the result of the visit. This method will |
| * throw an AnalysisException if the visitor throws an exception. |
| */ |
| E visitGenerateDartLintsTask(GenerateDartLintsTask task); |
| |
| /** |
| * Visit the given [task], returning the result of the visit. This method will |
| * throw an AnalysisException if the visitor throws an exception. |
| */ |
| E visitGetContentTask(GetContentTask task); |
| |
| /** |
| * Visit the given [task], returning the result of the visit. This method will |
| * throw an AnalysisException if the visitor throws an exception. |
| */ |
| E |
| visitIncrementalAnalysisTask(IncrementalAnalysisTask incrementalAnalysisTask); |
| |
| /** |
| * Visit the given [task], returning the result of the visit. This method will |
| * throw an AnalysisException if the visitor throws an exception. |
| */ |
| E visitParseDartTask(ParseDartTask task); |
| |
| /** |
| * Visit the given [task], returning the result of the visit. This method will |
| * throw an AnalysisException if the visitor throws an exception. |
| */ |
| E visitParseHtmlTask(ParseHtmlTask task); |
| |
| /** |
| * Visit the given [task], returning the result of the visit. This method will |
| * throw an AnalysisException if the visitor throws an exception. |
| */ |
| E visitResolveDartLibraryCycleTask(ResolveDartLibraryCycleTask task); |
| |
| /** |
| * Visit the given [task], returning the result of the visit. This method will |
| * throw an AnalysisException if the visitor throws an exception. |
| */ |
| E visitResolveDartLibraryTask(ResolveDartLibraryTask task); |
| |
| /** |
| * Visit the given [task], returning the result of the visit. This method will |
| * throw an AnalysisException if the visitor throws an exception. |
| */ |
| E visitResolveDartUnitTask(ResolveDartUnitTask task); |
| |
| /** |
| * Visit the given [task], returning the result of the visit. This method will |
| * throw an AnalysisException if the visitor throws an exception. |
| */ |
| E visitResolveHtmlTask(ResolveHtmlTask task); |
| |
| /** |
| * Visit the given [task], returning the result of the visit. This method will |
| * throw an AnalysisException if the visitor throws an exception. |
| */ |
| E visitScanDartTask(ScanDartTask task); |
| } |
| |
| /** |
| * A `CachedResult` is a single analysis result that is stored in a |
| * [SourceEntry]. |
| */ |
| class CachedResult<E> { |
| /** |
| * The state of the cached value. |
| */ |
| CacheState state; |
| |
| /** |
| * The value being cached, or `null` if there is no value (for example, when |
| * the [state] is [CacheState.INVALID]. |
| */ |
| E value; |
| |
| /** |
| * Initialize a newly created result holder to represent the value of data |
| * described by the given [descriptor]. |
| */ |
| CachedResult(DataDescriptor descriptor) { |
| state = CacheState.INVALID; |
| value = descriptor.defaultValue; |
| } |
| } |
| |
| /** |
| * Instances of the class `CachePartition` implement a single partition in an LRU cache of |
| * information related to analysis. |
| */ |
| abstract class CachePartition { |
| /** |
| * The context that owns this partition. Multiple contexts can reference a partition, but only one |
| * context can own it. |
| */ |
| final InternalAnalysisContext context; |
| |
| /** |
| * The maximum number of sources for which AST structures should be kept in the cache. |
| */ |
| int _maxCacheSize = 0; |
| |
| /** |
| * The policy used to determine which pieces of data to remove from the cache. |
| */ |
| final CacheRetentionPolicy _retentionPolicy; |
| |
| /** |
| * A table mapping the sources belonging to this partition to the information known about those |
| * sources. |
| */ |
| HashMap<Source, SourceEntry> _sourceMap = new HashMap<Source, SourceEntry>(); |
| |
| /** |
| * A list containing the most recently accessed sources with the most recently used at the end of |
| * the list. When more sources are added than the maximum allowed then the least recently used |
| * source will be removed and will have it's cached AST structure flushed. |
| */ |
| List<Source> _recentlyUsed; |
| |
| /** |
| * Initialize a newly created cache to maintain at most the given number of AST structures in the |
| * cache. |
| * |
| * @param context the context that owns this partition |
| * @param maxCacheSize the maximum number of sources for which AST structures should be kept in |
| * the cache |
| * @param retentionPolicy the policy used to determine which pieces of data to remove from the |
| * cache |
| */ |
| CachePartition(this.context, int maxCacheSize, this._retentionPolicy) { |
| this._maxCacheSize = maxCacheSize; |
| _recentlyUsed = new List<Source>(); |
| } |
| |
| /** |
| * Return the number of entries in this partition that have an AST associated with them. |
| * |
| * @return the number of entries in this partition that have an AST associated with them |
| */ |
| int get astSize { |
| int astSize = 0; |
| int count = _recentlyUsed.length; |
| for (int i = 0; i < count; i++) { |
| Source source = _recentlyUsed[i]; |
| SourceEntry sourceEntry = _sourceMap[source]; |
| if (sourceEntry is DartEntry) { |
| if (sourceEntry.anyParsedCompilationUnit != null) { |
| astSize++; |
| } |
| } else if (sourceEntry is HtmlEntry) { |
| if (sourceEntry.anyParsedUnit != null) { |
| astSize++; |
| } |
| } |
| } |
| return astSize; |
| } |
| |
| /** |
| * Return a table mapping the sources known to the context to the information known about the |
| * source. |
| * |
| * <b>Note:</b> This method is only visible for use by [AnalysisCache] and should not be |
| * used for any other purpose. |
| * |
| * @return a table mapping the sources known to the context to the information known about the |
| * source |
| */ |
| Map<Source, SourceEntry> get map => _sourceMap; |
| |
| /** |
| * Set the maximum size of the cache to the given size. |
| * |
| * @param size the maximum number of sources for which AST structures should be kept in the cache |
| */ |
| void set maxCacheSize(int size) { |
| _maxCacheSize = size; |
| while (_recentlyUsed.length > _maxCacheSize) { |
| if (!_flushAstFromCache()) { |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Record that the AST associated with the given source was just read from the cache. |
| * |
| * @param source the source whose AST was accessed |
| */ |
| void accessedAst(Source source) { |
| if (_recentlyUsed.remove(source)) { |
| _recentlyUsed.add(source); |
| return; |
| } |
| while (_recentlyUsed.length >= _maxCacheSize) { |
| if (!_flushAstFromCache()) { |
| break; |
| } |
| } |
| _recentlyUsed.add(source); |
| } |
| |
| /** |
| * Return `true` if the given source is contained in this partition. |
| * |
| * @param source the source being tested |
| * @return `true` if the source is contained in this partition |
| */ |
| bool contains(Source source); |
| |
| /** |
| * Return the entry associated with the given source. |
| * |
| * @param source the source whose entry is to be returned |
| * @return the entry associated with the given source |
| */ |
| SourceEntry get(Source source) => _sourceMap[source]; |
| |
| /** |
| * Return an iterator returning all of the map entries mapping sources to cache entries. |
| * |
| * @return an iterator returning all of the map entries mapping sources to cache entries |
| */ |
| MapIterator<Source, SourceEntry> iterator() => |
| new SingleMapIterator<Source, SourceEntry>(_sourceMap); |
| |
| /** |
| * Associate the given entry with the given source. |
| * |
| * @param source the source with which the entry is to be associated |
| * @param entry the entry to be associated with the source |
| */ |
| void put(Source source, SourceEntry entry) { |
| entry.fixExceptionState(); |
| _sourceMap[source] = entry; |
| } |
| |
| /** |
| * Remove all information related to the given source from this cache. |
| * |
| * @param source the source to be removed |
| */ |
| void remove(Source source) { |
| _recentlyUsed.remove(source); |
| _sourceMap.remove(source); |
| } |
| |
| /** |
| * Record that the AST associated with the given source was just removed from the cache. |
| * |
| * @param source the source whose AST was removed |
| */ |
| void removedAst(Source source) { |
| _recentlyUsed.remove(source); |
| } |
| |
| /** |
| * Return the number of sources that are mapped to cache entries. |
| * |
| * @return the number of sources that are mapped to cache entries |
| */ |
| int size() => _sourceMap.length; |
| |
| /** |
| * Record that the AST associated with the given source was just stored to the cache. |
| * |
| * @param source the source whose AST was stored |
| */ |
| void storedAst(Source source) { |
| if (_recentlyUsed.contains(source)) { |
| return; |
| } |
| while (_recentlyUsed.length >= _maxCacheSize) { |
| if (!_flushAstFromCache()) { |
| break; |
| } |
| } |
| _recentlyUsed.add(source); |
| } |
| |
| /** |
| * Attempt to flush one AST structure from the cache. |
| * |
| * @return `true` if a structure was flushed |
| */ |
| bool _flushAstFromCache() { |
| Source removedSource = _removeAstToFlush(); |
| if (removedSource == null) { |
| return false; |
| } |
| SourceEntry sourceEntry = _sourceMap[removedSource]; |
| if (sourceEntry is HtmlEntry) { |
| HtmlEntry htmlEntry = sourceEntry; |
| htmlEntry.flushAstStructures(); |
| } else if (sourceEntry is DartEntry) { |
| DartEntry dartEntry = sourceEntry; |
| dartEntry.flushAstStructures(); |
| } |
| return true; |
| } |
| |
| /** |
| * Remove and return one source from the list of recently used sources whose AST structure can be |
| * flushed from the cache. The source that will be returned will be the source that has been |
| * unreferenced for the longest period of time but that is not a priority for analysis. |
| * |
| * @return the source that was removed |
| */ |
| Source _removeAstToFlush() { |
| int sourceToRemove = -1; |
| for (int i = 0; i < _recentlyUsed.length; i++) { |
| Source source = _recentlyUsed[i]; |
| RetentionPriority priority = |
| _retentionPolicy.getAstPriority(source, _sourceMap[source]); |
| if (priority == RetentionPriority.LOW) { |
| return _recentlyUsed.removeAt(i); |
| } else if (priority == RetentionPriority.MEDIUM && sourceToRemove < 0) { |
| sourceToRemove = i; |
| } |
| } |
| if (sourceToRemove < 0) { |
| // This happens if the retention policy returns a priority of HIGH for all |
| // of the sources that have been recently used. This is the case, for |
| // example, when the list of priority sources is bigger than the current |
| // cache size. |
| return null; |
| } |
| return _recentlyUsed.removeAt(sourceToRemove); |
| } |
| } |
| |
| /** |
| * Instances of the class `CacheRetentionPolicy` define the behavior of objects that determine |
| * how important it is for data to be retained in the analysis cache. |
| */ |
| abstract class CacheRetentionPolicy { |
| /** |
| * Return the priority of retaining the AST structure for the given source. |
| * |
| * @param source the source whose AST structure is being considered for removal |
| * @param sourceEntry the entry representing the source |
| * @return the priority of retaining the AST structure for the given source |
| */ |
| RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry); |
| } |
| |
| /** |
| * The enumeration `CacheState` defines the possible states of cached data. |
| */ |
| class CacheState extends Enum<CacheState> { |
| /** |
| * The data is not in the cache and the last time an attempt was made to compute the data an |
| * exception occurred, making it pointless to attempt. |
| * |
| * Valid Transitions: |
| * * [INVALID] if a source was modified that might cause the data to be computable |
| */ |
| static const CacheState ERROR = const CacheState('ERROR', 0); |
| |
| /** |
| * The data is not in the cache because it was flushed from the cache in order to control memory |
| * usage. If the data is recomputed, results do not need to be reported. |
| * |
| * Valid Transitions: |
| * * [IN_PROCESS] if the data is being recomputed |
| * * [INVALID] if a source was modified that causes the data to need to be recomputed |
| */ |
| static const CacheState FLUSHED = const CacheState('FLUSHED', 1); |
| |
| /** |
| * The data might or might not be in the cache but is in the process of being recomputed. |
| * |
| * Valid Transitions: |
| * * [ERROR] if an exception occurred while trying to compute the data |
| * * [VALID] if the data was successfully computed and stored in the cache |
| */ |
| static const CacheState IN_PROCESS = const CacheState('IN_PROCESS', 2); |
| |
| /** |
| * The data is not in the cache and needs to be recomputed so that results can be reported. |
| * |
| * Valid Transitions: |
| * * [IN_PROCESS] if an attempt is being made to recompute the data |
| */ |
| static const CacheState INVALID = const CacheState('INVALID', 3); |
| |
| /** |
| * The data is in the cache and up-to-date. |
| * |
| * Valid Transitions: |
| * * [FLUSHED] if the data is removed in order to manage memory usage |
| * * [INVALID] if a source was modified in such a way as to invalidate the previous data |
| */ |
| static const CacheState VALID = const CacheState('VALID', 4); |
| |
| static const List<CacheState> values = const [ |
| ERROR, |
| FLUSHED, |
| IN_PROCESS, |
| INVALID, |
| VALID]; |
| |
| const CacheState(String name, int ordinal) : super(name, ordinal); |
| } |
| |
| /** |
| * An object that represents a change to the analysis results associated with a |
| * given source. |
| */ |
| abstract class ChangeNotice implements AnalysisErrorInfo { |
| /** |
| * The parsed, but maybe not resolved Dart AST that changed as a result of |
| * the analysis, or `null` if the AST was not changed. |
| */ |
| CompilationUnit get parsedDartUnit; |
| |
| /** |
| * The fully resolved Dart AST that changed as a result of the analysis, or |
| * `null` if the AST was not changed. |
| */ |
| CompilationUnit get resolvedDartUnit; |
| |
| /** |
| * The fully resolved HTML AST that changed as a result of the analysis, or |
| * `null` if the AST was not changed. |
| */ |
| ht.HtmlUnit get resolvedHtmlUnit; |
| |
| /** |
| * Return the source for which the result is being reported. |
| */ |
| Source get source; |
| } |
| |
| /** |
| * An implementation of a [ChangeNotice]. |
| */ |
| class ChangeNoticeImpl implements ChangeNotice { |
| /** |
| * An empty list of change notices. |
| */ |
| static const List<ChangeNoticeImpl> EMPTY_ARRAY = const <ChangeNoticeImpl>[]; |
| |
| /** |
| * The source for which the result is being reported. |
| */ |
| final Source source; |
| |
| /** |
| * The parsed, but maybe not resolved Dart AST that changed as a result of |
| * the analysis, or `null` if the AST was not changed. |
| */ |
| CompilationUnit parsedDartUnit; |
| |
| /** |
| * The fully resolved Dart AST that changed as a result of the analysis, or |
| * `null` if the AST was not changed. |
| */ |
| CompilationUnit resolvedDartUnit; |
| |
| /** |
| * The fully resolved HTML AST that changed as a result of the analysis, or |
| * `null` if the AST was not changed. |
| */ |
| ht.HtmlUnit resolvedHtmlUnit; |
| |
| /** |
| * The errors that changed as a result of the analysis, or `null` if errors |
| * were not changed. |
| */ |
| List<AnalysisError> _errors; |
| |
| /** |
| * The line information associated with the source, or `null` if errors were |
| * not changed. |
| */ |
| LineInfo _lineInfo; |
| |
| /** |
| * Initialize a newly created notice associated with the given source. |
| * |
| * @param source the source for which the change is being reported |
| */ |
| ChangeNoticeImpl(this.source); |
| |
| @override |
| List<AnalysisError> get errors => _errors; |
| |
| @override |
| LineInfo get lineInfo => _lineInfo; |
| |
| /** |
| * Set the errors that changed as a result of the analysis to the given |
| * [errors] and set the line information to the given [lineInfo]. |
| */ |
| void setErrors(List<AnalysisError> errors, LineInfo lineInfo) { |
| this._errors = errors; |
| this._lineInfo = lineInfo; |
| if (lineInfo == null) { |
| AnalysisEngine.instance.logger.logInformation( |
| "No line info: $source", |
| new CaughtException(new AnalysisException(), null)); |
| } |
| } |
| |
| @override |
| String toString() => "Changes for ${source.fullName}"; |
| } |
| |
| /** |
| * Instances of the class `ChangeSet` indicate which sources have been added, changed, |
| * removed, or deleted. In the case of a changed source, there are multiple ways of indicating the |
| * nature of the change. |
| * |
| * No source should be added to the change set more than once, either with the same or a different |
| * kind of change. It does not make sense, for example, for a source to be both added and removed, |
| * and it is redundant for a source to be marked as changed in its entirety and changed in some |
| * specific range. |
| */ |
| class ChangeSet { |
| /** |
| * A list containing the sources that have been added. |
| */ |
| final List<Source> addedSources = new List<Source>(); |
| |
| /** |
| * A list containing the sources that have been changed. |
| */ |
| final List<Source> changedSources = new List<Source>(); |
| |
| /** |
| * A table mapping the sources whose content has been changed to the current content of those |
| * sources. |
| */ |
| HashMap<Source, String> _changedContent = new HashMap<Source, String>(); |
| |
| /** |
| * A table mapping the sources whose content has been changed within a single range to the current |
| * content of those sources and information about the affected range. |
| */ |
| final HashMap<Source, ChangeSet_ContentChange> changedRanges = |
| new HashMap<Source, ChangeSet_ContentChange>(); |
| |
| /** |
| * A list containing the sources that have been removed. |
| */ |
| final List<Source> removedSources = new List<Source>(); |
| |
| /** |
| * A list containing the source containers specifying additional sources that have been removed. |
| */ |
| final List<SourceContainer> removedContainers = new List<SourceContainer>(); |
| |
| /** |
| * A list containing the sources that have been deleted. |
| */ |
| final List<Source> deletedSources = new List<Source>(); |
| |
| /** |
| * Return a table mapping the sources whose content has been changed to the current content of |
| * those sources. |
| * |
| * @return a table mapping the sources whose content has been changed to the current content of |
| * those sources |
| */ |
| Map<Source, String> get changedContents => _changedContent; |
| |
| /** |
| * Return `true` if this change set does not contain any changes. |
| * |
| * @return `true` if this change set does not contain any changes |
| */ |
| bool get isEmpty => |
| addedSources.isEmpty && |
| changedSources.isEmpty && |
| _changedContent.isEmpty && |
| changedRanges.isEmpty && |
| removedSources.isEmpty && |
| removedContainers.isEmpty && |
| deletedSources.isEmpty; |
| |
| /** |
| * Record that the specified source has been added and that its content is the default contents of |
| * the source. |
| * |
| * @param source the source that was added |
| */ |
| void addedSource(Source source) { |
| addedSources.add(source); |
| } |
| |
| /** |
| * Record that the specified source has been changed and that its content is the given contents. |
| * |
| * @param source the source that was changed |
| * @param contents the new contents of the source, or `null` if the default contents of the |
| * source are to be used |
| */ |
| void changedContent(Source source, String contents) { |
| _changedContent[source] = contents; |
| } |
| |
| /** |
| * Record that the specified source has been changed and that its content is the given contents. |
| * |
| * @param source the source that was changed |
| * @param contents the new contents of the source |
| * @param offset the offset into the current contents |
| * @param oldLength the number of characters in the original contents that were replaced |
| * @param newLength the number of characters in the replacement text |
| */ |
| void changedRange(Source source, String contents, int offset, int oldLength, |
| int newLength) { |
| changedRanges[source] = |
| new ChangeSet_ContentChange(contents, offset, oldLength, newLength); |
| } |
| |
| /** |
| * Record that the specified source has been changed. If the content of the source was previously |
| * overridden, this has no effect (the content remains overridden). To cancel (or change) the |
| * override, use [changedContent] instead. |
| * |
| * @param source the source that was changed |
| */ |
| void changedSource(Source source) { |
| changedSources.add(source); |
| } |
| |
| /** |
| * Record that the specified source has been deleted. |
| * |
| * @param source the source that was deleted |
| */ |
| void deletedSource(Source source) { |
| deletedSources.add(source); |
| } |
| |
| /** |
| * Record that the specified source container has been removed. |
| * |
| * @param container the source container that was removed |
| */ |
| void removedContainer(SourceContainer container) { |
| if (container != null) { |
| removedContainers.add(container); |
| } |
| } |
| |
| /** |
| * Record that the specified source has been removed. |
| * |
| * @param source the source that was removed |
| */ |
| void removedSource(Source source) { |
| if (source != null) { |
| removedSources.add(source); |
| } |
| } |
| |
| @override |
| String toString() { |
| StringBuffer buffer = new StringBuffer(); |
| bool needsSeparator = |
| _appendSources(buffer, addedSources, false, "addedSources"); |
| needsSeparator = |
| _appendSources(buffer, changedSources, needsSeparator, "changedSources"); |
| needsSeparator = |
| _appendSources2(buffer, _changedContent, needsSeparator, "changedContent"); |
| needsSeparator = |
| _appendSources2(buffer, changedRanges, needsSeparator, "changedRanges"); |
| needsSeparator = |
| _appendSources(buffer, deletedSources, needsSeparator, "deletedSources"); |
| needsSeparator = |
| _appendSources(buffer, removedSources, needsSeparator, "removedSources"); |
| int count = removedContainers.length; |
| if (count > 0) { |
| if (removedSources.isEmpty) { |
| if (needsSeparator) { |
| buffer.write("; "); |
| } |
| buffer.write("removed: from "); |
| buffer.write(count); |
| buffer.write(" containers"); |
| } else { |
| buffer.write(", and more from "); |
| buffer.write(count); |
| buffer.write(" containers"); |
| } |
| } |
| return buffer.toString(); |
| } |
| |
| /** |
| * Append the given sources to the given builder, prefixed with the given label and possibly a |
| * separator. |
| * |
| * @param builder the builder to which the sources are to be appended |
| * @param sources the sources to be appended |
| * @param needsSeparator `true` if a separator is needed before the label |
| * @param label the label used to prefix the sources |
| * @return `true` if future lists of sources will need a separator |
| */ |
| bool _appendSources(StringBuffer buffer, List<Source> sources, |
| bool needsSeparator, String label) { |
| if (sources.isEmpty) { |
| return needsSeparator; |
| } |
| if (needsSeparator) { |
| buffer.write("; "); |
| } |
| buffer.write(label); |
| String prefix = " "; |
| for (Source source in sources) { |
| buffer.write(prefix); |
| buffer.write(source.fullName); |
| prefix = ", "; |
| } |
| return true; |
| } |
| |
| /** |
| * Append the given sources to the given builder, prefixed with the given label and possibly a |
| * separator. |
| * |
| * @param builder the builder to which the sources are to be appended |
| * @param sources the sources to be appended |
| * @param needsSeparator `true` if a separator is needed before the label |
| * @param label the label used to prefix the sources |
| * @return `true` if future lists of sources will need a separator |
| */ |
| bool _appendSources2(StringBuffer buffer, HashMap<Source, dynamic> sources, |
| bool needsSeparator, String label) { |
| if (sources.isEmpty) { |
| return needsSeparator; |
| } |
| if (needsSeparator) { |
| buffer.write("; "); |
| } |
| buffer.write(label); |
| String prefix = " "; |
| for (Source source in sources.keys.toSet()) { |
| buffer.write(prefix); |
| buffer.write(source.fullName); |
| prefix = ", "; |
| } |
| return true; |
| } |
| } |
| |
| /** |
| * Instances of the class `ContentChange` represent a change to the content of a source. |
| */ |
| class ChangeSet_ContentChange { |
| /** |
| * The new contents of the source. |
| */ |
| final String contents; |
| |
| /** |
| * The offset into the current contents. |
| */ |
| final int offset; |
| |
| /** |
| * The number of characters in the original contents that were replaced |
| */ |
| final int oldLength; |
| |
| /** |
| * The number of characters in the replacement text. |
| */ |
| final int newLength; |
| |
| /** |
| * Initialize a newly created change object to represent a change to the content of a source. |
| * |
| * @param contents the new contents of the source |
| * @param offset the offset into the current contents |
| * @param oldLength the number of characters in the original contents that were replaced |
| * @param newLength the number of characters in the replacement text |
| */ |
| ChangeSet_ContentChange(this.contents, this.offset, this.oldLength, |
| this.newLength); |
| } |
| |
| /** |
| * Instances of the class `LibraryPair` hold a library and a list of the (source, entry) |
| * pairs for compilation units in the library. |
| */ |
| class CycleBuilder_LibraryPair { |
| /** |
| * The library containing the compilation units. |
| */ |
| ResolvableLibrary library; |
| |
| /** |
| * The (source, entry) pairs representing the compilation units in the library. |
| */ |
| List<CycleBuilder_SourceEntryPair> entryPairs; |
| |
| /** |
| * Initialize a newly created pair. |
| * |
| * @param library the library containing the compilation units |
| * @param entryPairs the (source, entry) pairs representing the compilation units in the |
| * library |
| */ |
| CycleBuilder_LibraryPair(ResolvableLibrary library, |
| List<CycleBuilder_SourceEntryPair> entryPairs) { |
| this.library = library; |
| this.entryPairs = entryPairs; |
| } |
| } |
| |
| /** |
| * Instances of the class `SourceEntryPair` hold a source and the cache entry associated |
| * with that source. They are used to reduce the number of times an entry must be looked up in |
| * the [cache]. |
| */ |
| class CycleBuilder_SourceEntryPair { |
| /** |
| * The source associated with the entry. |
| */ |
| Source source; |
| |
| /** |
| * The entry associated with the source. |
| */ |
| DartEntry entry; |
| |
| /** |
| * Initialize a newly created pair. |
| * |
| * @param source the source associated with the entry |
| * @param entry the entry associated with the source |
| */ |
| CycleBuilder_SourceEntryPair(Source source, DartEntry entry) { |
| this.source = source; |
| this.entry = entry; |
| } |
| } |
| |
| /** |
| * A `DartEntry` maintains the information cached by an analysis context about |
| * an individual Dart file. |
| */ |
| class DartEntry extends SourceEntry { |
| /** |
| * The data descriptor representing the element model representing a single |
| * compilation unit. This model is incomplete and should not be used except as |
| * input to another task. |
| */ |
| static final DataDescriptor<List<AnalysisError>> BUILT_ELEMENT = |
| new DataDescriptor<List<AnalysisError>>("DartEntry.BUILT_ELEMENT"); |
| |
| /** |
| * The data descriptor representing the AST structure after the element model |
| * has been built (and declarations are resolved) but before other resolution |
| * has been performed. |
| */ |
| static final DataDescriptor<CompilationUnit> BUILT_UNIT = |
| new DataDescriptor<CompilationUnit>("DartEntry.BUILT_UNIT"); |
| |
| /** |
| * The data descriptor representing the list of libraries that contain this |
| * compilation unit. |
| */ |
| static final DataDescriptor<List<Source>> CONTAINING_LIBRARIES = |
| new DataDescriptor<List<Source>>( |
| "DartEntry.CONTAINING_LIBRARIES", |
| Source.EMPTY_ARRAY); |
| |
| /** |
| * The data descriptor representing the library element for the library. This |
| * data is only available for Dart files that are the defining compilation |
| * unit of a library. |
| */ |
| static final DataDescriptor<LibraryElement> ELEMENT = |
| new DataDescriptor<LibraryElement>("DartEntry.ELEMENT"); |
| |
| /** |
| * The data descriptor representing the list of exported libraries. This data |
| * is only available for Dart files that are the defining compilation unit of |
| * a library. |
| */ |
| static final DataDescriptor<List<Source>> EXPORTED_LIBRARIES = |
| new DataDescriptor<List<Source>>( |
| "DartEntry.EXPORTED_LIBRARIES", |
| Source.EMPTY_ARRAY); |
| |
| /** |
| * The data descriptor representing the hints resulting from auditing the |
| * source. |
| */ |
| static final DataDescriptor<List<AnalysisError>> HINTS = |
| new DataDescriptor<List<AnalysisError>>( |
| "DartEntry.HINTS", |
| AnalysisError.NO_ERRORS); |
| |
| /** |
| * The data descriptor representing the list of imported libraries. This data |
| * is only available for Dart files that are the defining compilation unit of |
| * a library. |
| */ |
| static final DataDescriptor<List<Source>> IMPORTED_LIBRARIES = |
| new DataDescriptor<List<Source>>( |
| "DartEntry.IMPORTED_LIBRARIES", |
| Source.EMPTY_ARRAY); |
| |
| /** |
| * The data descriptor representing the list of included parts. This data is |
| * only available for Dart files that are the defining compilation unit of a |
| * library. |
| */ |
| static final DataDescriptor<List<Source>> INCLUDED_PARTS = |
| new DataDescriptor<List<Source>>( |
| "DartEntry.INCLUDED_PARTS", |
| Source.EMPTY_ARRAY); |
| |
| /** |
| * The data descriptor representing the client flag. This data is only |
| * available for Dart files that are the defining compilation unit of a |
| * library. |
| */ |
| static final DataDescriptor<bool> IS_CLIENT = |
| new DataDescriptor<bool>("DartEntry.IS_CLIENT", false); |
| |
| /** |
| * The data descriptor representing the launchable flag. This data is only |
| * available for Dart files that are the defining compilation unit of a |
| * library. |
| */ |
| static final DataDescriptor<bool> IS_LAUNCHABLE = |
| new DataDescriptor<bool>("DartEntry.IS_LAUNCHABLE", false); |
| |
| /** |
| * The data descriptor representing lint warnings resulting from auditing the |
| * source. |
| */ |
| static final DataDescriptor<List<AnalysisError>> LINTS = |
| new DataDescriptor<List<AnalysisError>>( |
| "DartEntry.LINTS", |
| AnalysisError.NO_ERRORS); |
| |
| /** |
| * The data descriptor representing the errors resulting from parsing the |
| * source. |
| */ |
| static final DataDescriptor<List<AnalysisError>> PARSE_ERRORS = |
| new DataDescriptor<List<AnalysisError>>( |
| "DartEntry.PARSE_ERRORS", |
| AnalysisError.NO_ERRORS); |
| |
| /** |
| * The data descriptor representing the parsed AST structure. |
| */ |
| static final DataDescriptor<CompilationUnit> PARSED_UNIT = |
| new DataDescriptor<CompilationUnit>("DartEntry.PARSED_UNIT"); |
| |
| /** |
| * The data descriptor representing the public namespace of the library. This |
| * data is only available for Dart files that are the defining compilation |
| * unit of a library. |
| */ |
| static final DataDescriptor<Namespace> PUBLIC_NAMESPACE = |
| new DataDescriptor<Namespace>("DartEntry.PUBLIC_NAMESPACE"); |
| |
| /** |
| * The data descriptor representing the errors resulting from resolving the |
| * source. |
| */ |
| static final DataDescriptor<List<AnalysisError>> RESOLUTION_ERRORS = |
| new DataDescriptor<List<AnalysisError>>( |
| "DartEntry.RESOLUTION_ERRORS", |
| AnalysisError.NO_ERRORS); |
| |
| /** |
| * The data descriptor representing the resolved AST structure. |
| */ |
| static final DataDescriptor<CompilationUnit> RESOLVED_UNIT = |
| new DataDescriptor<CompilationUnit>("DartEntry.RESOLVED_UNIT"); |
| |
| /** |
| * The data descriptor representing the token stream. |
| */ |
| static final DataDescriptor<List<AnalysisError>> SCAN_ERRORS = |
| new DataDescriptor<List<AnalysisError>>( |
| "DartEntry.SCAN_ERRORS", |
| AnalysisError.NO_ERRORS); |
| |
| /** |
| * The data descriptor representing the source kind. |
| */ |
| static final DataDescriptor<SourceKind> SOURCE_KIND = |
| new DataDescriptor<SourceKind>("DartEntry.SOURCE_KIND", SourceKind.UNKNOWN); |
| |
| /** |
| * The data descriptor representing the token stream. |
| */ |
| static final DataDescriptor<Token> TOKEN_STREAM = |
| new DataDescriptor<Token>("DartEntry.TOKEN_STREAM"); |
| |
| /** |
| * The data descriptor representing the errors resulting from verifying the |
| * source. |
| */ |
| static final DataDescriptor<List<AnalysisError>> VERIFICATION_ERRORS = |
| new DataDescriptor<List<AnalysisError>>( |
| "DartEntry.VERIFICATION_ERRORS", |
| AnalysisError.NO_ERRORS); |
| |
| /** |
| * The list of libraries that contain this compilation unit. The list will be |
| * empty if there are no known libraries that contain this compilation unit. |
| */ |
| List<Source> _containingLibraries = new List<Source>(); |
| |
| /** |
| * The information known as a result of resolving this compilation unit as |
| * part of the library that contains this unit. This field will never be |
| * `null`. |
| */ |
| ResolutionState _resolutionState = new ResolutionState(); |
| |
| /** |
| * Return all of the errors associated with the compilation unit that are |
| * currently cached. |
| */ |
| List<AnalysisError> get allErrors { |
| List<AnalysisError> errors = new List<AnalysisError>(); |
| errors.addAll(getValue(SCAN_ERRORS)); |
| errors.addAll(getValue(PARSE_ERRORS)); |
| ResolutionState state = _resolutionState; |
| while (state != null) { |
| errors.addAll(state.getValue(RESOLUTION_ERRORS)); |
| errors.addAll(state.getValue(VERIFICATION_ERRORS)); |
| errors.addAll(state.getValue(HINTS)); |
| errors.addAll(state.getValue(LINTS)); |
| state = state._nextState; |
| } |
| if (errors.length == 0) { |
| return AnalysisError.NO_ERRORS; |
| } |
| return errors; |
| } |
| |
| /** |
| * Return a valid parsed compilation unit, either an unresolved AST structure |
| * or the result of resolving the AST structure in the context of some library, |
| * or `null` if there is no parsed compilation unit available. |
| */ |
| CompilationUnit get anyParsedCompilationUnit { |
| if (getState(PARSED_UNIT) == CacheState.VALID) { |
| return getValue(PARSED_UNIT); |
| } |
| ResolutionState state = _resolutionState; |
| while (state != null) { |
| if (state.getState(BUILT_UNIT) == CacheState.VALID) { |
| return state.getValue(BUILT_UNIT); |
| } |
| state = state._nextState; |
| } |
| |
| return anyResolvedCompilationUnit; |
| } |
| |
| /** |
| * Return the result of resolving the compilation unit as part of any library, |
| * or `null` if there is no cached resolved compilation unit. |
| */ |
| CompilationUnit get anyResolvedCompilationUnit { |
| ResolutionState state = _resolutionState; |
| while (state != null) { |
| if (state.getState(RESOLVED_UNIT) == CacheState.VALID) { |
| return state.getValue(RESOLVED_UNIT); |
| } |
| state = state._nextState; |
| } |
| return null; |
| } |
| |
| /** |
| * The libraries that are known to contain this part. |
| */ |
| List<Source> get containingLibraries => _containingLibraries; |
| |
| /** |
| * Set the list of libraries that contain this compilation unit to contain |
| * only the given source. This method should only be invoked on entries that |
| * represent a library. |
| * |
| * @param librarySource the source of the single library that the list should contain |
| */ |
| void set containingLibrary(Source librarySource) { |
| _containingLibraries.clear(); |
| _containingLibraries.add(librarySource); |
| } |
| |
| @override |
| List<DataDescriptor> get descriptors { |
| List<DataDescriptor> result = super.descriptors; |
| result.addAll( |
| <DataDescriptor>[ |
| DartEntry.SOURCE_KIND, |
| DartEntry.CONTAINING_LIBRARIES, |
| DartEntry.PARSE_ERRORS, |
| DartEntry.PARSED_UNIT, |
| DartEntry.SCAN_ERRORS, |
| DartEntry.SOURCE_KIND, |
| DartEntry.TOKEN_STREAM]); |
| SourceKind kind = getValue(DartEntry.SOURCE_KIND); |
| if (kind == SourceKind.LIBRARY) { |
| result.addAll( |
| <DataDescriptor>[ |
| DartEntry.ELEMENT, |
| DartEntry.EXPORTED_LIBRARIES, |
| DartEntry.IMPORTED_LIBRARIES, |
| DartEntry.INCLUDED_PARTS, |
| DartEntry.IS_CLIENT, |
| DartEntry.IS_LAUNCHABLE, |
| DartEntry.PUBLIC_NAMESPACE]); |
| } |
| return result; |
| } |
| |
| /** |
| * Return `true` if this entry has an AST structure that can be resolved, even |
| * if it needs to be copied. Returning `true` implies that the method |
| * [resolvableCompilationUnit] will return a non-`null` result. |
| */ |
| bool get hasResolvableCompilationUnit { |
| if (getState(PARSED_UNIT) == CacheState.VALID) { |
| return true; |
| } |
| ResolutionState state = _resolutionState; |
| while (state != null) { |
| if (state.getState(BUILT_UNIT) == CacheState.VALID || |
| state.getState(RESOLVED_UNIT) == CacheState.VALID) { |
| return true; |
| } |
| state = state._nextState; |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Return `true` if this data is safe to use in refactoring. |
| */ |
| bool get isRefactoringSafe { |
| ResolutionState state = _resolutionState; |
| while (state != null) { |
| CacheState resolvedState = state.getState(RESOLVED_UNIT); |
| if (resolvedState != CacheState.VALID && |
| resolvedState != CacheState.FLUSHED) { |
| return false; |
| } |
| state = state._nextState; |
| } |
| return true; |
| } |
| |
| @override |
| SourceKind get kind => getValue(SOURCE_KIND); |
| |
| /** |
| * The library sources containing the receiver's source. |
| */ |
| List<Source> get librariesContaining { |
| ResolutionState state = _resolutionState; |
| List<Source> result = new List<Source>(); |
| while (state != null) { |
| if (state._librarySource != null) { |
| result.add(state._librarySource); |
| } |
| state = state._nextState; |
| } |
| return result; |
| } |
| |
| /** |
| * Get a list of all the library-dependent descriptors for which values may |
| * be stored in this SourceEntry. |
| */ |
| List<DataDescriptor> get libraryDescriptors { |
| return <DataDescriptor>[ |
| DartEntry.BUILT_ELEMENT, |
| DartEntry.BUILT_UNIT, |
| DartEntry.RESOLUTION_ERRORS, |
| DartEntry.RESOLVED_UNIT, |
| DartEntry.VERIFICATION_ERRORS, |
| DartEntry.HINTS, |
| DartEntry.LINTS]; |
| } |
| |
| /** |
| * A compilation unit that has not been accessed by any other client and can |
| * therefore safely be modified by the reconciler, or `null` if the source has |
| * not been parsed. |
| */ |
| CompilationUnit get resolvableCompilationUnit { |
| if (getState(PARSED_UNIT) == CacheState.VALID) { |
| CompilationUnit unit = getValue(PARSED_UNIT); |
| setState(PARSED_UNIT, CacheState.FLUSHED); |
| return unit; |
| } |
| ResolutionState state = _resolutionState; |
| while (state != null) { |
| if (state.getState(BUILT_UNIT) == CacheState.VALID) { |
| // TODO(brianwilkerson) We're cloning the structure to remove any |
| // previous resolution data, but I'm not sure that's necessary. |
| return state.getValue(BUILT_UNIT).accept(new AstCloner()); |
| } |
| if (state.getState(RESOLVED_UNIT) == CacheState.VALID) { |
| return state.getValue(RESOLVED_UNIT).accept(new AstCloner()); |
| } |
| state = state._nextState; |
| } |
| return null; |
| } |
| |
| /** |
| * Add the given [librarySource] to the list of libraries that contain this |
| * part. This method should only be invoked on entries that represent a part. |
| */ |
| void addContainingLibrary(Source librarySource) { |
| _containingLibraries.add(librarySource); |
| } |
| |
| /** |
| * Flush any AST structures being maintained by this entry. |
| */ |
| void flushAstStructures() { |
| _flush(TOKEN_STREAM); |
| _flush(PARSED_UNIT); |
| _resolutionState.flushAstStructures(); |
| } |
| |
| /** |
| * Return the state of the data represented by the given [descriptor] in the |
| * context of the given [librarySource]. |
| */ |
| CacheState getStateInLibrary(DataDescriptor descriptor, |
| Source librarySource) { |
| if (!_isValidLibraryDescriptor(descriptor)) { |
| throw new ArgumentError("Invalid descriptor: $descriptor"); |
| } |
| ResolutionState state = _resolutionState; |
| while (state != null) { |
| if (librarySource == state._librarySource) { |
| return state.getState(descriptor); |
| } |
| state = state._nextState; |
| } |
| return CacheState.INVALID; |
| } |
| |
| /** |
| * Return the value of the data represented by the given [descriptor] in the |
| * context of the given [librarySource], or `null` if the data represented by |
| * the descriptor is not in the cache. |
| */ |
| Object getValueInLibrary(DataDescriptor descriptor, Source librarySource) { |
| if (!_isValidLibraryDescriptor(descriptor)) { |
| throw new ArgumentError("Invalid descriptor: $descriptor"); |
| } |
| ResolutionState state = _resolutionState; |
| while (state != null) { |
| if (librarySource == state._librarySource) { |
| return state.getValue(descriptor); |
| } |
| state = state._nextState; |
| } |
| return descriptor.defaultValue; |
| } |
| |
| /** |
| * Return `true` if the data represented by the given [descriptor] is marked |
| * as being invalid. If the descriptor represents library-specific data then |
| * this method will return `true` if the data associated with any library it |
| * marked as invalid. |
| */ |
| bool hasInvalidData(DataDescriptor descriptor) { |
| if (_isValidDescriptor(descriptor)) { |
| return getState(descriptor) == CacheState.INVALID; |
| } else if (_isValidLibraryDescriptor(descriptor)) { |
| ResolutionState state = _resolutionState; |
| while (state != null) { |
| if (state.getState(descriptor) == CacheState.INVALID) { |
| return true; |
| } |
| state = state._nextState; |
| } |
| } |
| return false; |
| } |
| |
| @override |
| void invalidateAllInformation() { |
| super.invalidateAllInformation(); |
| setState(SCAN_ERRORS, CacheState.INVALID); |
| setState(TOKEN_STREAM, CacheState.INVALID); |
| setState(SOURCE_KIND, CacheState.INVALID); |
| setState(PARSE_ERRORS, CacheState.INVALID); |
| setState(PARSED_UNIT, CacheState.INVALID); |
| _discardCachedResolutionInformation(true); |
| } |
| |
| /** |
| * Invalidate all of the resolution information associated with the |
| * compilation unit. The flag [invalidateUris] should be `true` if the cached |
| * results of converting URIs to source files should also be invalidated. |
| */ |
| void invalidateAllResolutionInformation(bool invalidateUris) { |
| if (getState(PARSED_UNIT) == CacheState.FLUSHED) { |
| ResolutionState state = _resolutionState; |
| while (state != null) { |
| if (state.getState(BUILT_UNIT) == CacheState.VALID) { |
| CompilationUnit unit = state.getValue(BUILT_UNIT); |
| setValue(PARSED_UNIT, unit.accept(new AstCloner())); |
| break; |
| } else if (state.getState(RESOLVED_UNIT) == CacheState.VALID) { |
| CompilationUnit unit = state.getValue(RESOLVED_UNIT); |
| setValue(PARSED_UNIT, unit.accept(new AstCloner())); |
| break; |
| } |
| state = state._nextState; |
| } |
| } |
| _discardCachedResolutionInformation(invalidateUris); |
| } |
| |
| /** |
| * Invalidate all of the parse and resolution information associated with |
| * this source. |
| */ |
| void invalidateParseInformation() { |
| setState(SOURCE_KIND, CacheState.INVALID); |
| setState(PARSE_ERRORS, CacheState.INVALID); |
| setState(PARSED_UNIT, CacheState.INVALID); |
| _containingLibraries.clear(); |
| _discardCachedResolutionInformation(true); |
| } |
| |
| /** |
| * Record that an [exception] occurred while attempting to build the element |
| * model for the source represented by this entry in the context of the given |
| * [library]. This will set the state of all resolution-based information as |
| * being in error, but will not change the state of any parse results. |
| */ |
| void recordBuildElementErrorInLibrary(Source librarySource, |
| CaughtException exception) { |
| setStateInLibrary(BUILT_ELEMENT, librarySource, CacheState.ERROR); |
| setStateInLibrary(BUILT_UNIT, librarySource, CacheState.ERROR); |
| recordResolutionErrorInLibrary(librarySource, exception); |
| } |
| |
| @override |
| void recordContentError(CaughtException exception) { |
| super.recordContentError(exception); |
| recordScanError(exception); |
| } |
| |
| /** |
| * Record that an error occurred while attempting to generate hints for the |
| * source represented by this entry. This will set the state of all |
| * verification information as being in error. |
| * |
| * @param librarySource the source of the library in which hints were being generated |
| * @param exception the exception that shows where the error occurred |
| */ |
| void recordHintErrorInLibrary(Source librarySource, |
| CaughtException exception) { |
| this.exception = exception; |
| ResolutionState state = _getOrCreateResolutionState(librarySource); |
| state.recordHintError(); |
| } |
| |
| /** |
| * Record that an error occurred while attempting to generate lints for the |
| * source represented by this entry. This will set the state of all |
| * verification information as being in error. |
| * |
| * @param librarySource the source of the library in which lints were being generated |
| * @param exception the exception that shows where the error occurred |
| */ |
| void recordLintErrorInLibrary(Source librarySource, |
| CaughtException exception) { |
| this.exception = exception; |
| ResolutionState state = _getOrCreateResolutionState(librarySource); |
| state.recordLintError(); |
| } |
| |
| /** |
| * Record that an [exception] occurred while attempting to scan or parse the |
| * entry represented by this entry. This will set the state of all information, |
| * including any resolution-based information, as being in error. |
| */ |
| void recordParseError(CaughtException exception) { |
| setState(SOURCE_KIND, CacheState.ERROR); |
| setState(PARSE_ERRORS, CacheState.ERROR); |
| setState(PARSED_UNIT, CacheState.ERROR); |
| setState(EXPORTED_LIBRARIES, CacheState.ERROR); |
| setState(IMPORTED_LIBRARIES, CacheState.ERROR); |
| setState(INCLUDED_PARTS, CacheState.ERROR); |
| recordResolutionError(exception); |
| } |
| |
| /** |
| * Record that an [exception] occurred while attempting to resolve the source |
| * represented by this entry. This will set the state of all resolution-based |
| * information as being in error, but will not change the state of any parse |
| * results. |
| * |
| * @param exception the exception that shows where the error occurred |
| */ |
| void recordResolutionError(CaughtException exception) { |
| this.exception = exception; |
| setState(ELEMENT, CacheState.ERROR); |
| setState(IS_CLIENT, CacheState.ERROR); |
| setState(IS_LAUNCHABLE, CacheState.ERROR); |
| setState(PUBLIC_NAMESPACE, CacheState.ERROR); |
| _resolutionState.recordResolutionErrorsInAllLibraries(); |
| } |
| |
| /** |
| * Record that an error occurred while attempting to resolve the source represented by this entry. |
| * This will set the state of all resolution-based information as being in error, but will not |
| * change the state of any parse results. |
| * |
| * @param librarySource the source of the library in which resolution was being performed |
| * @param exception the exception that shows where the error occurred |
| */ |
| void recordResolutionErrorInLibrary(Source librarySource, |
| CaughtException exception) { |
| this.exception = exception; |
| setState(ELEMENT, CacheState.ERROR); |
| setState(IS_CLIENT, CacheState.ERROR); |
| setState(IS_LAUNCHABLE, CacheState.ERROR); |
| setState(PUBLIC_NAMESPACE, CacheState.ERROR); |
| ResolutionState state = _getOrCreateResolutionState(librarySource); |
| state.recordResolutionError(); |
| } |
| |
| /** |
| * Record that an [exception] occurred while attempting to scan or parse the |
| * entry represented by this entry. This will set the state of all information, |
| * including any resolution-based information, as being in error. |
| */ |
| @override |
| void recordScanError(CaughtException exception) { |
| super.recordScanError(exception); |
| setState(SCAN_ERRORS, CacheState.ERROR); |
| setState(TOKEN_STREAM, CacheState.ERROR); |
| recordParseError(exception); |
| } |
| |
| /** |
| * Record that an [exception] occurred while attempting to generate errors and |
| * warnings for the source represented by this entry. This will set the state |
| * of all verification information as being in error. |
| * |
| * @param librarySource the source of the library in which verification was being performed |
| * @param exception the exception that shows where the error occurred |
| */ |
| void recordVerificationErrorInLibrary(Source librarySource, |
| CaughtException exception) { |
| this.exception = exception; |
| ResolutionState state = _getOrCreateResolutionState(librarySource); |
| state.recordVerificationError(); |
| } |
| |
| /** |
| * Remove the given [library] from the list of libraries that contain this |
| * part. This method should only be invoked on entries that represent a part. |
| * |
| * @param librarySource the source of the library to be removed |
| */ |
| void removeContainingLibrary(Source library) { |
| _containingLibraries.remove(library); |
| } |
| |
| /** |
| * Remove any resolution information associated with this compilation unit |
| * being part of the given [library], presumably because it is no longer part |
| * of the library. |
| */ |
| void removeResolution(Source library) { |
| if (library != null) { |
| if (library == _resolutionState._librarySource) { |
| if (_resolutionState._nextState == null) { |
| _resolutionState.invalidateAllResolutionInformation(); |
| } else { |
| _resolutionState = _resolutionState._nextState; |
| } |
| } else { |
| ResolutionState priorState = _resolutionState; |
| ResolutionState state = _resolutionState._nextState; |
| while (state != null) { |
| if (library == state._librarySource) { |
| priorState._nextState = state._nextState; |
| break; |
| } |
| priorState = state; |
| state = state._nextState; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Set the state of the data represented by the given descriptor in the context of the given |
| * library to the given state. |
| * |
| * @param descriptor the descriptor representing the data whose state is to be set |
| * @param librarySource the source of the defining compilation unit of the library that is the |
| * context for the data |
| * @param cacheState the new state of the data represented by the given descriptor |
| */ |
| void setStateInLibrary(DataDescriptor descriptor, Source librarySource, |
| CacheState cacheState) { |
| if (!_isValidLibraryDescriptor(descriptor)) { |
| throw new ArgumentError("Invalid descriptor: $descriptor"); |
| } |
| ResolutionState state = _getOrCreateResolutionState(librarySource); |
| state.setState(descriptor, cacheState); |
| } |
| |
| /** |
| * Set the value of the data represented by the given descriptor in the context of the given |
| * library to the given value, and set the state of that data to [CacheState.VALID]. |
| * |
| * @param descriptor the descriptor representing which data is to have its value set |
| * @param librarySource the source of the defining compilation unit of the library that is the |
| * context for the data |
| * @param value the new value of the data represented by the given descriptor and library |
| */ |
| void setValueInLibrary(DataDescriptor descriptor, Source librarySource, |
| Object value) { |
| if (!_isValidLibraryDescriptor(descriptor)) { |
| throw new ArgumentError("Invalid descriptor: $descriptor"); |
| } |
| ResolutionState state = _getOrCreateResolutionState(librarySource); |
| state.setValue(descriptor, value); |
| } |
| |
| /** |
| * Invalidate all of the resolution information associated with the compilation unit. |
| * |
| * @param invalidateUris true if the cached results of converting URIs to source files should also |
| * be invalidated. |
| */ |
| void _discardCachedResolutionInformation(bool invalidateUris) { |
| setState(ELEMENT, CacheState.INVALID); |
| setState(IS_CLIENT, CacheState.INVALID); |
| setState(IS_LAUNCHABLE, CacheState.INVALID); |
| setState(PUBLIC_NAMESPACE, CacheState.INVALID); |
| _resolutionState.invalidateAllResolutionInformation(); |
| if (invalidateUris) { |
| setState(EXPORTED_LIBRARIES, CacheState.INVALID); |
| setState(IMPORTED_LIBRARIES, CacheState.INVALID); |
| setState(INCLUDED_PARTS, CacheState.INVALID); |
| } |
| } |
| |
| /** |
| * Return a resolution state for the specified library, creating one as necessary. |
| * |
| * @param librarySource the library source (not `null`) |
| * @return the resolution state (not `null`) |
| */ |
| ResolutionState _getOrCreateResolutionState(Source librarySource) { |
| ResolutionState state = _resolutionState; |
| if (state._librarySource == null) { |
| state._librarySource = librarySource; |
| return state; |
| } |
| while (state._librarySource != librarySource) { |
| if (state._nextState == null) { |
| ResolutionState newState = new ResolutionState(); |
| newState._librarySource = librarySource; |
| state._nextState = newState; |
| return newState; |
| } |
| state = state._nextState; |
| } |
| return state; |
| } |
| |
| @override |
| bool _isValidDescriptor(DataDescriptor descriptor) { |
| return descriptor == CONTAINING_LIBRARIES || |
| descriptor == ELEMENT || |
| descriptor == EXPORTED_LIBRARIES || |
| descriptor == IMPORTED_LIBRARIES || |
| descriptor == INCLUDED_PARTS || |
| descriptor == IS_CLIENT || |
| descriptor == IS_LAUNCHABLE || |
| descriptor == PARSED_UNIT || |
| descriptor == PARSE_ERRORS || |
| descriptor == PUBLIC_NAMESPACE || |
| descriptor == SCAN_ERRORS || |
| descriptor == SOURCE_KIND || |
| descriptor == TOKEN_STREAM || |
| super._isValidDescriptor(descriptor); |
| } |
| |
| /** |
| * Return `true` if the [descriptor] is valid for this entry when the data is |
| * relative to a library. |
| */ |
| bool _isValidLibraryDescriptor(DataDescriptor descriptor) { |
| return descriptor == BUILT_ELEMENT || |
| descriptor == BUILT_UNIT || |
| descriptor == HINTS || |
| descriptor == LINTS || |
| descriptor == RESOLUTION_ERRORS || |
| descriptor == RESOLVED_UNIT || |
| descriptor == VERIFICATION_ERRORS; |
| } |
| |
| @override |
| bool _writeDiffOn(StringBuffer buffer, SourceEntry oldEntry) { |
| bool needsSeparator = super._writeDiffOn(buffer, oldEntry); |
| if (oldEntry is! DartEntry) { |
| if (needsSeparator) { |
| buffer.write("; "); |
| } |
| buffer.write("entry type changed; was "); |
| buffer.write(oldEntry.runtimeType.toString()); |
| return true; |
| } |
| needsSeparator = _writeStateDiffOn( |
| buffer, |
| needsSeparator, |
| "tokenStream", |
| DartEntry.TOKEN_STREAM, |
| oldEntry); |
| needsSeparator = _writeStateDiffOn( |
| buffer, |
| needsSeparator, |
| "scanErrors", |
| DartEntry.SCAN_ERRORS, |
| oldEntry); |
| needsSeparator = _writeStateDiffOn( |
| buffer, |
| needsSeparator, |
| "sourceKind", |
| DartEntry.SOURCE_KIND, |
| oldEntry); |
| needsSeparator = _writeStateDiffOn( |
| buffer, |
| needsSeparator, |
| "parsedUnit", |
| DartEntry.PARSED_UNIT, |
| oldEntry); |
| needsSeparator = _writeStateDiffOn( |
| buffer, |
| needsSeparator, |
| "parseErrors", |
| DartEntry.PARSE_ERRORS, |
| oldEntry); |
| needsSeparator = _writeStateDiffOn( |
| buffer, |
| needsSeparator, |
| "importedLibraries", |
| DartEntry.IMPORTED_LIBRARIES, |
| oldEntry); |
| needsSeparator = _writeStateDiffOn( |
| buffer, |
| needsSeparator, |
| "exportedLibraries", |
| DartEntry.EXPORTED_LIBRARIES, |
| oldEntry); |
| needsSeparator = _writeStateDiffOn( |
| buffer, |
| needsSeparator, |
| "includedParts", |
| DartEntry.INCLUDED_PARTS, |
| oldEntry); |
| needsSeparator = _writeStateDiffOn( |
| buffer, |
| needsSeparator, |
| "element", |
| DartEntry.ELEMENT, |
| oldEntry); |
| needsSeparator = _writeStateDiffOn( |
| buffer, |
| needsSeparator, |
| "publicNamespace", |
| DartEntry.PUBLIC_NAMESPACE, |
| oldEntry); |
| needsSeparator = _writeStateDiffOn( |
| buffer, |
| needsSeparator, |
| "clientServer", |
| DartEntry.IS_CLIENT, |
| oldEntry); |
| needsSeparator = _writeStateDiffOn( |
| buffer, |
| needsSeparator, |
| "launchable", |
| DartEntry.IS_LAUNCHABLE, |
| oldEntry); |
| // TODO(brianwilkerson) Add better support for containingLibraries. |
| // It would be nice to be able to report on size-preserving changes. |
| int oldLibraryCount = (oldEntry as DartEntry)._containingLibraries.length; |
| int libraryCount = _containingLibraries.length; |
| if (oldLibraryCount != libraryCount) { |
| if (needsSeparator) { |
| buffer.write("; "); |
| } |
| buffer.write("containingLibraryCount = "); |
| buffer.write(oldLibraryCount); |
| buffer.write(" -> "); |
| buffer.write(libraryCount); |
| needsSeparator = true; |
| } |
| // |
| // Report change to the per-library state. |
| // |
| HashMap<Source, ResolutionState> oldStateMap = |
| new HashMap<Source, ResolutionState>(); |
| ResolutionState state = (oldEntry as DartEntry)._resolutionState; |
| while (state != null) { |
| Source librarySource = state._librarySource; |
| if (librarySource != null) { |
| oldStateMap[librarySource] = state; |
| } |
| state = state._nextState; |
| } |
| state = _resolutionState; |
| while (state != null) { |
| Source librarySource = state._librarySource; |
| if (librarySource != null) { |
| ResolutionState oldState = oldStateMap.remove(librarySource); |
| if (oldState == null) { |
| if (needsSeparator) { |
| buffer.write("; "); |
| } |
| buffer.write("added resolution for "); |
| buffer.write(librarySource.fullName); |
| needsSeparator = true; |
| } else { |
| needsSeparator = |
| oldState._writeDiffOn(buffer, needsSeparator, oldEntry as DartEntry); |
| } |
| } |
| state = state._nextState; |
| } |
| for (Source librarySource in oldStateMap.keys.toSet()) { |
| if (needsSeparator) { |
| buffer.write("; "); |
| } |
| buffer.write("removed resolution for "); |
| buffer.write(librarySource.fullName); |
| needsSeparator = true; |
| } |
| return needsSeparator; |
| } |
| |
| @override |
| void _writeOn(StringBuffer buffer) { |
| buffer.write("Dart: "); |
| super._writeOn(buffer); |
| _writeStateOn(buffer, "tokenStream", TOKEN_STREAM); |
| _writeStateOn(buffer, "scanErrors", SCAN_ERRORS); |
| _writeStateOn(buffer, "sourceKind", SOURCE_KIND); |
| _writeStateOn(buffer, "parsedUnit", PARSED_UNIT); |
| _writeStateOn(buffer, "parseErrors", PARSE_ERRORS); |
| _writeStateOn(buffer, "exportedLibraries", EXPORTED_LIBRARIES); |
| _writeStateOn(buffer, "importedLibraries", IMPORTED_LIBRARIES); |
| _writeStateOn(buffer, "includedParts", INCLUDED_PARTS); |
| _writeStateOn(buffer, "element", ELEMENT); |
| _writeStateOn(buffer, "publicNamespace", PUBLIC_NAMESPACE); |
| _writeStateOn(buffer, "clientServer", IS_CLIENT); |
| _writeStateOn(buffer, "launchable", IS_LAUNCHABLE); |
| _resolutionState._writeOn(buffer); |
| } |
| } |
| |
| /** |
| * Instances of the class `DataDescriptor` are immutable constants representing data that can |
| * be stored in the cache. |
| */ |
| class DataDescriptor<E> { |
| /** |
| * The name of the descriptor, used for debugging purposes. |
| */ |
| final String _name; |
| |
| /** |
| * The default value used when the data does not exist. |
| */ |
| final E defaultValue; |
| |
| /** |
| * Initialize a newly created descriptor to have the given [name] and |
| * [defaultValue]. |
| */ |
| DataDescriptor(this._name, [this.defaultValue = null]); |
| |
| @override |
| String toString() => _name; |
| } |
| |
| /** |
| * Instances of the class `DefaultRetentionPolicy` implement a retention policy that will keep |
| * AST's in the cache if there is analysis information that needs to be computed for a source, where |
| * the computation is dependent on having the AST. |
| */ |
| class DefaultRetentionPolicy implements CacheRetentionPolicy { |
| /** |
| * An instance of this class that can be shared. |
| */ |
| static DefaultRetentionPolicy POLICY = new DefaultRetentionPolicy(); |
| |
| /** |
| * Return `true` if there is analysis information in the given entry that needs to be |
| * computed, where the computation is dependent on having the AST. |
| * |
| * @param dartEntry the entry being tested |
| * @return `true` if there is analysis information that needs to be computed from the AST |
| */ |
| bool astIsNeeded(DartEntry dartEntry) => |
| dartEntry.hasInvalidData(DartEntry.HINTS) || |
| dartEntry.hasInvalidData(DartEntry.LINTS) || |
| dartEntry.hasInvalidData(DartEntry.VERIFICATION_ERRORS) || |
| dartEntry.hasInvalidData(DartEntry.RESOLUTION_ERRORS); |
| |
| @override |
| RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry) { |
| if (sourceEntry is DartEntry) { |
| DartEntry dartEntry = sourceEntry; |
| if (astIsNeeded(dartEntry)) { |
| return RetentionPriority.MEDIUM; |
| } |
| } |
| return RetentionPriority.LOW; |
| } |
| } |
| |
| /** |
| * Instances of the class `GenerateDartErrorsTask` generate errors and warnings for a single |
| * Dart source. |
| */ |
| class GenerateDartErrorsTask extends AnalysisTask { |
| /** |
| * The source for which errors and warnings are to be produced. |
| */ |
| final Source source; |
| |
| /** |
| * The compilation unit used to resolve the dependencies. |
| */ |
| final CompilationUnit _unit; |
| |
| /** |
| * The element model for the library containing the source. |
| */ |
| final LibraryElement libraryElement; |
| |
| /** |
| * The errors that were generated for the source. |
| */ |
| List<AnalysisError> _errors; |
| |
| /** |
| * Initialize a newly created task to perform analysis within the given context. |
| * |
| * @param context the context in which the task is to be performed |
| * @param source the source for which errors and warnings are to be produced |
| * @param unit the compilation unit used to resolve the dependencies |
| * @param libraryElement the element model for the library containing the source |
| */ |
| GenerateDartErrorsTask(InternalAnalysisContext context, this.source, |
| this._unit, this.libraryElement) |
| : super(context); |
| |
| /** |
| * Return the errors that were generated for the source. |
| * |
| * @return the errors that were generated for the source |
| */ |
| List<AnalysisError> get errors => _errors; |
| |
| @override |
| String get taskDescription => |
| "generate errors and warnings for ${source.fullName}"; |
| |
| @override |
| accept(AnalysisTaskVisitor visitor) => |
| visitor.visitGenerateDartErrorsTask(this); |
| |
| @override |
| void internalPerform() { |
| TimeCounter_TimeCounterHandle timeCounter = |
| PerformanceStatistics.errors.start(); |
| try { |
| RecordingErrorListener errorListener = new RecordingErrorListener(); |
| ErrorReporter errorReporter = new ErrorReporter(errorListener, source); |
| TypeProvider typeProvider = context.typeProvider; |
| // |
| // Validate the directives |
| // |
| validateDirectives(context, source, _unit, errorListener); |
| // |
| // Use the ConstantVerifier to verify the use of constants. |
| // This needs to happen before using the ErrorVerifier because some error |
| // codes need the computed constant values. |
| // |
| // TODO(paulberry): as a temporary workaround for issue 21572, |
| // ConstantVerifier is being run right after ConstantValueComputer, so we |
| // don't need to run it here. Once issue 21572 is fixed, re-enable the |
| // call to ConstantVerifier. |
| // ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, libraryElement, typeProvider); |
| // _unit.accept(constantVerifier); |
| // |
| // Use the ErrorVerifier to compute the rest of the errors. |
| // |
| ErrorVerifier errorVerifier = new ErrorVerifier( |
| errorReporter, |
| libraryElement, |
| typeProvider, |
| new InheritanceManager(libraryElement)); |
| _unit.accept(errorVerifier); |
| _errors = errorListener.getErrorsForSource(source); |
| } finally { |
| timeCounter.stop(); |
| } |
| } |
| |
| /** |
| * Check each directive in the given compilation unit to see if the referenced source exists and |
| * report an error if it does not. |
| * |
| * @param context the context in which the library exists |
| * @param librarySource the source representing the library containing the directives |
| * @param unit the compilation unit containing the directives to be validated |
| * @param errorListener the error listener to which errors should be reported |
| */ |
| static void validateDirectives(AnalysisContext context, Source librarySource, |
| CompilationUnit unit, AnalysisErrorListener errorListener) { |
| for (Directive directive in unit.directives) { |
| if (directive is UriBasedDirective) { |
| validateReferencedSource( |
| context, |
| librarySource, |
| directive, |
| errorListener); |
| } |
| } |
| } |
| |
| /** |
| * Check the given directive to see if the referenced source exists and report an error if it does |
| * not. |
| * |
| * @param context the context in which the library exists |
| * @param librarySource the source representing the library containing the directive |
| * @param directive the directive to be verified |
| * @param errorListener the error listener to which errors should be reported |
| */ |
| static void validateReferencedSource(AnalysisContext context, |
| Source librarySource, UriBasedDirective directive, |
| AnalysisErrorListener errorListener) { |
| Source source = directive.source; |
| if (source != null) { |
| if (context.exists(source)) { |
| return; |
| } |
| } else { |
| // Don't report errors already reported by ParseDartTask.resolveDirective |
| if (directive.validate() != null) { |
| return; |
| } |
| } |
| StringLiteral uriLiteral = directive.uri; |
| errorListener.onError( |
| new AnalysisError.con2( |
| librarySource, |
| uriLiteral.offset, |
| uriLiteral.length, |
| CompileTimeErrorCode.URI_DOES_NOT_EXIST, |
| [directive.uriContent])); |
| } |
| } |
| |
| /** |
| * Instances of the class `GenerateDartHintsTask` generate hints for a single Dart library. |
| */ |
| class GenerateDartHintsTask extends AnalysisTask { |
| /** |
| * The compilation units that comprise the library, with the defining compilation unit appearing |
| * first in the array. |
| */ |
| final List<TimestampedData<CompilationUnit>> _units; |
| |
| /** |
| * The element model for the library being analyzed. |
| */ |
| final LibraryElement libraryElement; |
| |
| /** |
| * A table mapping the sources that were analyzed to the hints that were |
| * generated for the sources. |
| */ |
| HashMap<Source, List<AnalysisError>> _hintMap; |
| |
| /** |
| * Initialize a newly created task to perform analysis within the given context. |
| * |
| * @param context the context in which the task is to be performed |
| * @param units the compilation units that comprise the library, with the defining compilation |
| * unit appearing first in the array |
| * @param libraryElement the element model for the library being analyzed |
| */ |
| GenerateDartHintsTask(InternalAnalysisContext context, this._units, |
| this.libraryElement) |
| : super(context); |
| |
| /** |
| * Return a table mapping the sources that were analyzed to the hints that were generated for the |
| * sources, or `null` if the task has not been performed or if the analysis did not complete |
| * normally. |
| * |
| * @return a table mapping the sources that were analyzed to the hints that were generated for the |
| * sources |
| */ |
| HashMap<Source, List<AnalysisError>> get hintMap => _hintMap; |
| |
| @override |
| String get taskDescription { |
| Source librarySource = libraryElement.source; |
| if (librarySource == null) { |
| return "generate Dart hints for library without source"; |
| } |
| return "generate Dart hints for ${librarySource.fullName}"; |
| } |
| |
| @override |
| accept(AnalysisTaskVisitor visitor) => |
| visitor.visitGenerateDartHintsTask(this); |
| |
| @override |
| void internalPerform() { |
| // |
| // Gather the compilation units. |
| // |
| int unitCount = _units.length; |
| List<CompilationUnit> compilationUnits = |
| new List<CompilationUnit>(unitCount); |
| for (int i = 0; i < unitCount; i++) { |
| compilationUnits[i] = _units[i].data; |
| } |
| // |
| // Analyze all of the units. |
| // |
| RecordingErrorListener errorListener = new RecordingErrorListener(); |
| HintGenerator hintGenerator = |
| new HintGenerator(compilationUnits, context, errorListener); |
| hintGenerator.generateForLibrary(); |
| // |
| // Store the results. |
| // |
| _hintMap = new HashMap<Source, List<AnalysisError>>(); |
| for (int i = 0; i < unitCount; i++) { |
| Source source = _units[i].data.element.source; |
| _hintMap[source] = errorListener.getErrorsForSource(source); |
| } |
| } |
| } |
| |
| /// Generates lint feedback for a single Dart library. |
| class GenerateDartLintsTask extends AnalysisTask { |
| |
| ///The compilation units that comprise the library, with the defining |
| ///compilation unit appearing first in the array. |
| final List<TimestampedData<CompilationUnit>> _units; |
| |
| /// The element model for the library being analyzed. |
| final LibraryElement libraryElement; |
| |
| /// A mapping of analyzed sources to their associated lint warnings. |
| /// May be [null] if the task has not been performed or if analysis did not |
| /// complete normally. |
| HashMap<Source, List<AnalysisError>> lintMap; |
| |
| /// Initialize a newly created task to perform lint checking over these |
| /// [_units] belonging to this [libraryElement] within the given [context]. |
| GenerateDartLintsTask(context, this._units, this.libraryElement) |
| : super(context); |
| |
| @override |
| String get taskDescription { |
| Source librarySource = libraryElement.source; |
| return (librarySource == null) ? |
| "generate Dart lints for library without source" : |
| "generate Dart lints for ${librarySource.fullName}"; |
| } |
| |
| @override |
| accept(AnalysisTaskVisitor visitor) => |
| visitor.visitGenerateDartLintsTask(this); |
| |
| @override |
| void internalPerform() { |
| |
| Iterable<CompilationUnit> compilationUnits = |
| _units.map((TimestampedData<CompilationUnit> unit) => unit.data); |
| RecordingErrorListener errorListener = new RecordingErrorListener(); |
| LintGenerator lintGenerator = |
| new LintGenerator(compilationUnits, errorListener); |
| lintGenerator.generate(); |
| |
| lintMap = new HashMap<Source, List<AnalysisError>>(); |
| compilationUnits.forEach((CompilationUnit unit) { |
| Source source = unit.element.source; |
| lintMap[source] = errorListener.getErrorsForSource(source); |
| }); |
| } |
| } |
| |
| |
| /** |
| * Instances of the class `GetContentTask` get the contents of a source. |
| */ |
| class GetContentTask extends AnalysisTask { |
| /** |
| * The source to be read. |
| */ |
| final Source source; |
| |
| /** |
| * A flag indicating whether this task is complete. |
| */ |
| bool _complete = false; |
| |
| /** |
| * The contents of the source. |
| */ |
| String _content; |
| |
| /** |
| * The time at which the contents of the source were last modified. |
| */ |
| int _modificationTime = -1; |
| |
| /** |
| * Initialize a newly created task to perform analysis within the given context. |
| * |
| * @param context the context in which the task is to be performed |
| * @param source the source to be parsed |
| * @param contentData the time-stamped contents of the source |
| */ |
| GetContentTask(InternalAnalysisContext context, this.source) |
| : super(context) { |
| if (source == null) { |
| throw new IllegalArgumentException("Cannot get contents of null source"); |
| } |
| } |
| |
| /** |
| * Return the contents of the source, or `null` if the task has not completed or if there |
| * was an exception while getting the contents. |
| * |
| * @return the contents of the source |
| */ |
| String get content => _content; |
| |
| /** |
| * Return `true` if this task is complete. Unlike most tasks, this task is allowed to be |
| * visited more than once in order to support asynchronous IO. If the task is not complete when it |
| * is visited synchronously as part of the [AnalysisTask.perform] |
| * method, it will be visited again, using the same visitor, when the IO operation has been |
| * performed. |
| * |
| * @return `true` if this task is complete |
| */ |
| bool get isComplete => _complete; |
| |
| /** |
| * Return the time at which the contents of the source that was parsed were last modified, or a |
| * negative value if the task has not yet been performed or if an exception occurred. |
| * |
| * @return the time at which the contents of the source that was parsed were last modified |
| */ |
| int get modificationTime => _modificationTime; |
| |
| @override |
| String get taskDescription => "get contents of ${source.fullName}"; |
| |
| @override |
| accept(AnalysisTaskVisitor visitor) => visitor.visitGetContentTask(this); |
| |
| @override |
| void internalPerform() { |
| _complete = true; |
| try { |
| TimestampedData<String> data = context.getContents(source); |
| _content = data.data; |
| _modificationTime = data.modificationTime; |
| AnalysisEngine.instance.instrumentationService.logFileRead( |
| source.fullName, |
| _modificationTime, |
| _content); |
| } catch (exception, stackTrace) { |
| throw new AnalysisException( |
| "Could not get contents of $source", |
| new CaughtException(exception, stackTrace)); |
| } |
| } |
| } |
| |
| /** |
| * An `HtmlEntry` maintains the information cached by an analysis context about |
| * an individual HTML file. |
| */ |
| class HtmlEntry extends SourceEntry { |
| /** |
| * The data descriptor representing the HTML element. |
| */ |
| static final DataDescriptor<HtmlElement> ELEMENT = |
| new DataDescriptor<HtmlElement>("HtmlEntry.ELEMENT"); |
| |
| /** |
| * The data descriptor representing the hints resulting from auditing the |
| * source. |
| */ |
| static final DataDescriptor<List<AnalysisError>> HINTS = |
| new DataDescriptor<List<AnalysisError>>( |
| "HtmlEntry.HINTS", |
| AnalysisError.NO_ERRORS); |
| |
| /** |
| * The data descriptor representing the errors resulting from parsing the |
| * source. |
| */ |
| static final DataDescriptor<List<AnalysisError>> PARSE_ERRORS = |
| new DataDescriptor<List<AnalysisError>>( |
| "HtmlEntry.PARSE_ERRORS", |
| AnalysisError.NO_ERRORS); |
| |
| /** |
| * The data descriptor representing the parsed AST structure. |
| */ |
| static final DataDescriptor<ht.HtmlUnit> PARSED_UNIT = |
| new DataDescriptor<ht.HtmlUnit>("HtmlEntry.PARSED_UNIT"); |
| |
| /** |
| * The data descriptor representing the resolved AST structure. |
| */ |
| static final DataDescriptor<ht.HtmlUnit> RESOLVED_UNIT = |
| new DataDescriptor<ht.HtmlUnit>("HtmlEntry.RESOLVED_UNIT"); |
| |
| /** |
| * The data descriptor representing the list of referenced libraries. |
| */ |
| static final DataDescriptor<List<Source>> REFERENCED_LIBRARIES = |
| new DataDescriptor<List<Source>>( |
| "HtmlEntry.REFERENCED_LIBRARIES", |
| Source.EMPTY_ARRAY); |
| |
| /** |
| * The data descriptor representing the errors resulting from resolving the |
| * source. |
| */ |
| static final DataDescriptor<List<AnalysisError>> RESOLUTION_ERRORS = |
| new DataDescriptor<List<AnalysisError>>( |
| "HtmlEntry.RESOLUTION_ERRORS", |
| AnalysisError.NO_ERRORS); |
| |
| /** |
| * Return all of the errors associated with the HTML file that are currently |
| * cached. |
| */ |
| List<AnalysisError> get allErrors { |
| List<AnalysisError> errors = new List<AnalysisError>(); |
| errors.addAll(getValue(PARSE_ERRORS)); |
| errors.addAll(getValue(RESOLUTION_ERRORS)); |
| errors.addAll(getValue(HINTS)); |
| if (errors.length == 0) { |
| return AnalysisError.NO_ERRORS; |
| } |
| return errors; |
| } |
| |
| /** |
| * Return a valid parsed unit, either an unresolved AST structure or the |
| * result of resolving the AST structure, or `null` if there is no parsed unit |
| * available. |
| */ |
| ht.HtmlUnit get anyParsedUnit { |
| if (getState(PARSED_UNIT) == CacheState.VALID) { |
| return getValue(PARSED_UNIT); |
| } |
| if (getState(RESOLVED_UNIT) == CacheState.VALID) { |
| return getValue(RESOLVED_UNIT); |
| } |
| return null; |
| } |
| |
| @override |
| List<DataDescriptor> get descriptors { |
| List<DataDescriptor> result = super.descriptors; |
| result.addAll( |
| [ |
| HtmlEntry.ELEMENT, |
| HtmlEntry.PARSE_ERRORS, |
| HtmlEntry.PARSED_UNIT, |
| HtmlEntry.RESOLUTION_ERRORS, |
| HtmlEntry.RESOLVED_UNIT, |
| HtmlEntry.HINTS]); |
| return result; |
| } |
| |
| @override |
| SourceKind get kind => SourceKind.HTML; |
| |
| /** |
| * Flush any AST structures being maintained by this entry. |
| */ |
| void flushAstStructures() { |
| _flush(PARSED_UNIT); |
| _flush(RESOLVED_UNIT); |
| } |
| |
| @override |
| void invalidateAllInformation() { |
| super.invalidateAllInformation(); |
| setState(PARSE_ERRORS, CacheState.INVALID); |
| setState(PARSED_UNIT, CacheState.INVALID); |
| setState(RESOLVED_UNIT, CacheState.INVALID); |
| invalidateAllResolutionInformation(true); |
| } |
| |
| /** |
| * Invalidate all of the resolution information associated with the HTML file. |
| * If [invalidateUris] is `true`, the cached results of converting URIs to |
| * source files should also be invalidated. |
| */ |
| void invalidateAllResolutionInformation(bool invalidateUris) { |
| setState(RESOLVED_UNIT, CacheState.INVALID); |
| setState(ELEMENT, CacheState.INVALID); |
| setState(RESOLUTION_ERRORS, CacheState.INVALID); |
| setState(HINTS, CacheState.INVALID); |
| if (invalidateUris) { |
| setState(REFERENCED_LIBRARIES, CacheState.INVALID); |
| } |
| } |
| |
| /** |
| * Invalidate all of the parse and resolution information associated with |
| * this source. |
| */ |
| void invalidateParseInformation() { |
| setState(PARSE_ERRORS, CacheState.INVALID); |
| setState(PARSED_UNIT, CacheState.INVALID); |
| invalidateAllResolutionInformation(true); |
| } |
| |
| @override |
| void recordContentError(CaughtException exception) { |
| super.recordContentError(exception); |
| recordParseError(exception); |
| } |
| |
| /** |
| * Record that an [exception] was encountered while attempting to parse the |
| * source associated with this entry. |
| */ |
| void recordParseError(CaughtException exception) { |
| // If the scanning and parsing of HTML are separated, |
| // the following line can be removed. |
| recordScanError(exception); |
| setState(PARSE_ERRORS, CacheState.ERROR); |
| setState(PARSED_UNIT, CacheState.ERROR); |
| setState(REFERENCED_LIBRARIES, CacheState.ERROR); |
| recordResolutionError(exception); |
| } |
| |
| /** |
| * Record that an [exception] was encountered while attempting to resolve the |
| * source associated with this entry. |
| */ |
| void recordResolutionError(CaughtException exception) { |
| this.exception = exception; |
| setState(RESOLVED_UNIT, CacheState.ERROR); |
| setState(ELEMENT, CacheState.ERROR); |
| setState(RESOLUTION_ERRORS, CacheState.ERROR); |
| setState(HINTS, CacheState.ERROR); |
| } |
| |
| @override |
| bool _isValidDescriptor(DataDescriptor descriptor) { |
| return descriptor == ELEMENT || |
| descriptor == HINTS || |
| descriptor == PARSED_UNIT || |
| descriptor == PARSE_ERRORS || |
| descriptor == REFERENCED_LIBRARIES || |
| descriptor == RESOLUTION_ERRORS || |
| descriptor == RESOLVED_UNIT || |
| super._isValidDescriptor(descriptor); |
| } |
| |
| @override |
| bool _writeDiffOn(StringBuffer buffer, SourceEntry oldEntry) { |
| bool needsSeparator = super._writeDiffOn(buffer, oldEntry); |
| if (oldEntry is! HtmlEntry) { |
| if (needsSeparator) { |
| buffer.write("; "); |
| } |
| buffer.write("entry type changed; was "); |
| buffer.write(oldEntry.runtimeType); |
| return true; |
| } |
| needsSeparator = _writeStateDiffOn( |
| buffer, |
| needsSeparator, |
| "parseErrors", |
| HtmlEntry.PARSE_ERRORS, |
| oldEntry); |
| needsSeparator = _writeStateDiffOn( |
| buffer, |
| needsSeparator, |
| "parsedUnit", |
| HtmlEntry.PARSED_UNIT, |
| oldEntry); |
| needsSeparator = _writeStateDiffOn( |
| buffer, |
| needsSeparator, |
| "resolvedUnit", |
| HtmlEntry.RESOLVED_UNIT, |
| oldEntry); |
| needsSeparator = _writeStateDiffOn( |
| buffer, |
| needsSeparator, |
| "resolutionErrors", |
| HtmlEntry.RESOLUTION_ERRORS, |
| oldEntry); |
| needsSeparator = _writeStateDiffOn( |
| buffer, |
| needsSeparator, |
| "referencedLibraries", |
| HtmlEntry.REFERENCED_LIBRARIES, |
| oldEntry); |
| needsSeparator = _writeStateDiffOn( |
| buffer, |
| needsSeparator, |
| "element", |
| HtmlEntry.ELEMENT, |
| oldEntry); |
| return needsSeparator; |
| } |
| |
| @override |
| void _writeOn(StringBuffer buffer) { |
| buffer.write("Html: "); |
| super._writeOn(buffer); |
| _writeStateOn(buffer, "parseErrors", PARSE_ERRORS); |
| _writeStateOn(buffer, "parsedUnit", PARSED_UNIT); |
| _writeStateOn(buffer, "resolvedUnit", RESOLVED_UNIT); |
| _writeStateOn(buffer, "resolutionErrors", RESOLUTION_ERRORS); |
| _writeStateOn(buffer, "referencedLibraries", REFERENCED_LIBRARIES); |
| _writeStateOn(buffer, "element", ELEMENT); |
| } |
| } |
| |
| /** |
| * Instances of the class `IncrementalAnalysisCache` hold information used to perform |
| * incremental analysis. |
| * |
| * See [AnalysisContextImpl.setChangedContents]. |
| */ |
| class IncrementalAnalysisCache { |
| final Source librarySource; |
| |
| final Source source; |
| |
| final String oldContents; |
| |
| final CompilationUnit resolvedUnit; |
| |
| String _newContents; |
| |
| int _offset = 0; |
| |
| int _oldLength = 0; |
| |
| int _newLength = 0; |
| |
| IncrementalAnalysisCache(this.librarySource, this.source, this.resolvedUnit, |
| this.oldContents, String newContents, int offset, int oldLength, int newLength) |
| { |
| this._newContents = newContents; |
| this._offset = offset; |
| this._oldLength = oldLength; |
| this._newLength = newLength; |
| } |
| |
| /** |
| * Determine if the cache contains source changes that need to be analyzed |
| * |
| * @return `true` if the cache contains changes to be analyzed, else `false` |
| */ |
| bool get hasWork => _oldLength > 0 || _newLength > 0; |
| |
| /** |
| * Return the current contents for the receiver's source. |
| * |
| * @return the contents (not `null`) |
| */ |
| String get newContents => _newContents; |
| |
| /** |
| * Return the number of characters in the replacement text. |
| * |
| * @return the replacement length (zero or greater) |
| */ |
| int get newLength => _newLength; |
| |
| /** |
| * Return the character position of the first changed character. |
| * |
| * @return the offset (zero or greater) |
| */ |
| int get offset => _offset; |
| |
| /** |
| * Return the number of characters that were replaced. |
| * |
| * @return the replaced length (zero or greater) |
| */ |
| int get oldLength => _oldLength; |
| |
| /** |
| * Determine if the incremental analysis result can be cached for the next incremental analysis. |
| * |
| * @param cache the prior incremental analysis cache |
| * @param unit the incrementally updated compilation unit |
| * @return the cache used for incremental analysis or `null` if incremental analysis results |
| * cannot be cached for the next incremental analysis |
| */ |
| static IncrementalAnalysisCache cacheResult(IncrementalAnalysisCache cache, |
| CompilationUnit unit) { |
| if (cache != null && unit != null) { |
| return new IncrementalAnalysisCache( |
| cache.librarySource, |
| cache.source, |
| unit, |
| cache._newContents, |
| cache._newContents, |
| 0, |
| 0, |
| 0); |
| } |
| return null; |
| } |
| |
| /** |
| * Determine if the cache should be cleared. |
| * |
| * @param cache the prior cache or `null` if none |
| * @param source the source being updated (not `null`) |
| * @return the cache used for incremental analysis or `null` if incremental analysis cannot |
| * be performed |
| */ |
| static IncrementalAnalysisCache clear(IncrementalAnalysisCache cache, |
| Source source) { |
| if (cache == null || cache.source == source) { |
| return null; |
| } |
| return cache; |
| } |
| |
| /** |
| * Determine if incremental analysis can be performed from the given information. |
| * |
| * @param cache the prior cache or `null` if none |
| * @param source the source being updated (not `null`) |
| * @param oldContents the original source contents prior to this update (may be `null`) |
| * @param newContents the new contents after this incremental change (not `null`) |
| * @param offset the offset at which the change occurred |
| * @param oldLength the length of the text being replaced |
| * @param newLength the length of the replacement text |
| * @param sourceEntry the cached entry for the given source or `null` if none |
| * @return the cache used for incremental analysis or `null` if incremental analysis cannot |
| * be performed |
| */ |
| static IncrementalAnalysisCache update(IncrementalAnalysisCache cache, |
| Source source, String oldContents, String newContents, int offset, |
| int oldLength, int newLength, SourceEntry sourceEntry) { |
| // Determine the cache resolved unit |
| Source librarySource = null; |
| CompilationUnit unit = null; |
| if (sourceEntry is DartEntry) { |
| DartEntry dartEntry = sourceEntry; |
| List<Source> librarySources = dartEntry.librariesContaining; |
| if (librarySources.length == 1) { |
| librarySource = librarySources[0]; |
| if (librarySource != null) { |
| unit = |
| dartEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource); |
| } |
| } |
| } |
| // Create a new cache if there is not an existing cache or the source is |
| // different or a new resolved compilation unit is available. |
| if (cache == null || cache.source != source || unit != null) { |
| if (unit == null) { |
| return null; |
| } |
| if (oldContents == null) { |
| if (oldLength != 0) { |
| return null; |
| } |
| oldContents = |
| "${newContents.substring(0, offset)}${newContents.substring(offset + newLength)}"; |
| } |
| return new IncrementalAnalysisCache( |
| librarySource, |
| source, |
| unit, |
| oldContents, |
| newContents, |
| offset, |
| oldLength, |
| newLength); |
| } |
| // Update the existing cache if the change is contiguous |
| if (cache._oldLength == 0 && cache._newLength == 0) { |
| cache._offset = offset; |
| cache._oldLength = oldLength; |
| cache._newLength = newLength; |
| } else { |
| if (cache._offset > offset || offset > cache._offset + cache._newLength) { |
| return null; |
| } |
| cache._newLength += newLength - oldLength; |
| } |
| cache._newContents = newContents; |
| return cache; |
| } |
| |
| /** |
| * Verify that the incrementally parsed and resolved unit in the incremental cache is structurally |
| * equivalent to the fully parsed unit. |
| * |
| * @param cache the prior cache or `null` if none |
| * @param source the source of the compilation unit that was parsed (not `null`) |
| * @param unit the compilation unit that was just parsed |
| * @return the cache used for incremental analysis or `null` if incremental analysis results |
| * cannot be cached for the next incremental analysis |
| */ |
| static IncrementalAnalysisCache |
| verifyStructure(IncrementalAnalysisCache cache, Source source, |
| CompilationUnit unit) { |
| if (cache != null && unit != null && cache.source == source) { |
| if (!AstComparator.equalNodes(cache.resolvedUnit, unit)) { |
| return null; |
| } |
| } |
| return cache; |
| } |
| } |
| |
| /** |
| * Instances of the class `IncrementalAnalysisTask` incrementally update existing analysis. |
| */ |
| class IncrementalAnalysisTask extends AnalysisTask { |
| /** |
| * The information used to perform incremental analysis. |
| */ |
| final IncrementalAnalysisCache cache; |
| |
| /** |
| * The compilation unit that was produced by incrementally updating the existing unit. |
| */ |
| CompilationUnit _updatedUnit; |
| |
| /** |
| * Initialize a newly created task to perform analysis within the given context. |
| * |
| * @param context the context in which the task is to be performed |
| * @param cache the incremental analysis cache used to perform the analysis |
| */ |
| IncrementalAnalysisTask(InternalAnalysisContext context, this.cache) |
| : super(context); |
| |
| /** |
| * Return the compilation unit that was produced by incrementally updating the existing |
| * compilation unit, or `null` if the task has not yet been performed, could not be |
| * performed, or if an exception occurred. |
| * |
| * @return the compilation unit |
| */ |
| CompilationUnit get compilationUnit => _updatedUnit; |
| |
| /** |
| * Return the source that is to be incrementally analyzed. |
| * |
| * @return the source |
| */ |
| Source get source => cache != null ? cache.source : null; |
| |
| @override |
| String get taskDescription => |
| "incremental analysis ${cache != null ? cache.source : "null"}"; |
| |
| /** |
| * Return the type provider used for incremental resolution. |
| * |
| * @return the type provider (or `null` if an exception occurs) |
| */ |
| TypeProvider get typeProvider { |
| try { |
| return context.typeProvider; |
| } on AnalysisException catch (exception) { |
| return null; |
| } |
| } |
| |
| @override |
| accept(AnalysisTaskVisitor visitor) => |
| visitor.visitIncrementalAnalysisTask(this); |
| |
| @override |
| void internalPerform() { |
| if (cache == null) { |
| return; |
| } |
| // Only handle small changes |
| if (cache.oldLength > 0 || cache.newLength > 30) { |
| return; |
| } |
| // Produce an updated token stream |
| CharacterReader reader = new CharSequenceReader(cache.newContents); |
| BooleanErrorListener errorListener = new BooleanErrorListener(); |
| IncrementalScanner scanner = |
| new IncrementalScanner(cache.source, reader, errorListener); |
| scanner.rescan( |
| cache.resolvedUnit.beginToken, |
| cache.offset, |
| cache.oldLength, |
| cache.newLength); |
| if (errorListener.errorReported) { |
| return; |
| } |
| // Produce an updated AST |
| IncrementalParser parser = new IncrementalParser( |
| cache.source, |
| scanner.tokenMap, |
| AnalysisErrorListener.NULL_LISTENER); |
| _updatedUnit = parser.reparse( |
| cache.resolvedUnit, |
| scanner.leftToken, |
| scanner.rightToken, |
| cache.offset, |
| cache.offset + cache.oldLength); |
| // Update the resolution |
| TypeProvider typeProvider = this.typeProvider; |
| if (_updatedUnit != null && typeProvider != null) { |
| CompilationUnitElement element = _updatedUnit.element; |
| if (element != null) { |
| LibraryElement library = element.library; |
| if (library != null) { |
| IncrementalResolver resolver = new IncrementalResolver( |
| <Source, CompilationUnit>{}, |
| element, |
| cache.offset, |
| cache.oldLength, |
| cache.newLength); |
| resolver.resolve(parser.updatedNode); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * The interface `InternalAnalysisContext` defines additional behavior for an analysis context |
| * that is required by internal users of the context. |
| */ |
| abstract class InternalAnalysisContext implements AnalysisContext { |
| /** |
| * Allow the client to supply its own content cache. This will take the |
| * place of the content cache created by default, allowing clients to share |
| * the content cache between contexts. |
| */ |
| set contentCache(ContentCache value); |
| |
| /** |
| * Return an array containing all of the sources that have been marked as priority sources. |
| * Clients must not modify the returned array. |
| * |
| * @return the sources that have been marked as priority sources |
| */ |
| List<Source> get prioritySources; |
| |
| /** |
| * Returns a statistics about this context. |
| */ |
| AnalysisContextStatistics get statistics; |
| |
| /** |
| * Returns a type provider for this context or throws an exception if dart:core cannot be |
| * resolved. |
| * |
| * @return the type provider (not `null`) |
| * @throws AnalysisException if dart:core cannot be resolved |
| */ |
| TypeProvider get typeProvider; |
| |
| /** |
| * Add the given source with the given information to this context. |
| * |
| * @param source the source to be added |
| * @param info the information about the source |
| */ |
| void addSourceInfo(Source source, SourceEntry info); |
| |
| /** |
| * Return an array containing the sources of the libraries that are exported by the library with |
| * the given source. The array will be empty if the given source is invalid, if the given source |
| * does not represent a library, or if the library does not export any other libraries. |
| * |
| * @param source the source representing the library whose exports are to be returned |
| * @return the sources of the libraries that are exported by the given library |
| * @throws AnalysisException if the exported libraries could not be computed |
| */ |
| List<Source> computeExportedLibraries(Source source); |
| |
| /** |
| * Return an array containing the sources of the libraries that are imported by the library with |
| * the given source. The array will be empty if the given source is invalid, if the given source |
| * does not represent a library, or if the library does not import any other libraries. |
| * |
| * @param source the source representing the library whose imports are to be returned |
| * @return the sources of the libraries that are imported by the given library |
| * @throws AnalysisException if the imported libraries could not be computed |
| */ |
| List<Source> computeImportedLibraries(Source source); |
| |
| /** |
| * Return an AST structure corresponding to the given source, but ensure that the structure has |
| * not already been resolved and will not be resolved by any other threads or in any other |
| * library. |
| * |
| * <b>Note:</b> This method cannot be used in an async environment |
| * |
| * @param source the compilation unit for which an AST structure should be returned |
| * @return the AST structure representing the content of the source |
| * @throws AnalysisException if the analysis could not be performed |
| */ |
| CompilationUnit computeResolvableCompilationUnit(Source source); |
| |
| /** |
| * Return context that owns the given source. |
| * |
| * @param source the source whose context is to be returned |
| * @return the context that owns the partition that contains the source |
| */ |
| InternalAnalysisContext getContextFor(Source source); |
| |
| /** |
| * 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); |
| |
| /** |
| * Respond to a change which has been made to the given [source] file. |
| * [originalContents] is the former contents of the file, and [newContents] |
| * is the updated contents. If [notify] is true, a source changed event is |
| * triggered. |
| * |
| * Normally it should not be necessary for clinets to call this function, |
| * since it will be automatically invoked in response to a call to |
| * [applyChanges] or [setContents]. However, if this analysis context is |
| * sharing its content cache with other contexts, then the client must |
| * manually update the content cache and call this function for each context. |
| * |
| * Return `true` if the change was significant to this context (i.e. [source] |
| * is either implicitly or explicitly analyzed by this context, and a change |
| * actually occurred). |
| */ |
| bool handleContentsChanged(Source source, String originalContents, |
| String newContents, bool notify); |
| |
| /** |
| * 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); |
| |
| /** |
| * Call the given callback function for eache cache item in the context. |
| */ |
| void visitCacheItems(void callback(Source source, SourceEntry dartEntry, |
| DataDescriptor rowDesc, CacheState state)); |
| } |
| |
| /** |
| * A `Logger` is an object 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 { |
| /** |
| * A logger that ignores all logging. |
| */ |
| static final Logger NULL = new NullLogger(); |
| |
| /** |
| * Log the given message as an error. The [message] is expected to be an |
| * explanation of why the error occurred or what it means. The [exception] is |
| * expected to be the reason for the error. At least one argument must be |
| * provided. |
| */ |
| void logError(String message, [CaughtException exception]); |
| |
| /** |
| * 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 |
| */ |
| @deprecated |
| void logError2(String message, Object exception); |
| |
| /** |
| * Log the given informational message. The [message] is expected to be an |
| * explanation of why the error occurred or what it means. The [exception] is |
| * expected to be the reason for the error. |
| */ |
| void logInformation(String message, [CaughtException exception]); |
| |
| /** |
| * 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 |
| */ |
| @deprecated |
| void logInformation2(String message, Object exception); |
| } |
| |
| /** |
| * An implementation of [Logger] that does nothing. |
| */ |
| class NullLogger implements Logger { |
| @override |
| void logError(String message, [CaughtException exception]) { |
| } |
| |
| @override |
| void logError2(String message, Object exception) { |
| } |
| |
| @override |
| void logInformation(String message, [CaughtException exception]) { |
| } |
| |
| @override |
| void logInformation2(String message, Object exception) { |
| } |
| } |
| |
| /** |
| * Instances of the class `ObsoleteSourceAnalysisException` represent an analysis attempt that |
| * failed because a source was deleted between the time the analysis started and the time the |
| * results of the analysis were ready to be recorded. |
| */ |
| class ObsoleteSourceAnalysisException extends AnalysisException { |
| /** |
| * The source that was removed while it was being analyzed. |
| */ |
| Source _source; |
| |
| /** |
| * Initialize a newly created exception to represent the removal of the given source. |
| * |
| * @param source the source that was removed while it was being analyzed |
| */ |
| ObsoleteSourceAnalysisException(Source source) |
| : super( |
| "The source '${source.fullName}' was removed while it was being analyzed") { |
| this._source = source; |
| } |
| |
| /** |
| * Return the source that was removed while it was being analyzed. |
| * |
| * @return the source that was removed |
| */ |
| Source get source => _source; |
| } |
| |
| /** |
| * Instances of the class `ParseDartTask` parse a specific source as a Dart file. |
| */ |
| class ParseDartTask extends AnalysisTask { |
| /** |
| * The source to be parsed. |
| */ |
| final Source source; |
| |
| /** |
| * The head of the token stream used for parsing. |
| */ |
| final Token _tokenStream; |
| |
| /** |
| * The line information associated with the source. |
| */ |
| final LineInfo lineInfo; |
| |
| /** |
| * The compilation unit that was produced by parsing the source. |
| */ |
| CompilationUnit _unit; |
| |
| /** |
| * A flag indicating whether the source contains a 'part of' directive. |
| */ |
| bool _containsPartOfDirective = false; |
| |
| /** |
| * A flag indicating whether the source contains any directive other than a 'part of' directive. |
| */ |
| bool _containsNonPartOfDirective = false; |
| |
| /** |
| * A set containing the sources referenced by 'export' directives. |
| */ |
| HashSet<Source> _exportedSources = new HashSet<Source>(); |
| |
| /** |
| * A set containing the sources referenced by 'import' directives. |
| */ |
| HashSet<Source> _importedSources = new HashSet<Source>(); |
| |
| /** |
| * A set containing the sources referenced by 'part' directives. |
| */ |
| HashSet<Source> _includedSources = new HashSet<Source>(); |
| |
| /** |
| * The errors that were produced by scanning and parsing the source. |
| */ |
| List<AnalysisError> _errors = AnalysisError.NO_ERRORS; |
| |
| /** |
| * Initialize a newly created task to perform analysis within the given context. |
| * |
| * @param context the context in which the task is to be performed |
| * @param source the source to be parsed |
| * @param tokenStream the head of the token stream used for parsing |
| * @param lineInfo the line information associated with the source |
| */ |
| ParseDartTask(InternalAnalysisContext context, this.source, this._tokenStream, |
| this.lineInfo) |
| : super(context); |
| |
| /** |
| * Return the compilation unit that was produced by parsing the source, or `null` if the |
| * task has not yet been performed or if an exception occurred. |
| * |
| * @return the compilation unit that was produced by parsing the source |
| */ |
| CompilationUnit get compilationUnit => _unit; |
| |
| /** |
| * Return the errors that were produced by scanning and parsing the source, or an empty array if |
| * the task has not yet been performed or if an exception occurred. |
| * |
| * @return the errors that were produced by scanning and parsing the source |
| */ |
| List<AnalysisError> get errors => _errors; |
| |
| /** |
| * Return an array containing the sources referenced by 'export' directives, or an empty array if |
| * the task has not yet been performed or if an exception occurred. |
| * |
| * @return an array containing the sources referenced by 'export' directives |
| */ |
| List<Source> get exportedSources => _toArray(_exportedSources); |
| |
| /** |
| * Return `true` if the source contains any directive other than a 'part of' directive, or |
| * `false` if the task has not yet been performed or if an exception occurred. |
| * |
| * @return `true` if the source contains any directive other than a 'part of' directive |
| */ |
| bool get hasNonPartOfDirective => _containsNonPartOfDirective; |
| |
| /** |
| * Return `true` if the source contains a 'part of' directive, or `false` if the task |
| * has not yet been performed or if an exception occurred. |
| * |
| * @return `true` if the source contains a 'part of' directive |
| */ |
| bool get hasPartOfDirective => _containsPartOfDirective; |
| |
| /** |
| * Return an array containing the sources referenced by 'import' directives, or an empty array if |
| * the task has not yet been performed or if an exception occurred. |
| * |
| * @return an array containing the sources referenced by 'import' directives |
| */ |
| List<Source> get importedSources => _toArray(_importedSources); |
| |
| /** |
| * Return an array containing the sources referenced by 'part' directives, or an empty array if |
| * the task has not yet been performed or if an exception occurred. |
| * |
| * @return an array containing the sources referenced by 'part' directives |
| */ |
| List<Source> get includedSources => _toArray(_includedSources); |
| |
| @override |
| String get taskDescription { |
| if (source == null) { |
| return "parse as dart null source"; |
| } |
| return "parse as dart ${source.fullName}"; |
| } |
| |
| @override |
| accept(AnalysisTaskVisitor visitor) => visitor.visitParseDartTask(this); |
| |
| @override |
| void internalPerform() { |
| // |
| // Then parse the token stream. |
| // |
| TimeCounter_TimeCounterHandle timeCounterParse = |
| PerformanceStatistics.parse.start(); |
| try { |
| RecordingErrorListener errorListener = new RecordingErrorListener(); |
| Parser parser = new Parser(source, errorListener); |
| AnalysisOptions options = context.analysisOptions; |
| parser.parseFunctionBodies = options.analyzeFunctionBodies; |
| _unit = parser.parseCompilationUnit(_tokenStream); |
| _unit.lineInfo = lineInfo; |
| AnalysisContext analysisContext = context; |
| for (Directive directive in _unit.directives) { |
| if (directive is PartOfDirective) { |
| _containsPartOfDirective = true; |
| } else { |
| _containsNonPartOfDirective = true; |
| if (directive is UriBasedDirective) { |
| Source referencedSource = |
| resolveDirective(analysisContext, source, directive, errorListener); |
| if (referencedSource != null) { |
| if (directive is ExportDirective) { |
| _exportedSources.add(referencedSource); |
| } else if (directive is ImportDirective) { |
| _importedSources.add(referencedSource); |
| } else if (directive is PartDirective) { |
| if (referencedSource != source) { |
| _includedSources.add(referencedSource); |
| } |
| } else { |
| throw new AnalysisException( |
| "$runtimeType failed to handle a ${directive.runtimeType}"); |
| } |
| } |
| } |
| } |
| } |
| _errors = errorListener.getErrorsForSource(source); |
| } finally { |
| timeCounterParse.stop(); |
| } |
| } |
| |
| /** |
| * Efficiently convert the given set of sources to an array. |
| * |
| * @param sources the set to be converted |
| * @return an array containing all of the sources in the given set |
| */ |
| List<Source> _toArray(HashSet<Source> sources) { |
| int size = sources.length; |
| if (size == 0) { |
| return Source.EMPTY_ARRAY; |
| } |
| return new List.from(sources); |
| } |
| |
| /** |
| * Return the result of resolving the URI of the given URI-based directive against the URI of the |
| * given library, or `null` if the URI is not valid. |
| * |
| * @param context the context in which the resolution is to be performed |
| * @param librarySource the source representing the library containing the directive |
| * @param directive the directive which URI should be resolved |
| * @param errorListener the error listener to which errors should be reported |
| * @return the result of resolving the URI against the URI of the library |
| */ |
| static Source resolveDirective(AnalysisContext context, Source librarySource, |
| UriBasedDirective directive, AnalysisErrorListener errorListener) { |
| StringLiteral uriLiteral = directive.uri; |
| String uriContent = uriLiteral.stringValue; |
| if (uriContent != null) { |
| uriContent = uriContent.trim(); |
| directive.uriContent = uriContent; |
| } |
| UriValidationCode code = directive.validate(); |
| if (code == null) { |
| String encodedUriContent = Uri.encodeFull(uriContent); |
| Source source = |
| context.sourceFactory.resolveUri(librarySource, encodedUriContent); |
| directive.source = source; |
| return source; |
| } |
| if (code == UriValidationCode.URI_WITH_DART_EXT_SCHEME) { |
| return null; |
| } |
| if (code == UriValidationCode.URI_WITH_INTERPOLATION) { |
| errorListener.onError( |
| new AnalysisError.con2( |
| librarySource, |
| uriLiteral.offset, |
| uriLiteral.length, |
| CompileTimeErrorCode.URI_WITH_INTERPOLATION)); |
| return null; |
| } |
| if (code == UriValidationCode.INVALID_URI) { |
| errorListener.onError( |
| new AnalysisError.con2( |
| librarySource, |
| uriLiteral.offset, |
| uriLiteral.length, |
| CompileTimeErrorCode.INVALID_URI, |
| [uriContent])); |
| return null; |
| } |
| throw new RuntimeException( |
| message: "Failed to handle validation code: $code"); |
| } |
| } |
| |
| /** |
| * Instances of the class `ParseHtmlTask` parse a specific source as an HTML file. |
| */ |
| class ParseHtmlTask extends AnalysisTask { |
| /** |
| * The name of the 'src' attribute in a HTML tag. |
| */ |
| static String _ATTRIBUTE_SRC = "src"; |
| |
| /** |
| * The name of the 'script' tag in an HTML file. |
| */ |
| static String _TAG_SCRIPT = "script"; |
| |
| /** |
| * The source to be parsed. |
| */ |
| final Source source; |
| |
| /** |
| * The contents of the source. |
| */ |
| final String _content; |
| |
| /** |
| * The line information that was produced. |
| */ |
| LineInfo _lineInfo; |
| |
| /** |
| * The HTML unit that was produced by parsing the source. |
| */ |
| ht.HtmlUnit _unit; |
| |
| /** |
| * The errors that were produced by scanning and parsing the source. |
| */ |
| List<AnalysisError> _errors = AnalysisError.NO_ERRORS; |
| |
| /** |
| * An array containing the sources of the libraries that are referenced within the HTML. |
| */ |
| List<Source> _referencedLibraries = Source.EMPTY_ARRAY; |
| |
| /** |
| * Initialize a newly created task to perform analysis within the given context. |
| * |
| * @param context the context in which the task is to be performed |
| * @param source the source to be parsed |
| * @param content the contents of the source |
| */ |
| ParseHtmlTask(InternalAnalysisContext context, this.source, this._content) |
| : super(context); |
| |
| /** |
| * Return the errors that were produced by scanning and parsing the source, or `null` if the |
| * task has not yet been performed or if an exception occurred. |
| * |
| * @return the errors that were produced by scanning and parsing the source |
| */ |
| List<AnalysisError> get errors => _errors; |
| |
| /** |
| * Return the HTML unit that was produced by parsing the source. |
| * |
| * @return the HTML unit that was produced by parsing the source |
| */ |
| ht.HtmlUnit get htmlUnit => _unit; |
| |
| /** |
| * Return the sources of libraries that are referenced in the specified HTML file. |
| * |
| * @return the sources of libraries that are referenced in the HTML file |
| */ |
| List<Source> get librarySources { |
| List<Source> libraries = new List<Source>(); |
| _unit.accept(new ParseHtmlTask_getLibrarySources(this, libraries)); |
| if (libraries.isEmpty) { |
| return Source.EMPTY_ARRAY; |
| } |
| return libraries; |
| } |
| |
| /** |
| * Return the line information that was produced, or `null` if the task has not yet been |
| * performed or if an exception occurred. |
| * |
| * @return the line information that was produced |
| */ |
| LineInfo get lineInfo => _lineInfo; |
| |
| /** |
| * Return an array containing the sources of the libraries that are referenced within the HTML. |
| * |
| * @return the sources of the libraries that are referenced within the HTML |
| */ |
| List<Source> get referencedLibraries => _referencedLibraries; |
| |
| @override |
| String get taskDescription { |
| if (source == null) { |
| return "parse as html null source"; |
| } |
| return "parse as html ${source.fullName}"; |
| } |
| |
| @override |
| accept(AnalysisTaskVisitor visitor) => visitor.visitParseHtmlTask(this); |
| |
| @override |
| void internalPerform() { |
| try { |
| ht.AbstractScanner scanner = new ht.StringScanner(source, _content); |
| scanner.passThroughElements = <String>[_TAG_SCRIPT]; |
| ht.Token token = scanner.tokenize(); |
| _lineInfo = new LineInfo(scanner.lineStarts); |
| RecordingErrorListener errorListener = new RecordingErrorListener(); |
| _unit = new ht.HtmlParser(source, errorListener).parse(token, _lineInfo); |
| _unit.accept( |
| new RecursiveXmlVisitor_ParseHtmlTask_internalPerform(this, errorListener)); |
| _errors = errorListener.getErrorsForSource(source); |
| _referencedLibraries = librarySources; |
| } catch (exception, stackTrace) { |
| throw new AnalysisException( |
| "Exception", |
| new CaughtException(exception, stackTrace)); |
| } |
| } |
| |
| /** |
| * Resolves directives in the given [CompilationUnit]. |
| */ |
| void _resolveScriptDirectives(CompilationUnit script, |
| AnalysisErrorListener errorListener) { |
| if (script == null) { |
| return; |
| } |
| AnalysisContext analysisContext = context; |
| for (Directive directive in script.directives) { |
| if (directive is UriBasedDirective) { |
| ParseDartTask.resolveDirective( |
| analysisContext, |
| source, |
| directive, |
| errorListener); |
| } |
| } |
| } |
| } |
| |
| class ParseHtmlTask_getLibrarySources extends ht.RecursiveXmlVisitor<Object> { |
| final ParseHtmlTask _task; |
| |
| List<Source> libraries; |
| |
| ParseHtmlTask_getLibrarySources(this._task, this.libraries) : super(); |
| |
| @override |
| Object visitHtmlScriptTagNode(ht.HtmlScriptTagNode node) { |
| ht.XmlAttributeNode scriptAttribute = null; |
| for (ht.XmlAttributeNode attribute in node.attributes) { |
| if (javaStringEqualsIgnoreCase( |
| attribute.name, |
| ParseHtmlTask._ATTRIBUTE_SRC)) { |
| scriptAttribute = attribute; |
| } |
| } |
| if (scriptAttribute != null) { |
| try { |
| Uri uri = new Uri(path: scriptAttribute.text); |
| String fileName = uri.path; |
| Source librarySource = |
| _task.context.sourceFactory.resolveUri(_task.source, fileName); |
| if (_task.context.exists(librarySource)) { |
| libraries.add(librarySource); |
| } |
| } on FormatException catch (e) { |
| // ignored - invalid URI reported during resolution phase |
| } |
| } |
| return super.visitHtmlScriptTagNode(node); |
| } |
| } |
| |
| /** |
| * Instances of the class `PartitionManager` manage the partitions that can be shared between |
| * analysis contexts. |
| */ |
| class PartitionManager { |
| /** |
| * The default cache size for a Dart SDK partition. |
| */ |
| static int _DEFAULT_SDK_CACHE_SIZE = 256; |
| |
| /** |
| * A table mapping SDK's to the partitions used for those SDK's. |
| */ |
| HashMap<DartSdk, SdkCachePartition> _sdkPartitions = |
| new HashMap<DartSdk, SdkCachePartition>(); |
| |
| /** |
| * Clear any cached data being maintained by this manager. |
| */ |
| void clearCache() { |
| _sdkPartitions.clear(); |
| } |
| |
| /** |
| * Return the partition being used for the given SDK, creating the partition |
| * if necessary. |
| * |
| * [sdk] - the SDK for which a partition is being requested. |
| */ |
| SdkCachePartition forSdk(DartSdk sdk) { |
| // Call sdk.context now, because when it creates a new |
| // InternalAnalysisContext instance, it calls forSdk() again, so creates an |
| // SdkCachePartition instance. |
| // So, if we initialize context after "partition == null", we end up |
| // with two SdkCachePartition instances. |
| InternalAnalysisContext sdkContext = sdk.context; |
| // Check cache for an existing partition. |
| SdkCachePartition partition = _sdkPartitions[sdk]; |
| if (partition == null) { |
| partition = new SdkCachePartition(sdkContext, _DEFAULT_SDK_CACHE_SIZE); |
| _sdkPartitions[sdk] = partition; |
| } |
| return partition; |
| } |
| } |
| |
| /** |
| * Representation of a pending computation which is based on the results of |
| * analysis that may or may not have been completed. |
| */ |
| class PendingFuture<T> { |
| /** |
| * The context in which this computation runs. |
| */ |
| final AnalysisContextImpl _context; |
| |
| /** |
| * The source used by this computation to compute its value. |
| */ |
| final Source source; |
| |
| /** |
| * The function which implements the computation. |
| */ |
| final PendingFutureComputer<T> _computeValue; |
| |
| /** |
| * The completer that should be completed once the computation has succeeded. |
| */ |
| CancelableCompleter<T> _completer; |
| |
| PendingFuture(this._context, this.source, this._computeValue) { |
| _completer = new CancelableCompleter<T>(_onCancel); |
| } |
| |
| /** |
| * Retrieve the future which will be completed when this object is |
| * successfully evaluated. |
| */ |
| CancelableFuture<T> get future => _completer.future; |
| |
| /** |
| * Execute [_computeValue], passing it the given [sourceEntry], and complete |
| * the pending future if it's appropriate to do so. If the pending future is |
| * completed by this call, true is returned; otherwise false is returned. |
| * |
| * Once this function has returned true, it should not be called again. |
| * |
| * Other than completing the future, this method is free of side effects. |
| * Note that any code the client has attached to the future will be executed |
| * in a microtask, so there is no danger of side effects occurring due to |
| * client callbacks. |
| */ |
| bool evaluate(SourceEntry sourceEntry) { |
| assert(!_completer.isCompleted); |
| try { |
| T result = _computeValue(sourceEntry); |
| if (result == null) { |
| return false; |
| } else { |
| _completer.complete(result); |
| return true; |
| } |
| } catch (exception, stackTrace) { |
| _completer.completeError(exception, stackTrace); |
| return true; |
| } |
| } |
| |
| /** |
| * No further analysis updates are expected which affect this future, so |
| * complete it with an AnalysisNotScheduledError in order to avoid |
| * deadlocking the client. |
| */ |
| void forciblyComplete() { |
| try { |
| throw new AnalysisNotScheduledError(); |
| } catch (exception, stackTrace) { |
| _completer.completeError(exception, stackTrace); |
| } |
| } |
| |
| void _onCancel() { |
| _context._cancelFuture(this); |
| } |
| } |
| |
| /** |
| * Container with global [AnalysisContext] performance statistics. |
| */ |
| class PerformanceStatistics { |
| /** |
| * The [TimeCounter] for time spent in reading files. |
| */ |
| static TimeCounter io = new TimeCounter(); |
| |
| /** |
| * The [TimeCounter] for time spent in scanning. |
| */ |
| static TimeCounter scan = new TimeCounter(); |
| |
| /** |
| * The [TimeCounter] for time spent in parsing. |
| */ |
| static TimeCounter parse = new TimeCounter(); |
| |
| /** |
| * The [TimeCounter] for time spent in resolving. |
| */ |
| static TimeCounter resolve = new TimeCounter(); |
| |
| /** |
| * The [TimeCounter] for time spent in error verifier. |
| */ |
| static TimeCounter errors = new TimeCounter(); |
| |
| /** |
| * The [TimeCounter] for time spent in hints generator. |
| */ |
| static TimeCounter hints = new TimeCounter(); |
| |
| /** |
| * The [TimeCounter] for time spent in linting. |
| */ |
| static TimeCounter lint = new TimeCounter(); |
| |
| /** |
| * Reset all of the time counters to zero. |
| */ |
| static void reset() { |
| io = new TimeCounter(); |
| scan = new TimeCounter(); |
| parse = new TimeCounter(); |
| resolve = new TimeCounter(); |
| errors = new TimeCounter(); |
| hints = new TimeCounter(); |
| lint = new TimeCounter(); |
| } |
| } |
| |
| /** |
| * Instances of the class `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 HashMap of lists containing the errors that were collected, keyed by each [Source]. |
| */ |
| Map<Source, HashSet<AnalysisError>> _errors = |
| new HashMap<Source, HashSet<AnalysisError>>(); |
| |
| /** |
| * Answer the errors collected by the listener. |
| * |
| * @return an array of errors (not `null`, contains no `null`s) |
| */ |
| List<AnalysisError> get errors { |
| int numEntries = _errors.length; |
| if (numEntries == 0) { |
| return AnalysisError.NO_ERRORS; |
| } |
| List<AnalysisError> resultList = new List<AnalysisError>(); |
| for (HashSet<AnalysisError> errors in _errors.values) { |
| resultList.addAll(errors); |
| } |
| return resultList; |
| } |
| |
| /** |
| * Add all of the errors recorded by the given listener to this listener. |
| * |
| * @param listener the listener that has recorded the errors to be added |
| */ |
| void addAll(RecordingErrorListener listener) { |
| for (AnalysisError error in listener.errors) { |
| onError(error); |
| } |
| } |
| |
| /** |
| * Answer the errors collected by the listener for some passed [Source]. |
| * |
| * @param source some [Source] for which the caller wants the set of [AnalysisError]s |
| * collected by this listener |
| * @return the errors collected by the listener for the passed [Source] |
| */ |
| List<AnalysisError> getErrorsForSource(Source source) { |
| HashSet<AnalysisError> errorsForSource = _errors[source]; |
| if (errorsForSource == null) { |
| return AnalysisError.NO_ERRORS; |
| } else { |
| return new List.from(errorsForSource); |
| } |
| } |
| |
| @override |
| void onError(AnalysisError error) { |
| Source source = error.source; |
| HashSet<AnalysisError> errorsForSource = _errors[source]; |
| if (_errors[source] == null) { |
| errorsForSource = new HashSet<AnalysisError>(); |
| _errors[source] = errorsForSource; |
| } |
| errorsForSource.add(error); |
| } |
| } |
| |
| class RecursiveXmlVisitor_ParseHtmlTask_internalPerform extends |
| ht.RecursiveXmlVisitor<Object> { |
| final ParseHtmlTask ParseHtmlTask_this; |
| |
| RecordingErrorListener errorListener; |
| |
| RecursiveXmlVisitor_ParseHtmlTask_internalPerform(this.ParseHtmlTask_this, |
| this.errorListener) |
| : super(); |
| |
| @override |
| Object visitHtmlScriptTagNode(ht.HtmlScriptTagNode node) { |
| ParseHtmlTask_this._resolveScriptDirectives(node.script, errorListener); |
| return null; |
| } |
| } |
| |
| class RecursiveXmlVisitor_ResolveHtmlTask_internalPerform extends |
| ht.RecursiveXmlVisitor<Object> { |
| final ResolveHtmlTask ResolveHtmlTask_this; |
| |
| RecordingErrorListener errorListener; |
| |
| RecursiveXmlVisitor_ResolveHtmlTask_internalPerform(this.ResolveHtmlTask_this, |
| this.errorListener) |
| : super(); |
| |
| @override |
| Object visitHtmlScriptTagNode(ht.HtmlScriptTagNode node) { |
| CompilationUnit script = node.script; |
| if (script != null) { |
| GenerateDartErrorsTask.validateDirectives( |
| ResolveHtmlTask_this.context, |
| ResolveHtmlTask_this.source, |
| script, |
| errorListener); |
| } |
| return null; |
| } |
| } |
| |
| /** |
| * A `ResolutionEraser` removes any resolution information from an AST |
| * structure when used to visit that structure. |
| */ |
| class ResolutionEraser extends GeneralizingAstVisitor<Object> { |
| @override |
| Object visitAssignmentExpression(AssignmentExpression node) { |
| node.staticElement = null; |
| node.propagatedElement = null; |
| return super.visitAssignmentExpression(node); |
| } |
| |
| @override |
| Object visitBinaryExpression(BinaryExpression node) { |
| node.staticElement = null; |
| node.propagatedElement = null; |
| return super.visitBinaryExpression(node); |
| } |
| |
| @override |
| Object visitBreakStatement(BreakStatement node) { |
| node.target = null; |
| return super.visitBreakStatement(node); |
| } |
| |
| @override |
| Object visitCompilationUnit(CompilationUnit node) { |
| node.element = null; |
| return super.visitCompilationUnit(node); |
| } |
| |
| @override |
| Object visitConstructorDeclaration(ConstructorDeclaration node) { |
| node.element = null; |
| return super.visitConstructorDeclaration(node); |
| } |
| |
| @override |
| Object visitConstructorName(ConstructorName node) { |
| node.staticElement = null; |
| return super.visitConstructorName(node); |
| } |
| |
| @override |
| Object visitContinueStatement(ContinueStatement node) { |
| node.target = null; |
| return super.visitContinueStatement(node); |
| } |
| |
| @override |
| Object visitDirective(Directive node) { |
| node.element = null; |
| return super.visitDirective(node); |
| } |
| |
| @override |
| Object visitExpression(Expression node) { |
| node.staticType = null; |
| node.propagatedType = null; |
| return super.visitExpression(node); |
| } |
| |
| @override |
| Object visitFunctionExpression(FunctionExpression node) { |
| node.element = null; |
| return super.visitFunctionExpression(node); |
| } |
| |
| @override |
| Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) { |
| node.staticElement = null; |
| node.propagatedElement = null; |
| return super.visitFunctionExpressionInvocation(node); |
| } |
| |
| @override |
| Object visitIndexExpression(IndexExpression node) { |
| node.staticElement = null; |
| node.propagatedElement = null; |
| return super.visitIndexExpression(node); |
| } |
| |
| @override |
| Object visitInstanceCreationExpression(InstanceCreationExpression node) { |
| node.staticElement = null; |
| return super.visitInstanceCreationExpression(node); |
| } |
| |
| @override |
| Object visitPostfixExpression(PostfixExpression node) { |
| node.staticElement = null; |
| node.propagatedElement = null; |
| return super.visitPostfixExpression(node); |
| } |
| |
| @override |
| Object visitPrefixExpression(PrefixExpression node) { |
| node.staticElement = null; |
| node.propagatedElement = null; |
| return super.visitPrefixExpression(node); |
| } |
| |
| @override |
| Object |
| visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) { |
| node.staticElement = null; |
| return super.visitRedirectingConstructorInvocation(node); |
| } |
| |
| @override |
| Object visitSimpleIdentifier(SimpleIdentifier node) { |
| node.staticElement = null; |
| node.propagatedElement = null; |
| return super.visitSimpleIdentifier(node); |
| } |
| |
| @override |
| Object visitSuperConstructorInvocation(SuperConstructorInvocation node) { |
| node.staticElement = null; |
| return super.visitSuperConstructorInvocation(node); |
| } |
| |
| /** |
| * Remove any resolution information from the given AST structure. |
| */ |
| static void erase(AstNode node) { |
| node.accept(new ResolutionEraser()); |
| } |
| } |
| |
| /** |
| * A `ResolutionState` maintains the information produced by resolving a |
| * compilation unit as part of a specific library. |
| */ |
| class ResolutionState { |
| /** |
| * The next resolution state or `null` if none. |
| */ |
| ResolutionState _nextState; |
| |
| /** |
| * The source for the defining compilation unit of the library that contains this unit. If this |
| * unit is the defining compilation unit for it's library, then this will be the source for this |
| * unit. |
| */ |
| Source _librarySource; |
| |
| /** |
| * A table mapping descriptors to the cached results for those descriptors. |
| * If there is no entry for a given descriptor then the state is implicitly |
| * [CacheState.INVALID] and the value is implicitly the default value. |
| */ |
| Map<DataDescriptor, CachedResult> resultMap = |
| new HashMap<DataDescriptor, CachedResult>(); |
| |
| /** |
| * Flush any AST structures being maintained by this state. |
| */ |
| void flushAstStructures() { |
| _flush(DartEntry.BUILT_UNIT); |
| _flush(DartEntry.RESOLVED_UNIT); |
| if (_nextState != null) { |
| _nextState.flushAstStructures(); |
| } |
| } |
| |
| /** |
| * Return the state of the data represented by the given [descriptor]. |
| */ |
| CacheState getState(DataDescriptor descriptor) { |
| CachedResult result = resultMap[descriptor]; |
| if (result == null) { |
| return CacheState.INVALID; |
| } |
| return result.state; |
| } |
| |
| /** |
| * Return the value of the data represented by the given [descriptor], or |
| * `null` if the data represented by the descriptor is not valid. |
| */ |
| /*<V>*/ dynamic /*V*/ getValue(DataDescriptor /*<V>*/ descriptor) { |
| CachedResult result = resultMap[descriptor]; |
| if (result == null) { |
| return descriptor.defaultValue; |
| } |
| return result.value; |
| } |
| |
| /** |
| * Return `true` if the state of any data value is [CacheState.ERROR]. |
| */ |
| bool hasErrorState() { |
| for (CachedResult result in resultMap.values) { |
| if (result.state == CacheState.ERROR) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Invalidate all of the resolution information associated with the compilation unit. |
| */ |
| void invalidateAllResolutionInformation() { |
| _nextState = null; |
| _librarySource = null; |
| setState(DartEntry.BUILT_UNIT, CacheState.INVALID); |
| setState(DartEntry.BUILT_ELEMENT, CacheState.INVALID); |
| setState(DartEntry.HINTS, CacheState.INVALID); |
| setState(DartEntry.LINTS, CacheState.INVALID); |
| setState(DartEntry.RESOLVED_UNIT, CacheState.INVALID); |
| setState(DartEntry.RESOLUTION_ERRORS, CacheState.INVALID); |
| setState(DartEntry.VERIFICATION_ERRORS, CacheState.INVALID); |
| } |
| |
| /** |
| * Record that an exception occurred while attempting to build the element |
| * model for the source associated with this state. |
| */ |
| void recordBuildElementError() { |
| setState(DartEntry.BUILT_UNIT, CacheState.ERROR); |
| setState(DartEntry.BUILT_ELEMENT, CacheState.ERROR); |
| recordResolutionError(); |
| } |
| |
| /** |
| * Record that an exception occurred while attempting to generate hints for |
| * the source associated with this entry. This will set the state of all |
| * verification information as being in error. |
| */ |
| void recordHintError() { |
| setState(DartEntry.HINTS, CacheState.ERROR); |
| } |
| |
| /** |
| * Record that an exception occurred while attempting to generate lints for |
| * the source associated with this entry. This will set the state of all |
| * verification information as being in error. |
| */ |
| void recordLintError() { |
| setState(DartEntry.LINTS, CacheState.ERROR); |
| } |
| |
| /** |
| * Record that an exception occurred while attempting to resolve the source |
| * associated with this state. |
| */ |
| void recordResolutionError() { |
| setState(DartEntry.RESOLVED_UNIT, CacheState.ERROR); |
| setState(DartEntry.RESOLUTION_ERRORS, CacheState.ERROR); |
| recordVerificationError(); |
| } |
| |
| /** |
| * Record that an exception occurred while attempting to scan or parse the |
| * source associated with this entry. This will set the state of all |
| * resolution-based information as being in error. |
| */ |
| void recordResolutionErrorsInAllLibraries() { |
| recordBuildElementError(); |
| if (_nextState != null) { |
| _nextState.recordResolutionErrorsInAllLibraries(); |
| } |
| } |
| |
| /** |
| * Record that an exception occurred while attempting to generate errors and |
| * warnings for the source associated with this entry. This will set the state |
| * of all verification information as being in error. |
| */ |
| void recordVerificationError() { |
| setState(DartEntry.VERIFICATION_ERRORS, CacheState.ERROR); |
| recordHintError(); |
| } |
| |
| /** |
| * Set the state of the data represented by the given [descriptor] to the |
| * given [state]. |
| */ |
| void setState(DataDescriptor descriptor, CacheState state) { |
| if (state == CacheState.VALID) { |
| throw new ArgumentError("use setValue() to set the state to VALID"); |
| } |
| if (state == CacheState.INVALID) { |
| resultMap.remove(descriptor); |
| } else { |
| CachedResult result = |
| resultMap.putIfAbsent(descriptor, () => new CachedResult(descriptor)); |
| result.state = state; |
| if (state != CacheState.IN_PROCESS) { |
| // |
| // If the state is in-process, we can leave the current value in the |
| // cache for any 'get' methods to access. |
| // |
| result.value = descriptor.defaultValue; |
| } |
| } |
| } |
| |
| /** |
| * Set the value of the data represented by the given [descriptor] to the |
| * given [value]. |
| */ |
| void setValue(DataDescriptor /*<V>*/ descriptor, dynamic /*V*/ value) { |
| CachedResult result = |
| resultMap.putIfAbsent(descriptor, () => new CachedResult(descriptor)); |
| result.state = CacheState.VALID; |
| result.value = value == null ? descriptor.defaultValue : value; |
| } |
| |
| /** |
| * Flush the value of the data described by the [descriptor]. |
| */ |
| void _flush(DataDescriptor descriptor) { |
| CachedResult result = resultMap[descriptor]; |
| if (result != null && result.state == CacheState.VALID) { |
| result.state = CacheState.FLUSHED; |
| result.value = descriptor.defaultValue; |
| } |
| } |
| |
| /** |
| * Write a textual representation of the difference between the old entry and this entry to the |
| * given string builder. |
| * |
| * @param builder the string builder to which the difference is to be written |
| * @param oldEntry the entry that was replaced by this entry |
| * @return `true` if some difference was written |
| */ |
| bool _writeDiffOn(StringBuffer buffer, bool needsSeparator, |
| DartEntry oldEntry) { |
| needsSeparator = _writeStateDiffOn( |
| buffer, |
| needsSeparator, |
| "resolvedUnit", |
| DartEntry.RESOLVED_UNIT, |
| oldEntry); |
| needsSeparator = _writeStateDiffOn( |
| buffer, |
| needsSeparator, |
| "resolutionErrors", |
| DartEntry.RESOLUTION_ERRORS, |
| oldEntry); |
| needsSeparator = _writeStateDiffOn( |
| buffer, |
| needsSeparator, |
| "verificationErrors", |
| DartEntry.VERIFICATION_ERRORS, |
| oldEntry); |
| needsSeparator = |
| _writeStateDiffOn(buffer, needsSeparator, "hints", DartEntry.HINTS, oldEntry); |
| needsSeparator = |
| _writeStateDiffOn(buffer, needsSeparator, "lints", DartEntry.LINTS, oldEntry); |
| return needsSeparator; |
| } |
| |
| /** |
| * Write a textual representation of this state to the given builder. The result will only be |
| * used for debugging purposes. |
| * |
| * @param builder the builder to which the text should be written |
| */ |
| void _writeOn(StringBuffer buffer) { |
| if (_librarySource != null) { |
| _writeStateOn(buffer, "builtElement", DartEntry.BUILT_ELEMENT); |
| _writeStateOn(buffer, "builtUnit", DartEntry.BUILT_UNIT); |
| _writeStateOn(buffer, "resolvedUnit", DartEntry.RESOLVED_UNIT); |
| _writeStateOn(buffer, "resolutionErrors", DartEntry.RESOLUTION_ERRORS); |
| _writeStateOn( |
| buffer, |
| "verificationErrors", |
| DartEntry.VERIFICATION_ERRORS); |
| _writeStateOn(buffer, "hints", DartEntry.HINTS); |
| _writeStateOn(buffer, "lints", DartEntry.LINTS); |
| if (_nextState != null) { |
| _nextState._writeOn(buffer); |
| } |
| } |
| } |
| |
| /** |
| * Write a textual representation of the difference between the state of the |
| * value described by the given [descriptor] between the [oldEntry] and this |
| * entry to the given [buffer]. Return `true` if some difference was written. |
| */ |
| bool _writeStateDiffOn(StringBuffer buffer, bool needsSeparator, String label, |
| DataDescriptor descriptor, SourceEntry oldEntry) { |
| CacheState oldState = oldEntry.getState(descriptor); |
| CacheState newState = getState(descriptor); |
| if (oldState != newState) { |
| if (needsSeparator) { |
| buffer.write("; "); |
| } |
| buffer.write(label); |
| buffer.write(" = "); |
| buffer.write(oldState); |
| buffer.write(" -> "); |
| buffer.write(newState); |
| return true; |
| } |
| return needsSeparator; |
| } |
| |
| /** |
| * Write a textual representation of the state of the value described by the |
| * given [descriptor] to the given bugger, prefixed by the given [label] to |
| * the given [buffer]. |
| */ |
| void _writeStateOn(StringBuffer buffer, String label, |
| DataDescriptor descriptor) { |
| CachedResult result = resultMap[descriptor]; |
| buffer.write("; "); |
| buffer.write(label); |
| buffer.write(" = "); |
| buffer.write(result == null ? CacheState.INVALID : result.state); |
| } |
| } |
| |
| /** |
| * A `ResolvableCompilationUnit` is a compilation unit that is not referenced by |
| * any other objects. It is used by the [LibraryResolver] to resolve a library. |
| */ |
| class ResolvableCompilationUnit { |
| /** |
| * The source of the compilation unit. |
| */ |
| final Source source; |
| |
| /** |
| * The compilation unit. |
| */ |
| final CompilationUnit compilationUnit; |
| |
| /** |
| * Initialize a newly created holder to hold the given values. |
| * |
| * @param source the source of the compilation unit |
| * @param unit the AST that was created from the source |
| */ |
| ResolvableCompilationUnit(this.source, this.compilationUnit); |
| } |
| |
| /** |
| * Instances of the class `ResolveDartLibraryTask` resolve a specific Dart library. |
| */ |
| class ResolveDartLibraryCycleTask extends AnalysisTask { |
| /** |
| * The source representing the file whose compilation unit is to be returned. TODO(brianwilkerson) |
| * This should probably be removed, but is being left in for now to ease the transition. |
| */ |
| final Source unitSource; |
| |
| /** |
| * The source representing the library to be resolved. |
| */ |
| final Source librarySource; |
| |
| /** |
| * The libraries that are part of the cycle containing the library to be resolved. |
| */ |
| final List<ResolvableLibrary> _librariesInCycle; |
| |
| /** |
| * The library resolver holding information about the libraries that were resolved. |
| */ |
| LibraryResolver2 _resolver; |
| |
| /** |
| * Initialize a newly created task to perform analysis within the given context. |
| * |
| * @param context the context in which the task is to be performed |
| * @param unitSource the source representing the file whose compilation unit is to be returned |
| * @param librarySource the source representing the library to be resolved |
| * @param librariesInCycle the libraries that are part of the cycle containing the library to be |
| * resolved |
| */ |
| ResolveDartLibraryCycleTask(InternalAnalysisContext context, this.unitSource, |
| this.librarySource, this._librariesInCycle) |
| : super(context); |
| |
| /** |
| * Return the library resolver holding information about the libraries that were resolved. |
| * |
| * @return the library resolver holding information about the libraries that were resolved |
| */ |
| LibraryResolver2 get libraryResolver => _resolver; |
| |
| @override |
| String get taskDescription { |
| if (librarySource == null) { |
| return "resolve library null source"; |
| } |
| return "resolve library ${librarySource.fullName}"; |
| } |
| |
| @override |
| accept(AnalysisTaskVisitor visitor) => |
| visitor.visitResolveDartLibraryCycleTask(this); |
| |
| @override |
| void internalPerform() { |
| _resolver = new LibraryResolver2(context); |
| _resolver.resolveLibrary(librarySource, _librariesInCycle); |
| } |
| } |
| |
| /** |
| * Instances of the class `ResolveDartLibraryTask` resolve a specific Dart library. |
| */ |
| class ResolveDartLibraryTask extends AnalysisTask { |
| /** |
| * The source representing the file whose compilation unit is to be returned. |
| */ |
| final Source unitSource; |
| |
| /** |
| * The source representing the library to be resolved. |
| */ |
| final Source librarySource; |
| |
| /** |
| * The library resolver holding information about the libraries that were resolved. |
| */ |
| LibraryResolver _resolver; |
| |
| /** |
| * Initialize a newly created task to perform analysis within the given context. |
| * |
| * @param context the context in which the task is to be performed |
| * @param unitSource the source representing the file whose compilation unit is to be returned |
| * @param librarySource the source representing the library to be resolved |
| */ |
| ResolveDartLibraryTask(InternalAnalysisContext context, this.unitSource, |
| this.librarySource) |
| : super(context); |
| |
| /** |
| * Return the library resolver holding information about the libraries that were resolved. |
| * |
| * @return the library resolver holding information about the libraries that were resolved |
| */ |
| LibraryResolver get libraryResolver => _resolver; |
| |
| @override |
| String get taskDescription { |
| if (librarySource == null) { |
| return "resolve library null source"; |
| } |
| return "resolve library ${librarySource.fullName}"; |
| } |
| |
| @override |
| accept(AnalysisTaskVisitor visitor) => |
| visitor.visitResolveDartLibraryTask(this); |
| |
| @override |
| void internalPerform() { |
| _resolver = new LibraryResolver(context); |
| _resolver.resolveLibrary(librarySource, true); |
| } |
| } |
| |
| /** |
| * Instances of the class `ResolveDartUnitTask` resolve a single Dart file based on a existing |
| * element model. |
| */ |
| class ResolveDartUnitTask extends AnalysisTask { |
| /** |
| * The source that is to be resolved. |
| */ |
| final Source source; |
| |
| /** |
| * The element model for the library containing the source. |
| */ |
| final LibraryElement _libraryElement; |
| |
| /** |
| * The compilation unit that was resolved by this task. |
| */ |
| CompilationUnit _resolvedUnit; |
| |
| /** |
| * Initialize a newly created task to perform analysis within the given context. |
| * |
| * @param context the context in which the task is to be performed |
| * @param source the source to be parsed |
| * @param libraryElement the element model for the library containing the source |
| */ |
| ResolveDartUnitTask(InternalAnalysisContext context, this.source, |
| this._libraryElement) |
| : super(context); |
| |
| /** |
| * Return the source for the library containing the source that is to be resolved. |
| * |
| * @return the source for the library containing the source that is to be resolved |
| */ |
| Source get librarySource => _libraryElement.source; |
| |
| /** |
| * Return the compilation unit that was resolved by this task. |
| * |
| * @return the compilation unit that was resolved by this task |
| */ |
| CompilationUnit get resolvedUnit => _resolvedUnit; |
| |
| @override |
| String get taskDescription { |
| Source librarySource = _libraryElement.source; |
| if (librarySource == null) { |
| return "resolve unit null source"; |
| } |
| return "resolve unit ${librarySource.fullName}"; |
| } |
| |
| @override |
| accept(AnalysisTaskVisitor visitor) => visitor.visitResolveDartUnitTask(this); |
| |
| @override |
| void internalPerform() { |
| TypeProvider typeProvider = |
| (_libraryElement.context as InternalAnalysisContext).typeProvider; |
| CompilationUnit unit = context.computeResolvableCompilationUnit(source); |
| if (unit == null) { |
| throw new AnalysisException( |
| "Internal error: computeResolvableCompilationUnit returned a value without a parsed Dart unit"); |
| } |
| // |
| // Resolve names in declarations. |
| // |
| new DeclarationResolver().resolve(unit, _find(_libraryElement, source)); |
| // |
| // Resolve the type names. |
| // |
| RecordingErrorListener errorListener = new RecordingErrorListener(); |
| TypeResolverVisitor typeResolverVisitor = new TypeResolverVisitor.con2( |
| _libraryElement, |
| source, |
| typeProvider, |
| errorListener); |
| unit.accept(typeResolverVisitor); |
| // |
| // Resolve the rest of the structure |
| // |
| InheritanceManager inheritanceManager = |
| new InheritanceManager(_libraryElement); |
| ResolverVisitor resolverVisitor = new ResolverVisitor.con2( |
| _libraryElement, |
| source, |
| typeProvider, |
| inheritanceManager, |
| errorListener); |
| unit.accept(resolverVisitor); |
| // |
| // Perform additional error checking. |
| // |
| TimeCounter_TimeCounterHandle counterHandleErrors = |
| PerformanceStatistics.errors.start(); |
| try { |
| ErrorReporter errorReporter = new ErrorReporter(errorListener, source); |
| ErrorVerifier errorVerifier = new ErrorVerifier( |
| errorReporter, |
| _libraryElement, |
| typeProvider, |
| inheritanceManager); |
| unit.accept(errorVerifier); |
| // TODO(paulberry): as a temporary workaround for issue 21572, |
| // ConstantVerifier is being run right after ConstantValueComputer, so we |
| // don't need to run it here. Once issue 21572 is fixed, re-enable the |
| // call to ConstantVerifier. |
| // ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, _libraryElement, typeProvider); |
| // unit.accept(constantVerifier); |
| } finally { |
| counterHandleErrors.stop(); |
| } |
| // |
| // Capture the results. |
| // |
| _resolvedUnit = unit; |
| } |
| |
| /** |
| * Search the compilation units that are part of the given library and return the element |
| * representing the compilation unit with the given source. Return `null` if there is no |
| * such compilation unit. |
| * |
| * @param libraryElement the element representing the library being searched through |
| * @param unitSource the source for the compilation unit whose element is to be returned |
| * @return the element representing the compilation unit |
| */ |
| CompilationUnitElement _find(LibraryElement libraryElement, |
| Source unitSource) { |
| CompilationUnitElement element = libraryElement.definingCompilationUnit; |
| if (element.source == unitSource) { |
| return element; |
| } |
| for (CompilationUnitElement partElement in libraryElement.parts) { |
| if (partElement.source == unitSource) { |
| return partElement; |
| } |
| } |
| return null; |
| } |
| } |
| |
| /** |
| * Instances of the class `ResolveHtmlTask` resolve a specific source as an HTML file. |
| */ |
| class ResolveHtmlTask extends AnalysisTask { |
| /** |
| * The source to be resolved. |
| */ |
| final Source source; |
| |
| /** |
| * The time at which the contents of the source were last modified. |
| */ |
| final int modificationTime; |
| |
| /** |
| * The HTML unit to be resolved. |
| */ |
| final ht.HtmlUnit _unit; |
| |
| /** |
| * The [HtmlUnit] that was resolved by this task. |
| */ |
| ht.HtmlUnit _resolvedUnit; |
| |
| /** |
| * The element produced by resolving the source. |
| */ |
| HtmlElement _element = null; |
| |
| /** |
| * The resolution errors that were discovered while resolving the source. |
| */ |
| List<AnalysisError> _resolutionErrors = AnalysisError.NO_ERRORS; |
| |
| /** |
| * Initialize a newly created task to perform analysis within the given context. |
| * |
| * @param context the context in which the task is to be performed |
| * @param source the source to be resolved |
| * @param modificationTime the time at which the contents of the source were last modified |
| * @param unit the HTML unit to be resolved |
| */ |
| ResolveHtmlTask(InternalAnalysisContext context, this.source, |
| this.modificationTime, this._unit) |
| : super(context); |
| |
| HtmlElement get element => _element; |
| |
| List<AnalysisError> get resolutionErrors => _resolutionErrors; |
| |
| /** |
| * Return the [HtmlUnit] that was resolved by this task. |
| * |
| * @return the [HtmlUnit] that was resolved by this task |
| */ |
| ht.HtmlUnit get resolvedUnit => _resolvedUnit; |
| |
| @override |
| String get taskDescription { |
| if (source == null) { |
| return "resolve as html null source"; |
| } |
| return "resolve as html ${source.fullName}"; |
| } |
| |
| @override |
| accept(AnalysisTaskVisitor visitor) => visitor.visitResolveHtmlTask(this); |
| |
| @override |
| void internalPerform() { |
| // |
| // Build the standard HTML element. |
| // |
| HtmlUnitBuilder builder = new HtmlUnitBuilder(context); |
| _element = builder.buildHtmlElement(source, _unit); |
| RecordingErrorListener errorListener = builder.errorListener; |
| // |
| // Validate the directives |
| // |
| _unit.accept( |
| new RecursiveXmlVisitor_ResolveHtmlTask_internalPerform(this, errorListener)); |
| // |
| // Record all resolution errors. |
| // |
| _resolutionErrors = errorListener.getErrorsForSource(source); |
| // |
| // Remember the resolved unit. |
| // |
| _resolvedUnit = _unit; |
| } |
| } |
| |
| /** |
| * The enumerated type `RetentionPriority` represents the priority of data in the cache in |
| * terms of the desirability of retaining some specified data about a specified source. |
| */ |
| class RetentionPriority extends Enum<RetentionPriority> { |
| /** |
| * A priority indicating that a given piece of data can be removed from the cache without |
| * reservation. |
| */ |
| static const RetentionPriority LOW = const RetentionPriority('LOW', 0); |
| |
| /** |
| * A priority indicating that a given piece of data should not be removed from the cache unless |
| * there are no sources for which the corresponding data has a lower priority. Currently used for |
| * data that is needed in order to finish some outstanding analysis task. |
| */ |
| static const RetentionPriority MEDIUM = const RetentionPriority('MEDIUM', 1); |
| |
| /** |
| * A priority indicating that a given piece of data should not be removed from the cache. |
| * Currently used for data related to a priority source. |
| */ |
| static const RetentionPriority HIGH = const RetentionPriority('HIGH', 2); |
| |
| static const List<RetentionPriority> values = const [LOW, MEDIUM, HIGH]; |
| |
| const RetentionPriority(String name, int ordinal) : super(name, ordinal); |
| } |
| |
| /** |
| * Instances of the class `ScanDartTask` scan a specific source as a Dart file. |
| */ |
| class ScanDartTask extends AnalysisTask { |
| /** |
| * The source to be scanned. |
| */ |
| final Source source; |
| |
| /** |
| * The contents of the source. |
| */ |
| final String _content; |
| |
| /** |
| * The token stream that was produced by scanning the source. |
| */ |
| Token _tokenStream; |
| |
| /** |
| * The line information that was produced. |
| */ |
| LineInfo _lineInfo; |
| |
| /** |
| * The errors that were produced by scanning the source. |
| */ |
| List<AnalysisError> _errors = AnalysisError.NO_ERRORS; |
| |
| /** |
| * Initialize a newly created task to perform analysis within the given context. |
| * |
| * @param context the context in which the task is to be performed |
| * @param source the source to be parsed |
| * @param content the contents of the source |
| */ |
| ScanDartTask(InternalAnalysisContext context, this.source, this._content) |
| : super(context); |
| |
| /** |
| * Return the errors that were produced by scanning the source, or `null` if the task has |
| * not yet been performed or if an exception occurred. |
| * |
| * @return the errors that were produced by scanning the source |
| */ |
| List<AnalysisError> get errors => _errors; |
| |
| /** |
| * Return the line information that was produced, or `null` if the task has not yet been |
| * performed or if an exception occurred. |
| * |
| * @return the line information that was produced |
| */ |
| LineInfo get lineInfo => _lineInfo; |
| |
| @override |
| String get taskDescription { |
| if (source == null) { |
| return "scan as dart null source"; |
| } |
| return "scan as dart ${source.fullName}"; |
| } |
| |
| /** |
| * Return the token stream that was produced by scanning the source, or `null` if the task |
| * has not yet been performed or if an exception occurred. |
| * |
| * @return the token stream that was produced by scanning the source |
| */ |
| Token get tokenStream => _tokenStream; |
| |
| @override |
| accept(AnalysisTaskVisitor visitor) => visitor.visitScanDartTask(this); |
| |
| @override |
| void internalPerform() { |
| RecordingErrorListener errorListener = new RecordingErrorListener(); |
| TimeCounter_TimeCounterHandle timeCounterScan = |
| PerformanceStatistics.scan.start(); |
| try { |
| Scanner scanner = |
| new Scanner(source, new CharSequenceReader(_content), errorListener); |
| scanner.preserveComments = context.analysisOptions.preserveComments; |
| _tokenStream = scanner.tokenize(); |
| _lineInfo = new LineInfo(scanner.lineStarts); |
| _errors = errorListener.getErrorsForSource(source); |
| } catch (exception, stackTrace) { |
| throw new AnalysisException( |
| "Exception", |
| new CaughtException(exception, stackTrace)); |
| } finally { |
| timeCounterScan.stop(); |
| } |
| } |
| } |
| |
| /** |
| * Instances of the class `SdkAnalysisContext` implement an [AnalysisContext] that only |
| * contains sources for a Dart SDK. |
| */ |
| class SdkAnalysisContext extends AnalysisContextImpl { |
| @override |
| AnalysisCache createCacheFromSourceFactory(SourceFactory factory) { |
| if (factory == null) { |
| return super.createCacheFromSourceFactory(factory); |
| } |
| DartSdk sdk = factory.dartSdk; |
| if (sdk == null) { |
| throw new IllegalArgumentException( |
| "The source factory for an SDK analysis context must have a DartUriResolver"); |
| } |
| return new AnalysisCache( |
| <CachePartition>[AnalysisEngine.instance.partitionManager.forSdk(sdk)]); |
| } |
| } |
| |
| /** |
| * Instances of the class `SdkCachePartition` implement a cache partition that contains all of |
| * the sources in the SDK. |
| */ |
| class SdkCachePartition extends CachePartition { |
| /** |
| * Initialize a newly created partition. |
| * |
| * @param context the context that owns this partition |
| * @param maxCacheSize the maximum number of sources for which AST structures should be kept in |
| * the cache |
| */ |
| SdkCachePartition(InternalAnalysisContext context, int maxCacheSize) |
| : super(context, maxCacheSize, DefaultRetentionPolicy.POLICY); |
| |
| @override |
| bool contains(Source source) => source.isInSystemLibrary; |
| } |
| |
| /** |
| * A `SourceEntry` maintains the information cached by an analysis context about |
| * an individual source, no matter what kind of source it is. |
| */ |
| abstract class SourceEntry { |
| /** |
| * The data descriptor representing the contents of the source. |
| */ |
| static final DataDescriptor<String> CONTENT = |
| new DataDescriptor<String>("SourceEntry.CONTENT"); |
| |
| /** |
| * The data descriptor representing the line information. |
| */ |
| static final DataDescriptor<LineInfo> LINE_INFO = |
| new DataDescriptor<LineInfo>("SourceEntry.LINE_INFO"); |
| |
| /** |
| * The index of the flag indicating whether the source was explicitly added to |
| * the context or whether the source was implicitly added because it was |
| * referenced by another source. |
| */ |
| static int _EXPLICITLY_ADDED_FLAG = 0; |
| |
| /** |
| * The most recent time at which the state of the source matched the state |
| * represented by this entry. |
| */ |
| int modificationTime = 0; |
| |
| /** |
| * The exception that caused one or more values to have a state of |
| * [CacheState.ERROR]. |
| */ |
| CaughtException exception; |
| |
| /** |
| * A bit-encoding of boolean flags associated with this element. |
| */ |
| int _flags = 0; |
| |
| /** |
| * A table mapping data descriptors to the cached results for those |
| * descriptors. |
| */ |
| Map<DataDescriptor, CachedResult> resultMap = |
| new HashMap<DataDescriptor, CachedResult>(); |
| |
| /** |
| * Get a list of all the library-independent descriptors for which values may |
| * be stored in this SourceEntry. |
| */ |
| List<DataDescriptor> get descriptors { |
| return <DataDescriptor>[SourceEntry.CONTENT, SourceEntry.LINE_INFO]; |
| } |
| |
| /** |
| * Return `true` if the source was explicitly added to the context or `false` |
| * if the source was implicitly added because it was referenced by another |
| * source. |
| */ |
| bool get explicitlyAdded => _getFlag(_EXPLICITLY_ADDED_FLAG); |
| |
| /** |
| * Set whether the source was explicitly added to the context to match the |
| * [explicitlyAdded] flag. |
| */ |
| void set explicitlyAdded(bool explicitlyAdded) { |
| _setFlag(_EXPLICITLY_ADDED_FLAG, explicitlyAdded); |
| } |
| |
| /** |
| * Return the kind of the source, or `null` if the kind is not currently |
| * cached. |
| */ |
| SourceKind get kind; |
| |
| /** |
| * Fix the state of the [exception] to match the current state of the entry. |
| */ |
| void fixExceptionState() { |
| if (hasErrorState()) { |
| if (exception == null) { |
| // |
| // This code should never be reached, but is a fail-safe in case an |
| // exception is not recorded when it should be. |
| // |
| String message = "State set to ERROR without setting an exception"; |
| exception = new CaughtException(new AnalysisException(message), null); |
| } |
| } else { |
| exception = null; |
| } |
| } |
| |
| /** |
| * Return a textual representation of the difference between the [oldEntry] |
| * and this entry. The difference is represented as a sequence of fields whose |
| * value would change if the old entry were converted into the new entry. |
| */ |
| String getDiff(SourceEntry oldEntry) { |
| StringBuffer buffer = new StringBuffer(); |
| _writeDiffOn(buffer, oldEntry); |
| return buffer.toString(); |
| } |
| |
| /** |
| * Return the state of the data represented by the given [descriptor]. |
| */ |
| CacheState getState(DataDescriptor descriptor) { |
| if (!_isValidDescriptor(descriptor)) { |
| throw new ArgumentError("Invalid descriptor: $descriptor"); |
| } |
| CachedResult result = resultMap[descriptor]; |
| if (result == null) { |
| return CacheState.INVALID; |
| } |
| return result.state; |
| } |
| |
| /** |
| * Return the value of the data represented by the given [descriptor], or |
| * `null` if the data represented by the descriptor is not valid. |
| */ |
| /*<V>*/ dynamic /*V*/ getValue(DataDescriptor /*<V>*/ descriptor) { |
| if (!_isValidDescriptor(descriptor)) { |
| throw new ArgumentError("Invalid descriptor: $descriptor"); |
| } |
| CachedResult result = resultMap[descriptor]; |
| if (result == null) { |
| return descriptor.defaultValue; |
| } |
| return result.value; |
| } |
| |
| /** |
| * Return `true` if the state of any data value is [CacheState.ERROR]. |
| */ |
| bool hasErrorState() { |
| for (CachedResult result in resultMap.values) { |
| if (result.state == CacheState.ERROR) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Invalidate all of the information associated with this source. |
| */ |
| void invalidateAllInformation() { |
| setState(CONTENT, CacheState.INVALID); |
| setState(LINE_INFO, CacheState.INVALID); |
| } |
| |
| /** |
| * Record that an [exception] occurred while attempting to get the contents of |
| * the source represented by this entry. This will set the state of all |
| * information, including any resolution-based information, as being in error. |
| */ |
| void recordContentError(CaughtException exception) { |
| setState(CONTENT, CacheState.ERROR); |
| recordScanError(exception); |
| } |
| |
| /** |
| * Record that an [exception] occurred while attempting to scan or parse the |
| * entry represented by this entry. This will set the state of all |
| * information, including any resolution-based information, as being in error. |
| */ |
| void recordScanError(CaughtException exception) { |
| this.exception = exception; |
| setState(LINE_INFO, CacheState.ERROR); |
| } |
| |
| /** |
| * Set the state of the data represented by the given [descriptor] to the |
| * given [state]. |
| */ |
| void setState(DataDescriptor descriptor, CacheState state) { |
| if (!_isValidDescriptor(descriptor)) { |
| throw new ArgumentError("Invalid descriptor: $descriptor"); |
| } |
| if (state == CacheState.VALID) { |
| throw new ArgumentError("use setValue() to set the state to VALID"); |
| } |
| _validateStateChange(descriptor, state); |
| if (state == CacheState.INVALID) { |
| resultMap.remove(descriptor); |
| } else { |
| CachedResult result = |
| resultMap.putIfAbsent(descriptor, () => new CachedResult(descriptor)); |
| result.state = state; |
| if (state != CacheState.IN_PROCESS) { |
| // |
| // If the state is in-process, we can leave the current value in the |
| // cache for any 'get' methods to access. |
| // |
| result.value = descriptor.defaultValue; |
| } |
| } |
| } |
| |
| /** |
| * Set the value of the data represented by the given [descriptor] to the |
| * given [value]. |
| */ |
| void setValue(DataDescriptor /*<V>*/ descriptor, dynamic /*V*/ value) { |
| if (!_isValidDescriptor(descriptor)) { |
| throw new ArgumentError("Invalid descriptor: $descriptor"); |
| } |
| _validateStateChange(descriptor, CacheState.VALID); |
| CachedResult result = |
| resultMap.putIfAbsent(descriptor, () => new CachedResult(descriptor)); |
| result.state = CacheState.VALID; |
| result.value = value == null ? descriptor.defaultValue : value; |
| } |
| |
| @override |
| String toString() { |
| StringBuffer buffer = new StringBuffer(); |
| _writeOn(buffer); |
| return buffer.toString(); |
| } |
| |
| /** |
| * Flush the value of the data described by the [descriptor]. |
| */ |
| void _flush(DataDescriptor descriptor) { |
| CachedResult result = resultMap[descriptor]; |
| if (result != null && result.state == CacheState.VALID) { |
| _validateStateChange(descriptor, CacheState.FLUSHED); |
| result.state = CacheState.FLUSHED; |
| result.value = descriptor.defaultValue; |
| } |
| } |
| |
| /** |
| * Return the value of the flag with the given [index]. |
| */ |
| bool _getFlag(int index) => BooleanArray.get(_flags, index); |
| |
| /** |
| * Return `true` if the [descriptor] is valid for this entry. |
| */ |
| bool _isValidDescriptor(DataDescriptor descriptor) { |
| return descriptor == CONTENT || descriptor == LINE_INFO; |
| } |
| |
| /** |
| * Set the value of the flag with the given [index] to the given [value]. |
| */ |
| void _setFlag(int index, bool value) { |
| _flags = BooleanArray.set(_flags, index, value); |
| } |
| |
| /** |
| * If the state of the value described by the given [descriptor] is changing |
| * from ERROR to anything else, capture the information. This is an attempt to |
| * discover the underlying cause of a long-standing bug. |
| */ |
| void _validateStateChange(DataDescriptor descriptor, CacheState newState) { |
| // TODO(brianwilkerson) Decide whether we still want to capture this data. |
| // if (descriptor != CONTENT) { |
| // return; |
| // } |
| // CachedResult result = resultMap[CONTENT]; |
| // if (result != null && result.state == CacheState.ERROR) { |
| // String message = |
| // "contentState changing from ${result.state} to $newState"; |
| // InstrumentationBuilder builder = |
| // Instrumentation.builder2("SourceEntry-validateStateChange"); |
| // builder.data3("message", message); |
| // //builder.data("source", source.getFullName()); |
| // builder.record(new CaughtException(new AnalysisException(message), null)); |
| // builder.log(); |
| // } |
| } |
| |
| /** |
| * Write a textual representation of the difference between the [oldEntry] and |
| * this entry to the given string [buffer]. Return `true` if some difference |
| * was written. |
| */ |
| bool _writeDiffOn(StringBuffer buffer, SourceEntry oldEntry) { |
| bool needsSeparator = false; |
| CaughtException oldException = oldEntry.exception; |
| if (!identical(oldException, exception)) { |
| buffer.write("exception = "); |
| buffer.write(oldException.runtimeType); |
| buffer.write(" -> "); |
| buffer.write(exception.runtimeType); |
| needsSeparator = true; |
| } |
| int oldModificationTime = oldEntry.modificationTime; |
| if (oldModificationTime != modificationTime) { |
| if (needsSeparator) { |
| buffer.write("; "); |
| } |
| buffer.write("time = "); |
| buffer.write(oldModificationTime); |
| buffer.write(" -> "); |
| buffer.write(modificationTime); |
| needsSeparator = true; |
| } |
| needsSeparator = |
| _writeStateDiffOn(buffer, needsSeparator, "content", CONTENT, oldEntry); |
| needsSeparator = |
| _writeStateDiffOn(buffer, needsSeparator, "lineInfo", LINE_INFO, oldEntry); |
| return needsSeparator; |
| } |
| |
| /** |
| * Write a textual representation of this entry to the given [buffer]. The |
| * result should only be used for debugging purposes. |
| */ |
| void _writeOn(StringBuffer buffer) { |
| buffer.write("time = "); |
| buffer.write(modificationTime); |
| _writeStateOn(buffer, "content", CONTENT); |
| _writeStateOn(buffer, "lineInfo", LINE_INFO); |
| } |
| |
| /** |
| * Write a textual representation of the difference between the state of the |
| * value described by the given [descriptor] between the [oldEntry] and this |
| * entry to the given [buffer]. Return `true` if some difference was written. |
| */ |
| bool _writeStateDiffOn(StringBuffer buffer, bool needsSeparator, String label, |
| DataDescriptor descriptor, SourceEntry oldEntry) { |
| CacheState oldState = oldEntry.getState(descriptor); |
| CacheState newState = getState(descriptor); |
| if (oldState != newState) { |
| if (needsSeparator) { |
| buffer.write("; "); |
| } |
| buffer.write(label); |
| buffer.write(" = "); |
| buffer.write(oldState); |
| buffer.write(" -> "); |
| buffer.write(newState); |
| return true; |
| } |
| return needsSeparator; |
| } |
| |
| /** |
| * Write a textual representation of the state of the value described by the |
| * given [descriptor] to the given bugger, prefixed by the given [label] to |
| * the given [buffer]. |
| */ |
| void _writeStateOn(StringBuffer buffer, String label, |
| DataDescriptor descriptor) { |
| CachedResult result = resultMap[descriptor]; |
| buffer.write("; "); |
| buffer.write(label); |
| buffer.write(" = "); |
| buffer.write(result == null ? CacheState.INVALID : result.state); |
| } |
| } |
| |
| /** |
| * The enumerated type `Priority` defines the priority levels used to return sources in an |
| * optimal order. A smaller ordinal value equates to a higher priority. |
| */ |
| class SourcePriority extends Enum<SourcePriority> { |
| /** |
| * Used for a Dart source that is known to be a part contained in a library that was recently |
| * resolved. These parts are given a higher priority because there is a high probability that |
| * their AST structure is still in the cache and therefore would not need to be re-created. |
| */ |
| static const SourcePriority PRIORITY_PART = |
| const SourcePriority('PRIORITY_PART', 0); |
| |
| /** |
| * Used for a Dart source that is known to be a library. |
| */ |
| static const SourcePriority LIBRARY = const SourcePriority('LIBRARY', 1); |
| |
| /** |
| * Used for a Dart source whose kind is unknown. |
| */ |
| static const SourcePriority UNKNOWN = const SourcePriority('UNKNOWN', 2); |
| |
| /** |
| * Used for a Dart source that is known to be a part but whose library has not yet been resolved. |
| */ |
| static const SourcePriority NORMAL_PART = |
| const SourcePriority('NORMAL_PART', 3); |
| |
| /** |
| * Used for an HTML source. |
| */ |
| static const SourcePriority HTML = const SourcePriority('HTML', 4); |
| |
| static const List<SourcePriority> values = const [ |
| PRIORITY_PART, |
| LIBRARY, |
| UNKNOWN, |
| NORMAL_PART, |
| HTML]; |
| |
| const SourcePriority(String name, int ordinal) : super(name, ordinal); |
| } |
| |
| /** |
| * [SourcesChangedEvent] indicates which sources have been added, removed, |
| * or whose contents have changed. |
| */ |
| class SourcesChangedEvent { |
| |
| /** |
| * The internal representation of what has changed. |
| * Clients should not access this field directly. |
| */ |
| final ChangeSet _changeSet; |
| |
| /** |
| * Construct an instance representing the given changes. |
| */ |
| SourcesChangedEvent(ChangeSet changeSet) : _changeSet = changeSet; |
| |
| /** |
| * Construct an instance representing a source content change. |
| */ |
| factory SourcesChangedEvent.changedContent(Source source, String contents) { |
| ChangeSet changeSet = new ChangeSet(); |
| changeSet.changedContent(source, contents); |
| return new SourcesChangedEvent(changeSet); |
| } |
| |
| /** |
| * Construct an instance representing a source content change. |
| */ |
| factory SourcesChangedEvent.changedRange(Source source, String contents, |
| int offset, int oldLength, int newLength) { |
| ChangeSet changeSet = new ChangeSet(); |
| changeSet.changedRange(source, contents, offset, oldLength, newLength); |
| return new SourcesChangedEvent(changeSet); |
| } |
| |
| /** |
| * Return the collection of sources for which content has changed. |
| */ |
| Iterable<Source> get changedSources { |
| List<Source> changedSources = new List.from(_changeSet.changedSources); |
| changedSources.addAll(_changeSet.changedContents.keys); |
| changedSources.addAll(_changeSet.changedRanges.keys); |
| return changedSources; |
| } |
| |
| /** |
| * Return `true` if any sources were added. |
| */ |
| bool get wereSourcesAdded => _changeSet.addedSources.length > 0; |
| |
| /** |
| * Return `true` if any sources were removed or deleted. |
| */ |
| bool get wereSourcesRemovedOrDeleted => |
| _changeSet.removedSources.length > 0 || |
| _changeSet.removedContainers.length > 0 || |
| _changeSet.deletedSources.length > 0; |
| } |
| |
| /** |
| * Instances of the class `TimestampedData` represent analysis data for which we have a |
| * modification time. |
| */ |
| class TimestampedData<E> { |
| /** |
| * The modification time of the source from which the data was created. |
| */ |
| final int modificationTime; |
| |
| /** |
| * The data that was created from the source. |
| */ |
| final E data; |
| |
| /** |
| * Initialize a newly created holder to hold the given values. |
| * |
| * @param modificationTime the modification time of the source from which the data was created |
| * @param unit the data that was created from the source |
| */ |
| TimestampedData(this.modificationTime, this.data); |
| } |
| |
| /** |
| * Instances of the class `UniversalCachePartition` implement a cache partition that contains |
| * all sources not contained in other partitions. |
| */ |
| class UniversalCachePartition extends CachePartition { |
| /** |
| * Initialize a newly created partition. |
| * |
| * @param context the context that owns this partition |
| * @param maxCacheSize the maximum number of sources for which AST structures should be kept in |
| * the cache |
| * @param retentionPolicy the policy used to determine which pieces of data to remove from the |
| * cache |
| */ |
| UniversalCachePartition(InternalAnalysisContext context, int maxCacheSize, |
| CacheRetentionPolicy retentionPolicy) |
| : super(context, maxCacheSize, retentionPolicy); |
| |
| @override |
| bool contains(Source source) => true; |
| } |
| |
| /** |
| * The unique instances of the class `WaitForAsyncTask` represents a state in which there is |
| * no analysis work that can be done until some asynchronous task (such as IO) has completed, but |
| * where analysis is not yet complete. |
| */ |
| class WaitForAsyncTask extends AnalysisTask { |
| /** |
| * The unique instance of this class. |
| */ |
| static WaitForAsyncTask _UniqueInstance = new WaitForAsyncTask(); |
| |
| /** |
| * Return the unique instance of this class. |
| * |
| * @return the unique instance of this class |
| */ |
| static WaitForAsyncTask get instance => _UniqueInstance; |
| |
| /** |
| * Prevent the creation of instances of this class. |
| */ |
| WaitForAsyncTask() : super(null); |
| |
| @override |
| String get taskDescription => "Waiting for async analysis"; |
| |
| @override |
| accept(AnalysisTaskVisitor visitor) => null; |
| |
| @override |
| void internalPerform() { |
| // There is no work to be done. |
| } |
| } |
| |
| /** |
| * Instances of the class `WorkManager` manage a list of sources that need to have analysis |
| * work performed on them. |
| */ |
| class WorkManager { |
| /** |
| * An array containing the various queues is priority order. |
| */ |
| List<List<Source>> _workQueues; |
| |
| /** |
| * Initialize a newly created manager to have no work queued up. |
| */ |
| WorkManager() { |
| int queueCount = SourcePriority.values.length; |
| _workQueues = new List<List>(queueCount); |
| for (int i = 0; i < queueCount; i++) { |
| _workQueues[i] = new List<Source>(); |
| } |
| } |
| |
| /** |
| * Record that the given source needs to be analyzed. The priority level is used to control when |
| * the source will be analyzed with respect to other sources. If the source was previously added |
| * then it's priority is updated. If it was previously added with the same priority then it's |
| * position in the queue is unchanged. |
| * |
| * @param source the source that needs to be analyzed |
| * @param priority the priority level of the source |
| */ |
| void add(Source source, SourcePriority priority) { |
| int queueCount = _workQueues.length; |
| int ordinal = priority.ordinal; |
| for (int i = 0; i < queueCount; i++) { |
| List<Source> queue = _workQueues[i]; |
| if (i == ordinal) { |
| if (!queue.contains(source)) { |
| queue.add(source); |
| } |
| } else { |
| queue.remove(source); |
| } |
| } |
| } |
| |
| /** |
| * Record that the given source needs to be analyzed. The priority level is used to control when |
| * the source will be analyzed with respect to other sources. If the source was previously added |
| * then it's priority is updated. In either case, it will be analyzed before other sources of the |
| * same priority. |
| * |
| * @param source the source that needs to be analyzed |
| * @param priority the priority level of the source |
| */ |
| void addFirst(Source source, SourcePriority priority) { |
| int queueCount = _workQueues.length; |
| int ordinal = priority.ordinal; |
| for (int i = 0; i < queueCount; i++) { |
| List<Source> queue = _workQueues[i]; |
| if (i == ordinal) { |
| queue.remove(source); |
| queue.insert(0, source); |
| } else { |
| queue.remove(source); |
| } |
| } |
| } |
| |
| /** |
| * Return an iterator that can be used to access the sources to be analyzed in the order in which |
| * they should be analyzed. |
| * |
| * <b>Note:</b> As with other iterators, no sources can be added or removed from this work manager |
| * while the iterator is being used. Unlike some implementations, however, the iterator will not |
| * detect when this requirement has been violated; it might work correctly, it might return the |
| * wrong source, or it might throw an exception. |
| * |
| * @return an iterator that can be used to access the next source to be analyzed |
| */ |
| WorkManager_WorkIterator iterator() => new WorkManager_WorkIterator(this); |
| |
| /** |
| * Record that the given source is fully analyzed. |
| * |
| * @param source the source that is fully analyzed |
| */ |
| void remove(Source source) { |
| int queueCount = _workQueues.length; |
| for (int i = 0; i < queueCount; i++) { |
| _workQueues[i].remove(source); |
| } |
| } |
| |
| @override |
| String toString() { |
| StringBuffer buffer = new StringBuffer(); |
| List<SourcePriority> priorities = SourcePriority.values; |
| bool needsSeparator = false; |
| int queueCount = _workQueues.length; |
| for (int i = 0; i < queueCount; i++) { |
| List<Source> queue = _workQueues[i]; |
| if (!queue.isEmpty) { |
| if (needsSeparator) { |
| buffer.write("; "); |
| } |
| buffer.write(priorities[i]); |
| buffer.write(": "); |
| int queueSize = queue.length; |
| for (int j = 0; j < queueSize; j++) { |
| if (j > 0) { |
| buffer.write(", "); |
| } |
| buffer.write(queue[j].fullName); |
| } |
| needsSeparator = true; |
| } |
| } |
| return buffer.toString(); |
| } |
| } |
| |
| /** |
| * Instances of the class `WorkIterator` implement an iterator that returns the sources in a |
| * work manager in the order in which they are to be analyzed. |
| */ |
| class WorkManager_WorkIterator { |
| final WorkManager _manager; |
| |
| /** |
| * The index of the work queue through which we are currently iterating. |
| */ |
| int _queueIndex = 0; |
| |
| /** |
| * The index of the next element of the work queue to be returned. |
| */ |
| int _index = -1; |
| |
| /** |
| * Initialize a newly created iterator to be ready to return the first element in the iteration. |
| */ |
| WorkManager_WorkIterator(this._manager) { |
| _advance(); |
| } |
| |
| /** |
| * Return `true` if there is another [Source] available for processing. |
| * |
| * @return `true` if there is another [Source] available for processing |
| */ |
| bool get hasNext => _queueIndex < _manager._workQueues.length; |
| |
| /** |
| * Return the next [Source] available for processing and advance so that the returned |
| * source will not be returned again. |
| * |
| * @return the next [Source] available for processing |
| */ |
| Source next() { |
| if (!hasNext) { |
| throw new NoSuchElementException(); |
| } |
| Source source = _manager._workQueues[_queueIndex][_index]; |
| _advance(); |
| return source; |
| } |
| |
| /** |
| * Increment the [index] and [queueIndex] so that they are either indicating the |
| * next source to be returned or are indicating that there are no more sources to be returned. |
| */ |
| void _advance() { |
| _index++; |
| if (_index >= _manager._workQueues[_queueIndex].length) { |
| _index = 0; |
| _queueIndex++; |
| while (_queueIndex < _manager._workQueues.length && |
| _manager._workQueues[_queueIndex].isEmpty) { |
| _queueIndex++; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Helper class used to create futures for AnalysisContextImpl. Using a helper |
| * class allows us to preserve the generic parameter T. |
| */ |
| class _AnalysisFutureHelper<T> { |
| final AnalysisContextImpl _context; |
| |
| _AnalysisFutureHelper(this._context); |
| |
| /** |
| * Return a future that will be completed with the result of calling |
| * [computeValue]. If [computeValue] returns non-null, the future will be |
| * completed immediately with the resulting value. If it returns null, then |
| * it will be re-executed in the future, after the next time the cached |
| * information for [source] has changed. If [computeValue] throws an |
| * exception, the future will fail with that exception. |
| * |
| * If the [computeValue] still returns null after there is no further |
| * analysis to be done for [source], then the future will be completed with |
| * the error AnalysisNotScheduledError. |
| * |
| * Since [computeValue] will be called while the state of analysis is being |
| * updated, it should be free of side effects so that it doesn't cause |
| * reentrant changes to the analysis state. |
| */ |
| CancelableFuture<T> computeAsync(Source source, T |
| computeValue(SourceEntry sourceEntry)) { |
| if (_context.isDisposed) { |
| // No further analysis is expected, so return a future that completes |
| // immediately with AnalysisNotScheduledError. |
| return new CancelableFuture.error(new AnalysisNotScheduledError()); |
| } |
| SourceEntry sourceEntry = _context.getReadableSourceEntryOrNull(source); |
| if (sourceEntry == null) { |
| return new CancelableFuture.error(new AnalysisNotScheduledError()); |
| } |
| PendingFuture pendingFuture = |
| new PendingFuture<T>(_context, source, computeValue); |
| if (!pendingFuture.evaluate(sourceEntry)) { |
| _context._pendingFutureSources.putIfAbsent( |
| source, |
| () => <PendingFuture>[]).add(pendingFuture); |
| } |
| return pendingFuture.future; |
| } |
| } |
| |
| class _ElementByIdFinder extends GeneralizingElementVisitor { |
| final int _id; |
| Element result; |
| |
| _ElementByIdFinder(this._id); |
| |
| @override |
| visitElement(Element element) { |
| if (element.id == _id) { |
| result = element; |
| throw new _ElementByIdFinderException(); |
| } |
| super.visitElement(element); |
| } |
| } |
| |
| class _ElementByIdFinderException { |
| } |