Task: Build Type Aliases.

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

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library engine.resolver;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/utilities_collection.dart';
@@ skipping 4870 matching lines @@
 
   /**
    * Initialize a newly created visitor to build implicit constructors for file
    * [source], in library [libraryElement], which has scope [libraryScope]. Use
    * [typeProvider] to access types from the core library.
    *
    * The visit methods will pass closures to [_callback] to indicate what
    * computation needs to be performed, and its dependency order.
    */
   ImplicitConstructorBuilder(Source source, LibraryElement libraryElement,
-      LibraryScope libraryScope, TypeProvider typeProvider, this._callback)
+      Scope libraryScope, TypeProvider typeProvider, this._callback)
       : super.con3(libraryElement, source, typeProvider, libraryScope,
           libraryScope.errorListener);
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElementImpl classElement = node.element;
     classElement.mixinErrorsReported = false;
     if (node.extendsClause != null && node.withClause != null) {
       // We don't need to build any implicitly constructors for the mixin
       // application (since there isn't an explicit element for it), but we
@@ skipping 216 matching lines @@
    */
   ImplicitConstructorComputer(this.typeProvider);
 
   /**
    * Add the given [unit] to the list of units which need to have implicit
    * constructors built for them.  [source] is the source file corresponding to
    * the compilation unit, [libraryElement] is the library element containing
    * that source, and [libraryScope] is the scope for the library element.
    */
   void add(CompilationUnit unit, Source source, LibraryElement libraryElement,
-      LibraryScope libraryScope) {
+      Scope libraryScope) {
     unit.accept(new ImplicitConstructorBuilder(
         source, libraryElement, libraryScope, typeProvider, _defer));
   }
 
   /**
    * Compute the implicit constructors for all compilation units that have been
    * passed to [add].
    */
   void compute() {
     List<List<ClassElement>> topologicalSort =
@@ skipping 1781 matching lines @@
     }
   }
 
   /**
    * Return the library scope used when resolving elements within this library's compilation units.
    *
    * @return the library scope used when resolving elements within this library's compilation units
    */
   LibraryScope get libraryScope {
     if (_libraryScope == null) {
-      _libraryScope = new LibraryScope(_libraryElement, _errorListener);
+      _libraryScope = new LibraryScope(_libraryElement,
+          new LibraryImportScope(_libraryElement, _errorListener),
+          _errorListener);
     }
     return _libraryScope;
   }
 
   /**
    * Return the AST structure associated with the given source.
    *
    * @param source the source representing the compilation unit whose AST is to be returned
    * @return the AST structure associated with the given source
    * @throws AnalysisException if an AST structure could not be created for the compilation unit
@@ skipping 385 matching lines @@
 }
 
 /**
  * Instances of the class `LibraryImportScope` represent the scope containing all of the names
  * available from imported libraries.
  */
 class LibraryImportScope extends Scope {
   /**
    * The element representing the library in which this scope is enclosed.
    */
-  final LibraryElement _definingLibrary;
+  final LibraryElement definingLibrary;
 
   /**
    * The listener that is to be informed when an error is encountered.
    */
   final AnalysisErrorListener errorListener;
 
   /**
    * A list of the namespaces representing the names that are available in this scope from imported
    * libraries.
    */
-  List<Namespace> _importedNamespaces;
+  final List<Namespace> importedNamespaces = <Namespace>[];
 
   /**
    * Initialize a newly created scope representing the names imported into the given library.
    *
    * @param definingLibrary the element representing the library that imports the names defined in
    *          this scope
    * @param errorListener the listener that is to be informed when an error is encountered
    */
-  LibraryImportScope(this._definingLibrary, this.errorListener) {
-    _createImportedNamespaces();
+  LibraryImportScope(this.definingLibrary, this.errorListener) {
+    createImportedNamespaces();
+  }
+
+  /**
+   * Create all of the namespaces associated with the libraries imported into this library. The
+   * names are not added to this scope, but are stored for later reference.
+   *
+   * @param definingLibrary the element representing the library that imports the libraries for
+   *          which namespaces will be created
+   */
+  void createImportedNamespaces() {
+    NamespaceBuilder builder = new NamespaceBuilder();
+    for (ImportElement import in definingLibrary.imports) {
+      Namespace namespace = builder.createImportNamespaceForDirective(import);
+      importedNamespaces.add(namespace);
+    }
   }
 
   @override
   void define(Element element) {
     if (!Scope.isPrivateName(element.displayName)) {
       super.define(element);
     }
   }
 
   @override
   Source getSource(AstNode node) {
     Source source = super.getSource(node);
     if (source == null) {
-      source = _definingLibrary.definingCompilationUnit.source;
+      source = definingLibrary.definingCompilationUnit.source;
     }
     return source;
   }
 
   @override
   Element internalLookup(
       Identifier identifier, String name, LibraryElement referencingLibrary) {
     Element foundElement = localLookup(name, referencingLibrary);
     if (foundElement != null) {
       return foundElement;
     }
-    for (int i = 0; i < _importedNamespaces.length; i++) {
-      Namespace nameSpace = _importedNamespaces[i];
+    for (int i = 0; i < importedNamespaces.length; i++) {
+      Namespace nameSpace = importedNamespaces[i];
       Element element = nameSpace.get(name);
       if (element != null) {
         if (foundElement == null) {
           foundElement = element;
         } else if (!identical(foundElement, element)) {
           foundElement = MultiplyDefinedElementImpl.fromElements(
-              _definingLibrary.context, foundElement, element);
+              definingLibrary.context, foundElement, element);
         }
       }
     }
     if (foundElement is MultiplyDefinedElementImpl) {
       foundElement = _removeSdkElements(
           identifier, name, foundElement as MultiplyDefinedElementImpl);
     }
     if (foundElement is MultiplyDefinedElementImpl) {
       String foundEltName = foundElement.displayName;
       List<Element> conflictingMembers = foundElement.conflictingElements;
@@ skipping 11 matching lines @@
       ]));
       return foundElement;
     }
     if (foundElement != null) {
       defineNameWithoutChecking(name, foundElement);
     }
     return foundElement;
   }
 
   /**
-   * Create all of the namespaces associated with the libraries imported into this library. The
-   * names are not added to this scope, but are stored for later reference.
-   *
-   * @param definingLibrary the element representing the library that imports the libraries for
-   *          which namespaces will be created
-   */
-  void _createImportedNamespaces() {
-    NamespaceBuilder builder = new NamespaceBuilder();
-    List<ImportElement> imports = _definingLibrary.imports;
-    int count = imports.length;
-    _importedNamespaces = new List<Namespace>(count);
-    for (int i = 0; i < count; i++) {
-      _importedNamespaces[i] =
-          builder.createImportNamespaceForDirective(imports[i]);
-    }
-  }
-
-  /**
    * Returns the name of the library that defines given element.
    *
    * @param element the element to get library name
    * @return the name of the library that defines given element
    */
   String _getLibraryName(Element element) {
     if (element == null) {
       return StringUtilities.EMPTY;
     }
     LibraryElement library = element.library;
     if (library == null) {
       return StringUtilities.EMPTY;
     }
-    List<ImportElement> imports = _definingLibrary.imports;
+    List<ImportElement> imports = definingLibrary.imports;
     int count = imports.length;
     for (int i = 0; i < count; i++) {
       if (identical(imports[i].importedLibrary, library)) {
         return library.definingCompilationUnit.displayName;
       }
     }
     List<String> indirectSources = new List<String>();
     for (int i = 0; i < count; i++) {
       LibraryElement importedLibrary = imports[i].importedLibrary;
       if (importedLibrary != null) {
@@ skipping 56 matching lines @@
     } else if (nonSdkElements.length == 1) {
       // All but one member was removed
       return nonSdkElements[0];
     } else if (nonSdkElements.length == 0) {
       // All members were removed
       AnalysisEngine.instance.logger
           .logInformation("Multiply defined SDK element: $foundElement");
       return foundElement;
     }
     return new MultiplyDefinedElementImpl(
-        _definingLibrary.context, nonSdkElements);
+        definingLibrary.context, nonSdkElements);
   }
 }
 
 /**
  * Instances of the class `LibraryResolver` are used to resolve one or more mutually dependent
  * libraries within a single context.
  */
 class LibraryResolver {
   /**
    * The analysis context in which the libraries are being analyzed.
@@ skipping 1454 matching lines @@
  * Instances of the class `LibraryScope` implement a scope containing all of the names defined
  * in a given library.
  */
 class LibraryScope extends EnclosedScope {
   /**
    * Initialize a newly created scope representing the names defined in the given library.
    *
    * @param definingLibrary the element representing the library represented by this scope
    * @param errorListener the listener that is to be informed when an error is encountered
    */
-  LibraryScope(
-      LibraryElement definingLibrary, AnalysisErrorListener errorListener)
-      : super(new LibraryImportScope(definingLibrary, errorListener)) {
+  LibraryScope(LibraryElement definingLibrary, Scope importScope,

[Brian Wilkerson, 2015/03/18 14:34:05]

This is a breaking change for other clients and makes the existing clients of
this constructor harder to read. It should also be a temporary change because
eventually there should only need to be one kind of library import scope.

How about adding a named constructor (marked as 'deprecated') for this case and
leaving this constructor as it was?

+      AnalysisErrorListener errorListener)
+      : super(importScope) {
     _defineTopLevelNames(definingLibrary);
   }
 
   @override
   AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
     if (existing is PrefixElement) {
       // TODO(scheglov) consider providing actual 'nameOffset' from the
       // synthetic accessor
       int offset = duplicate.nameOffset;
       if (duplicate is PropertyAccessorElement) {
@@ skipping 996 matching lines @@
     }
   }
 
   /**
    * Return the library scope used when resolving elements within this library's compilation units.
    *
    * @return the library scope used when resolving elements within this library's compilation units
    */
   LibraryScope get libraryScope {
     if (_libraryScope == null) {
-      _libraryScope = new LibraryScope(_libraryElement, _errorListener);
+      _libraryScope = new LibraryScope(_libraryElement,
+          new LibraryImportScope(_libraryElement, _errorListener),
+          _errorListener);
     }
     return _libraryScope;
   }
 
   /**
    * Return an array containing the compilation units that comprise this library. The defining
    * compilation unit is always first.
    *
    * @return the compilation units that comprise this library
    */
@@ skipping 168 matching lines @@
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param definingLibrary the element for the library containing the compilation unit being
    *          visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during resolution
    */
-  ResolverVisitor.con2(LibraryElement definingLibrary, Source source,
-      TypeProvider typeProvider, InheritanceManager inheritanceManager,
+  ResolverVisitor.con2(LibraryElement definingLibrary, Scope libraryScope,

[Brian Wilkerson, 2015/03/18 14:34:05]

Should this be "LibraryScope libraryScope"? If not, then perhaps "Scope
resolutionScope" or something that doesn't imply that it should have been a
library scope? (I see this same problem in several other places as well.)

+      Source source, TypeProvider typeProvider,
+      InheritanceManager inheritanceManager,
       AnalysisErrorListener errorListener)
-      : super.con2(definingLibrary, source, typeProvider, errorListener) {
+      : super.con2(
+          definingLibrary, libraryScope, source, typeProvider, errorListener) {
     this._inheritanceManager = inheritanceManager;
     this._elementResolver = new ElementResolver(this);
     this._typeAnalyzer = new StaticTypeAnalyzer(this);
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in an AST node.
    *
    * @param definingLibrary the element for the library containing the node being visited
    * @param source the source representing the compilation unit containing the node being visited
@@ skipping 1597 matching lines @@
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param definingLibrary the element for the library containing the compilation unit being
    *          visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during resolution
    */
-  ScopedVisitor.con2(LibraryElement definingLibrary, this.source,
-      this.typeProvider, AnalysisErrorListener errorListener) {
+  ScopedVisitor.con2(LibraryElement definingLibrary, Scope libraryScope,
+      this.source, this.typeProvider, AnalysisErrorListener errorListener) {
     this._definingLibrary = definingLibrary;
     this._errorListener = errorListener;
-    this._nameScope = new LibraryScope(definingLibrary, errorListener);
+    this._nameScope = libraryScope;
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param definingLibrary the element for the library containing the compilation unit being
    *          visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param nameScope the scope used to resolve identifiers in the node that will first be visited
@@ skipping 1729 matching lines @@
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param definingLibrary the element for the library containing the compilation unit being
    *          visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during resolution
    */
-  TypeResolverVisitor.con2(LibraryElement definingLibrary, Source source,
-      TypeProvider typeProvider, AnalysisErrorListener errorListener)
-      : super.con2(definingLibrary, source, typeProvider, errorListener) {
+  TypeResolverVisitor.con2(LibraryElement definingLibrary, Scope libraryScope,
+      Source source, TypeProvider typeProvider,
+      AnalysisErrorListener errorListener)
+      : super.con2(
+          definingLibrary, libraryScope, source, typeProvider, errorListener) {
     _dynamicType = typeProvider.dynamicType;
     _undefinedType = typeProvider.undefinedType;
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in an AST node.
    *
    * @param definingLibrary the element for the library containing the node being visited
    * @param source the source representing the compilation unit containing the node being visited
    * @param typeProvider the object used to access the types from the core library
@@ skipping 1207 matching lines @@
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       _enclosingFunction = node.element;
       return super.visitFunctionDeclaration(node);
     } finally {
       _enclosingFunction = outerFunction;
     }
   }
 
   @override
-  Object visitMethodDeclaration(MethodDeclaration node) {
-    ExecutableElement outerFunction = _enclosingFunction;
-    try {
-      _enclosingFunction = node.element;
-      return super.visitMethodDeclaration(node);
-    } finally {
-      _enclosingFunction = outerFunction;
-    }
-  }
-
-  @override
   Object visitFunctionExpression(FunctionExpression node) {
     if (node.parent is! FunctionDeclaration) {
       ExecutableElement outerFunction = _enclosingFunction;
       try {
         _enclosingFunction = node.element;
         return super.visitFunctionExpression(node);
       } finally {
         _enclosingFunction = outerFunction;
       }
     } else {
       return super.visitFunctionExpression(node);
     }
   }
 
   @override
   Object visitImportDirective(ImportDirective node) => null;
 
   @override
+  Object visitMethodDeclaration(MethodDeclaration node) {
+    ExecutableElement outerFunction = _enclosingFunction;
+    try {
+      _enclosingFunction = node.element;
+      return super.visitMethodDeclaration(node);
+    } finally {
+      _enclosingFunction = outerFunction;
+    }
+  }
+
+  @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     // Ignore if already resolved - declaration or type.
     if (node.staticElement != null) {
       return null;
     }
     // Ignore if qualified.
     AstNode parent = node.parent;
     if (parent is PrefixedIdentifier && identical(parent.identifier, node)) {
       return null;
     }
@@ skipping 520 matching lines @@
    * library.
    */
   final HashSet<String> members = new HashSet<String>();
 
   /**
    * Names of resolved or unresolved class members that are read in the
    * library.
    */
   final HashSet<String> readMembers = new HashSet<String>();
 }