| /* |
| * Copyright (c) 2013, the Dart project authors. |
| * |
| * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except |
| * in compliance with the License. You may obtain a copy of the License at |
| * |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Unless required by applicable law or agreed to in writing, software distributed under the License |
| * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express |
| * or implied. See the License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| package com.google.dart.engine.internal.resolver; |
| |
| import com.google.dart.engine.AnalysisEngine; |
| import com.google.dart.engine.ast.Combinator; |
| import com.google.dart.engine.ast.CompilationUnit; |
| import com.google.dart.engine.ast.CompilationUnitMember; |
| import com.google.dart.engine.ast.Directive; |
| import com.google.dart.engine.ast.ExportDirective; |
| import com.google.dart.engine.ast.FunctionTypeAlias; |
| import com.google.dart.engine.ast.HideCombinator; |
| import com.google.dart.engine.ast.ImportDirective; |
| import com.google.dart.engine.ast.NamespaceDirective; |
| import com.google.dart.engine.ast.NodeList; |
| import com.google.dart.engine.ast.ShowCombinator; |
| import com.google.dart.engine.ast.SimpleIdentifier; |
| import com.google.dart.engine.ast.StringInterpolation; |
| import com.google.dart.engine.ast.StringLiteral; |
| import com.google.dart.engine.ast.TypeAlias; |
| import com.google.dart.engine.ast.UriBasedDirective; |
| import com.google.dart.engine.context.AnalysisException; |
| import com.google.dart.engine.element.Element; |
| import com.google.dart.engine.element.ExportElement; |
| import com.google.dart.engine.element.FunctionElement; |
| import com.google.dart.engine.element.ImportElement; |
| import com.google.dart.engine.element.LibraryElement; |
| import com.google.dart.engine.element.NamespaceCombinator; |
| import com.google.dart.engine.error.AnalysisError; |
| import com.google.dart.engine.error.AnalysisErrorListener; |
| import com.google.dart.engine.error.CompileTimeErrorCode; |
| import com.google.dart.engine.error.ErrorCode; |
| import com.google.dart.engine.error.StaticWarningCode; |
| import com.google.dart.engine.internal.builder.AngularCompilationUnitBuilder; |
| import com.google.dart.engine.internal.builder.EnumMemberBuilder; |
| import com.google.dart.engine.internal.builder.PolymerCompilationUnitBuilder; |
| import com.google.dart.engine.internal.constant.ConstantValueComputer; |
| import com.google.dart.engine.internal.context.InternalAnalysisContext; |
| import com.google.dart.engine.internal.context.PerformanceStatistics; |
| import com.google.dart.engine.internal.context.RecordingErrorListener; |
| import com.google.dart.engine.internal.element.ExportElementImpl; |
| import com.google.dart.engine.internal.element.HideElementCombinatorImpl; |
| import com.google.dart.engine.internal.element.ImportElementImpl; |
| import com.google.dart.engine.internal.element.LibraryElementImpl; |
| import com.google.dart.engine.internal.element.PrefixElementImpl; |
| import com.google.dart.engine.internal.element.ShowElementCombinatorImpl; |
| import com.google.dart.engine.internal.scope.Namespace; |
| import com.google.dart.engine.internal.scope.NamespaceBuilder; |
| import com.google.dart.engine.sdk.DartSdk; |
| import com.google.dart.engine.source.DartUriResolver; |
| import com.google.dart.engine.source.Source; |
| import com.google.dart.engine.source.SourceKind; |
| import com.google.dart.engine.utilities.general.TimeCounter.TimeCounterHandle; |
| import com.google.dart.engine.utilities.instrumentation.Instrumentation; |
| import com.google.dart.engine.utilities.instrumentation.InstrumentationBuilder; |
| import com.google.dart.engine.utilities.io.UriUtilities; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Set; |
| |
| /** |
| * Instances of the class {@code LibraryResolver} are used to resolve one or more mutually dependent |
| * libraries within a single context. |
| * |
| * @coverage dart.engine.resolver |
| */ |
| public class LibraryResolver { |
| /** |
| * Instances of the class {@code TypeAliasInfo} hold information about a {@link TypeAlias}. |
| */ |
| private static class TypeAliasInfo { |
| private Library library; |
| private Source source; |
| private FunctionTypeAlias typeAlias; |
| |
| /** |
| * Initialize a newly created information holder with the given information. |
| * |
| * @param library the library containing the type alias |
| * @param source the source of the file containing the type alias |
| * @param typeAlias the type alias being remembered |
| */ |
| public TypeAliasInfo(Library library, Source source, FunctionTypeAlias typeAlias) { |
| this.library = library; |
| this.source = source; |
| this.typeAlias = typeAlias; |
| } |
| } |
| |
| /** |
| * The analysis context in which the libraries are being analyzed. |
| */ |
| private InternalAnalysisContext analysisContext; |
| |
| /** |
| * The listener to which analysis errors will be reported, this error listener is either |
| * references {@link #recordingErrorListener}, or it unions the passed |
| * {@link AnalysisErrorListener} with the {@link #recordingErrorListener}. |
| */ |
| private RecordingErrorListener errorListener; |
| |
| /** |
| * A source object representing the core library (dart:core). |
| */ |
| private Source coreLibrarySource; |
| |
| /** |
| * The object representing the core library. |
| */ |
| private Library coreLibrary; |
| |
| /** |
| * The object used to access the types from the core library. |
| */ |
| private TypeProvider typeProvider; |
| |
| /** |
| * A table mapping library sources to the information being maintained for those libraries. |
| */ |
| private HashMap<Source, Library> libraryMap = new HashMap<Source, Library>(); |
| |
| /** |
| * A collection containing the libraries that are being resolved together. |
| */ |
| private Set<Library> librariesInCycles; |
| |
| /** |
| * Initialize a newly created library resolver to resolve libraries within the given context. |
| * |
| * @param analysisContext the analysis context in which the library is being analyzed |
| */ |
| public LibraryResolver(InternalAnalysisContext analysisContext) { |
| this.analysisContext = analysisContext; |
| this.errorListener = new RecordingErrorListener(); |
| coreLibrarySource = analysisContext.getSourceFactory().forUri(DartSdk.DART_CORE); |
| } |
| |
| /** |
| * Return the analysis context in which the libraries are being analyzed. |
| * |
| * @return the analysis context in which the libraries are being analyzed |
| */ |
| public InternalAnalysisContext getAnalysisContext() { |
| return analysisContext; |
| } |
| |
| /** |
| * Return the listener to which analysis errors will be reported. |
| * |
| * @return the listener to which analysis errors will be reported |
| */ |
| public RecordingErrorListener getErrorListener() { |
| return errorListener; |
| } |
| |
| /** |
| * Return an array containing information about all of the libraries that were resolved. |
| * |
| * @return an array containing the libraries that were resolved |
| */ |
| public Set<Library> getResolvedLibraries() { |
| return librariesInCycles; |
| } |
| |
| /** |
| * Resolve the library specified by the given source in the given context. The library is assumed |
| * to be embedded in the given source. |
| * |
| * @param librarySource the source specifying the defining compilation unit of the library to be |
| * resolved |
| * @param modificationStamp the time stamp of the source from which the compilation unit was |
| * created |
| * @param unit the compilation unit representing the embedded library |
| * @param fullAnalysis {@code true} if a full analysis should be performed |
| * @return the element representing the resolved library |
| * @throws AnalysisException if the library could not be resolved for some reason |
| */ |
| public LibraryElement resolveEmbeddedLibrary(Source librarySource, long modificationStamp, |
| CompilationUnit unit, boolean fullAnalysis) throws AnalysisException { |
| |
| InstrumentationBuilder instrumentation = Instrumentation.builder("dart.engine.LibraryResolver.resolveEmbeddedLibrary"); |
| try { |
| instrumentation.metric("fullAnalysis", fullAnalysis); |
| instrumentation.data("fullName", librarySource.getFullName()); |
| // |
| // Create the objects representing the library being resolved and the core library. |
| // |
| Library targetLibrary = createLibraryWithUnit(librarySource, modificationStamp, unit); |
| coreLibrary = libraryMap.get(coreLibrarySource); |
| if (coreLibrary == null) { |
| // This will be true unless the library being analyzed is the core library. |
| coreLibrary = createLibrary(coreLibrarySource); |
| if (coreLibrary == null) { |
| LibraryResolver2.missingCoreLibrary(analysisContext, coreLibrarySource); |
| } |
| } |
| instrumentation.metric("createLibrary", "complete"); |
| // |
| // Compute the set of libraries that need to be resolved together. |
| // |
| computeEmbeddedLibraryDependencies(targetLibrary, unit); |
| librariesInCycles = computeLibrariesInCycles(targetLibrary); |
| // |
| // Build the element models representing the libraries being resolved. This is done in three |
| // steps: |
| // |
| // 1. Build the basic element models without making any connections between elements other than |
| // the basic parent/child relationships. This includes building the elements representing the |
| // libraries. |
| // 2. Build the elements for the import and export directives. This requires that we have the |
| // elements built for the referenced libraries, but because of the possibility of circular |
| // references needs to happen after all of the library elements have been created. |
| // 3. Build the rest of the type model by connecting superclasses, mixins, and interfaces. This |
| // requires that we be able to compute the names visible in the libraries being resolved, |
| // which in turn requires that we have resolved the import directives. |
| // |
| buildElementModels(); |
| instrumentation.metric("buildElementModels", "complete"); |
| LibraryElement coreElement = coreLibrary.getLibraryElement(); |
| if (coreElement == null) { |
| throw new AnalysisException("Could not resolve dart:core"); |
| } |
| buildDirectiveModels(); |
| instrumentation.metric("buildDirectiveModels", "complete"); |
| typeProvider = new TypeProviderImpl(coreElement); |
| buildTypeAliases(); |
| buildTypeHierarchies(); |
| instrumentation.metric("buildTypeHierarchies", "complete"); |
| // |
| // Perform resolution and type analysis. |
| // |
| // TODO(brianwilkerson) Decide whether we want to resolve all of the libraries or whether we |
| // want to only resolve the target library. The advantage to resolving everything is that we |
| // have already done part of the work so we'll avoid duplicated effort. The disadvantage of |
| // resolving everything is that we might do extra work that we don't really care about. Another |
| // possibility is to add a parameter to this method and punt the decision to the clients. |
| // |
| //if (analyzeAll) { |
| resolveReferencesAndTypes(); |
| instrumentation.metric("resolveReferencesAndTypes", "complete"); |
| //} else { |
| // resolveReferencesAndTypes(targetLibrary); |
| //} |
| performConstantEvaluation(); |
| instrumentation.metric("performConstantEvaluation", "complete"); |
| return targetLibrary.getLibraryElement(); |
| } finally { |
| instrumentation.log(); |
| } |
| } |
| |
| /** |
| * Resolve the library specified by the given source in the given context. |
| * <p> |
| * Note that because Dart allows circular imports between libraries, it is possible that more than |
| * one library will need to be resolved. In such cases the error listener can receive errors from |
| * multiple libraries. |
| * |
| * @param librarySource the source specifying the defining compilation unit of the library to be |
| * resolved |
| * @param fullAnalysis {@code true} if a full analysis should be performed |
| * @return the element representing the resolved library |
| * @throws AnalysisException if the library could not be resolved for some reason |
| */ |
| public LibraryElement resolveLibrary(Source librarySource, boolean fullAnalysis) |
| throws AnalysisException { |
| InstrumentationBuilder instrumentation = Instrumentation.builder("dart.engine.LibraryResolver.resolveLibrary"); |
| try { |
| instrumentation.metric("fullAnalysis", fullAnalysis); |
| instrumentation.data("fullName", librarySource.getFullName()); |
| // |
| // Create the objects representing the library being resolved and the core library. |
| // |
| Library targetLibrary = createLibrary(librarySource); |
| coreLibrary = libraryMap.get(coreLibrarySource); |
| if (coreLibrary == null) { |
| // This will be true unless the library being analyzed is the core library. |
| coreLibrary = createLibraryOrNull(coreLibrarySource); |
| if (coreLibrary == null) { |
| LibraryResolver2.missingCoreLibrary(analysisContext, coreLibrarySource); |
| } |
| } |
| instrumentation.metric("createLibrary", "complete"); |
| // |
| // Compute the set of libraries that need to be resolved together. |
| // |
| computeLibraryDependencies(targetLibrary); |
| librariesInCycles = computeLibrariesInCycles(targetLibrary); |
| // |
| // Build the element models representing the libraries being resolved. This is done in three |
| // steps: |
| // |
| // 1. Build the basic element models without making any connections between elements other |
| // than the basic parent/child relationships. This includes building the elements |
| // representing the libraries, but excludes members defined in enums. |
| // 2. Build the elements for the import and export directives. This requires that we have the |
| // elements built for the referenced libraries, but because of the possibility of circular |
| // references needs to happen after all of the library elements have been created. |
| // 3. Build the members in enum declarations. |
| // 4. Build the rest of the type model by connecting superclasses, mixins, and interfaces. This |
| // requires that we be able to compute the names visible in the libraries being resolved, |
| // which in turn requires that we have resolved the import directives. |
| // |
| buildElementModels(); |
| instrumentation.metric("buildElementModels", "complete"); |
| LibraryElement coreElement = coreLibrary.getLibraryElement(); |
| if (coreElement == null) { |
| throw new AnalysisException("Could not resolve dart:core"); |
| } |
| buildDirectiveModels(); |
| instrumentation.metric("buildDirectiveModels", "complete"); |
| typeProvider = new TypeProviderImpl(coreElement); |
| buildEnumMembers(); |
| buildTypeAliases(); |
| buildTypeHierarchies(); |
| buildImplicitConstructors(); |
| instrumentation.metric("buildTypeHierarchies", "complete"); |
| // |
| // Perform resolution and type analysis. |
| // |
| // TODO(brianwilkerson) Decide whether we want to resolve all of the libraries or whether we |
| // want to only resolve the target library. The advantage to resolving everything is that we |
| // have already done part of the work so we'll avoid duplicated effort. The disadvantage of |
| // resolving everything is that we might do extra work that we don't really care about. Another |
| // possibility is to add a parameter to this method and punt the decision to the clients. |
| // |
| //if (analyzeAll) { |
| resolveReferencesAndTypes(); |
| instrumentation.metric("resolveReferencesAndTypes", "complete"); |
| //} else { |
| // resolveReferencesAndTypes(targetLibrary); |
| //} |
| performConstantEvaluation(); |
| instrumentation.metric("performConstantEvaluation", "complete"); |
| instrumentation.metric("librariesInCycles", librariesInCycles.size()); |
| for (Library lib : librariesInCycles) { |
| instrumentation.metric( |
| "librariesInCycles-CompilationUnitSources-Size", |
| lib.getCompilationUnitSources().size()); |
| } |
| |
| return targetLibrary.getLibraryElement(); |
| } finally { |
| instrumentation.log(15); //Log if >= than 15ms |
| } |
| } |
| |
| /** |
| * 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 |
| * @throws AnalysisException if the library source is not valid |
| */ |
| protected Library createLibrary(Source librarySource) throws AnalysisException { |
| Library library = new Library(analysisContext, errorListener, librarySource); |
| libraryMap.put(librarySource, library); |
| return library; |
| } |
| |
| /** |
| * Add a dependency to the given map from the referencing library to the referenced library. |
| * |
| * @param dependencyMap the map to which the dependency is to be added |
| * @param referencingLibrary the library that references the referenced library |
| * @param referencedLibrary the library referenced by the referencing library |
| */ |
| private void addDependencyToMap(HashMap<Library, ArrayList<Library>> dependencyMap, |
| Library referencingLibrary, Library referencedLibrary) { |
| ArrayList<Library> dependentLibraries = dependencyMap.get(referencedLibrary); |
| if (dependentLibraries == null) { |
| dependentLibraries = new ArrayList<Library>(); |
| dependencyMap.put(referencedLibrary, dependentLibraries); |
| } |
| dependentLibraries.add(referencingLibrary); |
| } |
| |
| /** |
| * Given a library that is part of a cycle that includes the root library, add to the given set of |
| * libraries all of the libraries reachable from the root library that are also included in the |
| * cycle. |
| * |
| * @param library the library to be added to the collection of libraries in cycles |
| * @param librariesInCycle a collection of the libraries that are in the cycle |
| * @param dependencyMap a table mapping libraries to the collection of libraries from which those |
| * libraries are referenced |
| */ |
| private void addLibrariesInCycle(Library library, Set<Library> librariesInCycle, |
| HashMap<Library, ArrayList<Library>> dependencyMap) { |
| if (librariesInCycle.add(library)) { |
| ArrayList<Library> dependentLibraries = dependencyMap.get(library); |
| if (dependentLibraries != null) { |
| for (Library dependentLibrary : dependentLibraries) { |
| addLibrariesInCycle(dependentLibrary, librariesInCycle, dependencyMap); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Add the given library, and all libraries reachable from it that have not already been visited, |
| * to the given dependency map. |
| * |
| * @param library the library currently being added to the dependency map |
| * @param dependencyMap the dependency map being computed |
| * @param visitedLibraries the libraries that have already been visited, used to prevent infinite |
| * recursion |
| */ |
| private void addToDependencyMap(Library library, |
| HashMap<Library, ArrayList<Library>> dependencyMap, Set<Library> visitedLibraries) { |
| if (visitedLibraries.add(library)) { |
| for (Library referencedLibrary : library.getImportsAndExports()) { |
| addDependencyToMap(dependencyMap, library, referencedLibrary); |
| addToDependencyMap(referencedLibrary, dependencyMap, visitedLibraries); |
| } |
| if (!library.getExplicitlyImportsCore() && library != coreLibrary) { |
| addDependencyToMap(dependencyMap, library, coreLibrary); |
| } |
| } |
| } |
| |
| /** |
| * Build the element model representing the combinators declared by the given directive. |
| * |
| * @param directive the directive that declares the combinators |
| * @return an array containing the import combinators that were built |
| */ |
| // TODO(brianwilkerson) Move with buildDirectiveModels(). |
| private NamespaceCombinator[] buildCombinators(NamespaceDirective directive) { |
| ArrayList<NamespaceCombinator> combinators = new ArrayList<NamespaceCombinator>(); |
| for (Combinator combinator : directive.getCombinators()) { |
| if (combinator instanceof HideCombinator) { |
| HideElementCombinatorImpl hide = new HideElementCombinatorImpl(); |
| hide.setHiddenNames(getIdentifiers(((HideCombinator) combinator).getHiddenNames())); |
| combinators.add(hide); |
| } else { |
| ShowElementCombinatorImpl show = new ShowElementCombinatorImpl(); |
| show.setOffset(combinator.getOffset()); |
| show.setEnd(combinator.getEnd()); |
| show.setShownNames(getIdentifiers(((ShowCombinator) combinator).getShownNames())); |
| combinators.add(show); |
| } |
| } |
| return combinators.toArray(new NamespaceCombinator[combinators.size()]); |
| } |
| |
| /** |
| * Every library now has a corresponding {@link LibraryElement}, so it is now possible to resolve |
| * the import and export directives. |
| * |
| * @throws AnalysisException if the defining compilation unit for any of the libraries could not |
| * be accessed |
| */ |
| // TODO(brianwilkerson) The body of this method probably wants to be moved into a separate class. |
| private void buildDirectiveModels() throws AnalysisException { |
| for (Library library : librariesInCycles) { |
| HashMap<String, PrefixElementImpl> nameToPrefixMap = new HashMap<String, PrefixElementImpl>(); |
| ArrayList<ImportElement> imports = new ArrayList<ImportElement>(); |
| ArrayList<ExportElement> exports = new ArrayList<ExportElement>(); |
| for (Directive directive : library.getDefiningCompilationUnit().getDirectives()) { |
| if (directive instanceof ImportDirective) { |
| ImportDirective importDirective = (ImportDirective) directive; |
| String uriContent = importDirective.getUriContent(); |
| if (DartUriResolver.isDartExtUri(uriContent)) { |
| library.getLibraryElement().setHasExtUri(true); |
| } |
| Source importedSource = importDirective.getSource(); |
| if (importedSource != null) { |
| // The imported source will be null if the URI in the import directive was invalid. |
| Library importedLibrary = libraryMap.get(importedSource); |
| if (importedLibrary != null) { |
| ImportElementImpl importElement = new ImportElementImpl(directive.getOffset()); |
| StringLiteral uriLiteral = importDirective.getUri(); |
| importElement.setUriOffset(uriLiteral.getOffset()); |
| importElement.setUriEnd(uriLiteral.getEnd()); |
| importElement.setUri(uriContent); |
| importElement.setDeferred(importDirective.getDeferredToken() != null); |
| importElement.setCombinators(buildCombinators(importDirective)); |
| LibraryElement importedLibraryElement = importedLibrary.getLibraryElement(); |
| if (importedLibraryElement != null) { |
| importElement.setImportedLibrary(importedLibraryElement); |
| } |
| SimpleIdentifier prefixNode = ((ImportDirective) directive).getPrefix(); |
| if (prefixNode != null) { |
| importElement.setPrefixOffset(prefixNode.getOffset()); |
| String prefixName = prefixNode.getName(); |
| PrefixElementImpl prefix = nameToPrefixMap.get(prefixName); |
| if (prefix == null) { |
| prefix = new PrefixElementImpl(prefixNode); |
| nameToPrefixMap.put(prefixName, prefix); |
| } |
| importElement.setPrefix(prefix); |
| prefixNode.setStaticElement(prefix); |
| } |
| directive.setElement(importElement); |
| imports.add(importElement); |
| |
| if (analysisContext.computeKindOf(importedSource) != SourceKind.LIBRARY) { |
| ErrorCode errorCode = importElement.isDeferred() |
| ? StaticWarningCode.IMPORT_OF_NON_LIBRARY |
| : CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY; |
| errorListener.onError(new AnalysisError( |
| library.getLibrarySource(), |
| uriLiteral.getOffset(), |
| uriLiteral.getLength(), |
| errorCode, |
| uriLiteral.toSource())); |
| } |
| } |
| } |
| } else if (directive instanceof ExportDirective) { |
| ExportDirective exportDirective = (ExportDirective) directive; |
| Source exportedSource = exportDirective.getSource(); |
| if (exportedSource != null) { |
| // The exported source will be null if the URI in the export directive was invalid. |
| Library exportedLibrary = libraryMap.get(exportedSource); |
| if (exportedLibrary != null) { |
| ExportElementImpl exportElement = new ExportElementImpl(); |
| StringLiteral uriLiteral = exportDirective.getUri(); |
| exportElement.setUriOffset(uriLiteral.getOffset()); |
| exportElement.setUriEnd(uriLiteral.getEnd()); |
| exportElement.setUri(exportDirective.getUriContent()); |
| exportElement.setCombinators(buildCombinators(exportDirective)); |
| LibraryElement exportedLibraryElement = exportedLibrary.getLibraryElement(); |
| if (exportedLibraryElement != null) { |
| exportElement.setExportedLibrary(exportedLibraryElement); |
| } |
| directive.setElement(exportElement); |
| exports.add(exportElement); |
| |
| if (analysisContext.computeKindOf(exportedSource) != SourceKind.LIBRARY) { |
| errorListener.onError(new AnalysisError( |
| library.getLibrarySource(), |
| uriLiteral.getOffset(), |
| uriLiteral.getLength(), |
| CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY, |
| uriLiteral.toSource())); |
| } |
| } |
| } |
| } |
| } |
| Source librarySource = library.getLibrarySource(); |
| if (!library.getExplicitlyImportsCore() && !coreLibrarySource.equals(librarySource)) { |
| ImportElementImpl importElement = new ImportElementImpl(-1); |
| importElement.setImportedLibrary(coreLibrary.getLibraryElement()); |
| importElement.setSynthetic(true); |
| imports.add(importElement); |
| } |
| LibraryElementImpl libraryElement = library.getLibraryElement(); |
| libraryElement.setImports(imports.toArray(new ImportElement[imports.size()])); |
| libraryElement.setExports(exports.toArray(new ExportElement[exports.size()])); |
| if (libraryElement.getEntryPoint() == null) { |
| Namespace namespace = new NamespaceBuilder().createExportNamespaceForLibrary(libraryElement); |
| Element element = namespace.get(LibraryElementBuilder.ENTRY_POINT_NAME); |
| if (element instanceof FunctionElement) { |
| libraryElement.setEntryPoint((FunctionElement) element); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Build element models for all of the libraries in the current cycle. |
| * |
| * @throws AnalysisException if any of the element models cannot be built |
| */ |
| private void buildElementModels() throws AnalysisException { |
| for (Library library : librariesInCycles) { |
| LibraryElementBuilder builder = new LibraryElementBuilder( |
| getAnalysisContext(), |
| getErrorListener()); |
| LibraryElementImpl libraryElement = builder.buildLibrary(library); |
| library.setLibraryElement(libraryElement); |
| } |
| } |
| |
| /** |
| * Build the members in enum declarations. This cannot be done while building the rest of the |
| * element model because it depends on being able to access core types, which cannot happen until |
| * the rest of the element model has been built (when resolving the core library). |
| * |
| * @throws AnalysisException if any of the enum members could not be built |
| */ |
| private void buildEnumMembers() throws AnalysisException { |
| TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start(); |
| try { |
| for (Library library : librariesInCycles) { |
| for (Source source : library.getCompilationUnitSources()) { |
| EnumMemberBuilder builder = new EnumMemberBuilder(typeProvider); |
| library.getAST(source).accept(builder); |
| } |
| } |
| } finally { |
| timeCounter.stop(); |
| } |
| } |
| |
| /** |
| * Finish steps that the {@link #buildTypeHierarchies()} could not perform, see |
| * {@link ImplicitConstructorBuilder}. |
| * |
| * @throws AnalysisException if any of the type hierarchies could not be resolved |
| */ |
| private void buildImplicitConstructors() throws AnalysisException { |
| TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start(); |
| try { |
| for (Library library : librariesInCycles) { |
| for (Source source : library.getCompilationUnitSources()) { |
| ImplicitConstructorBuilder visitor = new ImplicitConstructorBuilder( |
| library, |
| source, |
| typeProvider); |
| library.getAST(source).accept(visitor); |
| } |
| } |
| } finally { |
| timeCounter.stop(); |
| } |
| } |
| |
| /** |
| * Resolve the types referenced by function type aliases across all of the function type aliases |
| * defined in the current cycle. |
| * |
| * @throws AnalysisException if any of the function type aliases could not be resolved |
| */ |
| private void buildTypeAliases() throws AnalysisException { |
| TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start(); |
| try { |
| List<TypeAliasInfo> typeAliases = new ArrayList<TypeAliasInfo>(); |
| for (Library library : librariesInCycles) { |
| for (Source source : library.getCompilationUnitSources()) { |
| CompilationUnit ast = library.getAST(source); |
| for (CompilationUnitMember member : ast.getDeclarations()) { |
| if (member instanceof FunctionTypeAlias) { |
| typeAliases.add(new TypeAliasInfo(library, source, (FunctionTypeAlias) member)); |
| } |
| } |
| } |
| } |
| // TODO(brianwilkerson) We need to sort the type aliases such that all aliases referenced by |
| // an alias T are resolved before we resolve T. |
| for (TypeAliasInfo info : typeAliases) { |
| TypeResolverVisitor visitor = new TypeResolverVisitor( |
| info.library, |
| info.source, |
| typeProvider); |
| info.typeAlias.accept(visitor); |
| } |
| } finally { |
| timeCounter.stop(); |
| } |
| } |
| |
| /** |
| * Resolve the type hierarchy across all of the types declared in the libraries in the current |
| * cycle. |
| * |
| * @throws AnalysisException if any of the type hierarchies could not be resolved |
| */ |
| private void buildTypeHierarchies() throws AnalysisException { |
| TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start(); |
| try { |
| for (Library library : librariesInCycles) { |
| for (Source source : library.getCompilationUnitSources()) { |
| TypeResolverVisitor visitor = new TypeResolverVisitor(library, source, typeProvider); |
| library.getAST(source).accept(visitor); |
| } |
| } |
| } finally { |
| timeCounter.stop(); |
| } |
| } |
| |
| /** |
| * Compute a dependency map of libraries reachable from the given library. A dependency map is a |
| * table that maps individual libraries to a list of the libraries that either import or export |
| * those libraries. |
| * <p> |
| * This map is used to compute all of the libraries involved in a cycle that include the root |
| * library. Given that we only add libraries that are reachable from the root library, when we |
| * work backward we are guaranteed to only get libraries in the cycle. |
| * |
| * @param library the library currently being added to the dependency map |
| */ |
| private HashMap<Library, ArrayList<Library>> computeDependencyMap(Library library) { |
| HashMap<Library, ArrayList<Library>> dependencyMap = new HashMap<Library, ArrayList<Library>>(); |
| addToDependencyMap(library, dependencyMap, new HashSet<Library>()); |
| return dependencyMap; |
| } |
| |
| /** |
| * Recursively traverse the libraries reachable from the given library, creating instances of the |
| * class {@link 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 |
| */ |
| private void computeEmbeddedLibraryDependencies(Library library, CompilationUnit unit) |
| throws AnalysisException { |
| Source librarySource = library.getLibrarySource(); |
| HashSet<Source> exportedSources = new HashSet<Source>(); |
| HashSet<Source> importedSources = new HashSet<Source>(); |
| for (Directive directive : unit.getDirectives()) { |
| if (directive instanceof ExportDirective) { |
| Source exportSource = resolveSource(librarySource, (ExportDirective) directive); |
| if (exportSource != null) { |
| exportedSources.add(exportSource); |
| } |
| } else if (directive instanceof ImportDirective) { |
| Source importSource = resolveSource(librarySource, (ImportDirective) directive); |
| if (importSource != null) { |
| importedSources.add(importSource); |
| } |
| } |
| } |
| computeLibraryDependenciesFromDirectives( |
| library, |
| importedSources.toArray(new Source[importedSources.size()]), |
| exportedSources.toArray(new Source[exportedSources.size()])); |
| } |
| |
| /** |
| * Return a collection containing all of the libraries reachable from the given library that are |
| * contained in a cycle that includes the given library. |
| * |
| * @param library the library that must be included in any cycles whose members are to be returned |
| * @return all of the libraries referenced by the given library that have a circular reference |
| * back to the given library |
| */ |
| private Set<Library> computeLibrariesInCycles(Library library) { |
| HashMap<Library, ArrayList<Library>> dependencyMap = computeDependencyMap(library); |
| Set<Library> librariesInCycle = new HashSet<Library>(); |
| addLibrariesInCycle(library, librariesInCycle, dependencyMap); |
| return librariesInCycle; |
| } |
| |
| /** |
| * Recursively traverse the libraries reachable from the given library, creating instances of the |
| * class {@link 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 |
| */ |
| private void computeLibraryDependencies(Library library) throws AnalysisException { |
| Source librarySource = library.getLibrarySource(); |
| computeLibraryDependenciesFromDirectives( |
| library, |
| analysisContext.computeImportedLibraries(librarySource), |
| analysisContext.computeExportedLibraries(librarySource)); |
| } |
| |
| /** |
| * Recursively traverse the libraries reachable from the given library, creating instances of the |
| * class {@link 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 |
| * @throws AnalysisException if some portion of the library graph could not be traversed |
| */ |
| private void computeLibraryDependenciesFromDirectives(Library library, Source[] importedSources, |
| Source[] exportedSources) throws AnalysisException { |
| ArrayList<Library> importedLibraries = new ArrayList<Library>(); |
| boolean explicitlyImportsCore = false; |
| for (Source importedSource : importedSources) { |
| if (importedSource.equals(coreLibrarySource)) { |
| explicitlyImportsCore = true; |
| } |
| Library importedLibrary = libraryMap.get(importedSource); |
| if (importedLibrary == null) { |
| importedLibrary = createLibraryOrNull(importedSource); |
| if (importedLibrary != null) { |
| computeLibraryDependencies(importedLibrary); |
| } |
| } |
| if (importedLibrary != null) { |
| importedLibraries.add(importedLibrary); |
| } |
| } |
| library.setImportedLibraries(importedLibraries.toArray(new Library[importedLibraries.size()])); |
| |
| ArrayList<Library> exportedLibraries = new ArrayList<Library>(); |
| for (Source exportedSource : exportedSources) { |
| Library exportedLibrary = libraryMap.get(exportedSource); |
| if (exportedLibrary == null) { |
| exportedLibrary = createLibraryOrNull(exportedSource); |
| if (exportedLibrary != null) { |
| computeLibraryDependencies(exportedLibrary); |
| } |
| } |
| if (exportedLibrary != null) { |
| exportedLibraries.add(exportedLibrary); |
| } |
| } |
| library.setExportedLibraries(exportedLibraries.toArray(new Library[exportedLibraries.size()])); |
| |
| library.setExplicitlyImportsCore(explicitlyImportsCore); |
| if (!explicitlyImportsCore && !coreLibrarySource.equals(library.getLibrarySource())) { |
| Library importedLibrary = libraryMap.get(coreLibrarySource); |
| if (importedLibrary == null) { |
| importedLibrary = createLibraryOrNull(coreLibrarySource); |
| if (importedLibrary != null) { |
| computeLibraryDependencies(importedLibrary); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Create an object to represent the information about the library defined by the compilation unit |
| * with the given source. Return the library object that was created, or {@code null} if the |
| * source is not valid. |
| * |
| * @param librarySource the source of the library's defining compilation unit |
| * @return the library object that was created |
| */ |
| private Library createLibraryOrNull(Source librarySource) { |
| if (!analysisContext.exists(librarySource)) { |
| return null; |
| } |
| Library library = new Library(analysisContext, errorListener, librarySource); |
| libraryMap.put(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 |
| * @param modificationStamp the modification time of the source from which the compilation unit |
| * was created |
| * @param unit the compilation unit that defines the library |
| * @return the library object that was created |
| * @throws AnalysisException if the library source is not valid |
| */ |
| private Library createLibraryWithUnit(Source librarySource, long modificationStamp, |
| CompilationUnit unit) throws AnalysisException { |
| Library library = new Library(analysisContext, errorListener, librarySource); |
| library.setDefiningCompilationUnit(modificationStamp, unit); |
| libraryMap.put(librarySource, library); |
| return library; |
| } |
| |
| /** |
| * Return an array containing the lexical identifiers associated with the nodes in the given list. |
| * |
| * @param names the AST nodes representing the identifiers |
| * @return the lexical identifiers associated with the nodes in the list |
| */ |
| // TODO(brianwilkerson) Move with buildDirectiveModels(). |
| private String[] getIdentifiers(NodeList<SimpleIdentifier> names) { |
| int count = names.size(); |
| String[] identifiers = new String[count]; |
| for (int i = 0; i < count; i++) { |
| identifiers[i] = names.get(i).getName(); |
| } |
| return identifiers; |
| } |
| |
| /** |
| * Compute a value for all of the constants in the libraries being analyzed. |
| */ |
| private void performConstantEvaluation() { |
| TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start(); |
| try { |
| ConstantValueComputer computer = new ConstantValueComputer( |
| typeProvider, |
| analysisContext.getDeclaredVariables()); |
| for (Library library : librariesInCycles) { |
| for (Source source : library.getCompilationUnitSources()) { |
| try { |
| CompilationUnit unit = library.getAST(source); |
| if (unit != null) { |
| computer.add(unit); |
| } |
| } catch (AnalysisException exception) { |
| AnalysisEngine.getInstance().getLogger().logError( |
| "Internal Error: Could not access AST for " + source.getFullName() |
| + " during constant evaluation", |
| exception); |
| } |
| } |
| } |
| computer.computeValues(); |
| } finally { |
| timeCounter.stop(); |
| } |
| } |
| |
| /** |
| * Resolve the identifiers and perform type analysis in the libraries in the current cycle. |
| * |
| * @throws AnalysisException if any of the identifiers could not be resolved or if any of the |
| * libraries could not have their types analyzed |
| */ |
| private void resolveReferencesAndTypes() throws AnalysisException { |
| for (Library library : librariesInCycles) { |
| resolveReferencesAndTypesInLibrary(library); |
| } |
| } |
| |
| /** |
| * Resolve the identifiers and perform type analysis in the given library. |
| * |
| * @param library the library to be resolved |
| * @throws AnalysisException if any of the identifiers could not be resolved or if the types in |
| * the library cannot be analyzed |
| */ |
| private void resolveReferencesAndTypesInLibrary(Library library) throws AnalysisException { |
| TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start(); |
| try { |
| for (Source source : library.getCompilationUnitSources()) { |
| CompilationUnit ast = library.getAST(source); |
| ast.accept(new VariableResolverVisitor(library, source, typeProvider)); |
| ResolverVisitor visitor = new ResolverVisitor(library, source, typeProvider); |
| ast.accept(visitor); |
| } |
| } finally { |
| timeCounter.stop(); |
| } |
| // Angular |
| timeCounter = PerformanceStatistics.angular.start(); |
| try { |
| for (Source source : library.getCompilationUnitSources()) { |
| CompilationUnit ast = library.getAST(source); |
| new AngularCompilationUnitBuilder(errorListener, source, ast).build(); |
| } |
| } finally { |
| timeCounter.stop(); |
| } |
| // Polymer |
| timeCounter = PerformanceStatistics.polymer.start(); |
| try { |
| for (Source source : library.getCompilationUnitSources()) { |
| CompilationUnit ast = library.getAST(source); |
| new PolymerCompilationUnitBuilder(ast).build(); |
| } |
| } finally { |
| timeCounter.stop(); |
| } |
| } |
| |
| /** |
| * Return the result of resolving the URI of the given URI-based directive against the URI of the |
| * given library, or {@code null} if the URI is not valid. |
| * |
| * @param librarySource the source representing the library containing the directive |
| * @param directive the directive which URI should be resolved |
| * @return the result of resolving the URI against the URI of the library |
| */ |
| private Source resolveSource(Source librarySource, UriBasedDirective directive) { |
| StringLiteral uriLiteral = directive.getUri(); |
| if (uriLiteral instanceof StringInterpolation) { |
| return null; |
| } |
| String uriContent = uriLiteral.getStringValue().trim(); |
| if (uriContent == null || uriContent.isEmpty()) { |
| return null; |
| } |
| uriContent = UriUtilities.encode(uriContent); |
| return analysisContext.getSourceFactory().resolveUri(librarySource, uriContent); |
| } |
| } |
