Matching for import/export/part directives.

pkg/analyzer/lib/src/generated/incremental_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.incremental_resolver;
 
 import 'dart:collection';
 
 import 'ast.dart';
 import 'element.dart';
 import 'error.dart';
 import 'java_engine.dart';
 import 'resolver.dart';
 import 'scanner.dart';
 import 'source.dart';
 
 
 /**
  * Instances of the class [DeclarationMatcher] determine whether the element
  * model defined by a given AST structure matches an existing element model.
  */
 class DeclarationMatcher extends RecursiveAstVisitor {
   /**
+   * The libary containing the AST nodes being visited.
+   */
+  LibraryElement _enclosingLibrary;
+
+  /**
    * The compilation unit containing the AST nodes being visited.
    */
   CompilationUnitElement _enclosingUnit;
 
   /**
    * The function type alias containing the AST nodes being visited, or `null` if we are not
    * in the scope of a function type alias.
    */
   FunctionTypeAliasElement _enclosingAlias;
 
@@ skipping 105 matching lines @@
     _hasConstructor = true;
     SimpleIdentifier constructorName = node.name;
     ConstructorElement element = constructorName == null ?
         _enclosingClass.unnamedConstructor :
         _enclosingClass.getNamedConstructor(constructorName.name);
     _processElement(element);
     _assertCompatibleParameters(node.parameters, element.parameters);
   }
 
   @override
+  visitEnumConstantDeclaration(EnumConstantDeclaration node) {
+    String name = node.name.name;
+    FieldElement element = _findElement(_enclosingClass.fields, name);
+    _processElement(element);
+  }
+
+  @override
   visitEnumDeclaration(EnumDeclaration node) {
     String name = node.name.name;
     ClassElement element = _findElement(_enclosingUnit.enums, name);
     _enclosingClass = element;
     _processElement(element);
     _assertTrue(element.isEnum);
     super.visitEnumDeclaration(node);
   }
 
   @override
-  visitEnumConstantDeclaration(EnumConstantDeclaration node) {
-    String name = node.name.name;
-    FieldElement element = _findElement(_enclosingClass.fields, name);
-    _processElement(element);
+  visitExportDirective(ExportDirective node) {
+    String uri = _getStringValue(node.uri);
+    if (uri != null) {
+      ExportElement element =
+          _findUriReferencedElement(_enclosingLibrary.exports, uri);
+      _processElement(element);
+      _assertCombinators(node.combinators, element.combinators);
+    }
   }
 
   @override
-  visitExportDirective(ExportDirective node) {
-    String uri = _getStringValue(node.uri);
-    if (uri != null) {
-      LibraryElement library = _enclosingUnit.library;
-      ExportElement exportElement = _findExport(
-          library.exports,
-          _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri));
-      _processElement(exportElement);
-    }
-    super.visitExportDirective(node);
-  }
-
-  @override
   visitExpressionFunctionBody(ExpressionFunctionBody node) {
     // ignore bodies
   }
 
   @override
   visitExtendsClause(ExtendsClause node) {
     _assertSameType(node.superclass, _enclosingClass.supertype);
   }
 
   @override
@@ skipping 49 matching lines @@
   visitImplementsClause(ImplementsClause node) {
     List<TypeName> nodes = node.interfaces;
     List<InterfaceType> types = _enclosingClass.interfaces;
     _assertSameTypes(nodes, types);
   }
 
   @override
   visitImportDirective(ImportDirective node) {
     String uri = _getStringValue(node.uri);
     if (uri != null) {
-      LibraryElement library = _enclosingUnit.library;
-      ImportElement importElement = _findImport(
-          library.imports,
-          _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri),
-          node.prefix);
-      _processElement(importElement);
+      ImportElement element =
+          _findUriReferencedElement(_enclosingLibrary.imports, uri);
+      _processElement(element);
+      // match the prefix
+      SimpleIdentifier prefixNode = node.prefix;
+      PrefixElement prefixElement = element.prefix;
+      if (prefixNode == null) {
+        _assertNull(prefixElement);
+      } else {
+        _assertNotNull(prefixElement);
+        _assertEquals(prefixNode.name, prefixElement.name);
+      }
+      // match combinators
+      _assertCombinators(node.combinators, element.combinators);
     }
-    super.visitImportDirective(node);
   }
 
   @override
   visitMethodDeclaration(MethodDeclaration node) {
     // prepare element name
     String name = node.name.name;
     if (name == TokenType.MINUS.lexeme &&
         node.parameters.parameters.length == 0) {
       name = "unary-";
     }
@@ skipping 15 matching lines @@
     _processElement(element);
     // TODO(scheglov) test returnType
     _assertSameType(node.returnType, element.returnType);
     _assertCompatibleParameters(node.parameters, element.parameters);
   }
 
   @override
   visitPartDirective(PartDirective node) {
     String uri = _getStringValue(node.uri);
     if (uri != null) {
-      Source partSource =
-          _enclosingUnit.context.sourceFactory.resolveUri(_enclosingUnit.source, uri);
       CompilationUnitElement element =
-          _findPart(_enclosingUnit.library.parts, partSource);
+          _findUriReferencedElement(_enclosingLibrary.parts, uri);
       _processElement(element);
     }
     super.visitPartDirective(node);
   }
 
   @override
   visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     _inTopLevelVariableDeclaration = true;
     try {
       super.visitTopLevelVariableDeclaration(node);
@@ skipping 38 matching lines @@
         element.type);
   }
 
   @override
   visitWithClause(WithClause node) {
     List<TypeName> nodes = node.mixinTypes;
     List<InterfaceType> types = _enclosingClass.mixins;
     _assertSameTypes(nodes, types);
   }
 
+  void _assertCombinators(List<Combinator> nodeCombinators,
+      List<NamespaceCombinator> elementCombinators) {
+    // prepare shown/hidden names in the element
+    Set<String> showNames = new Set<String>();
+    Set<String> hideNames = new Set<String>();
+    for (NamespaceCombinator combinator in elementCombinators) {
+      if (combinator is ShowElementCombinator) {
+        showNames.addAll(combinator.shownNames);
+      } else if (combinator is HideElementCombinator) {
+        hideNames.addAll(combinator.hiddenNames);
+      }
+    }
+    // match combinators with the node
+    for (Combinator combinator in nodeCombinators) {
+      if (combinator is ShowCombinator) {
+        for (SimpleIdentifier nameNode in combinator.shownNames) {
+          String name = nameNode.name;
+          _assertTrue(showNames.remove(name));
+        }
+      } else if (combinator is HideCombinator) {
+        for (SimpleIdentifier nameNode in combinator.hiddenNames) {
+          String name = nameNode.name;
+          _assertTrue(hideNames.remove(name));
+        }
+      }
+    }
+    _assertTrue(showNames.isEmpty);
+    _assertTrue(hideNames.isEmpty);
+  }
+
   void _assertCompatibleParameter(FormalParameter node,
       ParameterElement element) {
     if (node is SimpleFormalParameter) {
       _assertSameType(node.type, element.type);
     } else {
       // TODO(scheglov) support other parameter types
       _assertTrue(false);
     }
     // TODO(scheglov) check names of named parameters
   }
@@ skipping 19 matching lines @@
       throw new _DeclarationMismatchException();
     }
   }
 
   void _assertNotNull(Element element) {
     if (element == null) {
       throw new _DeclarationMismatchException();
     }
   }
 
+  void _assertNull(Element element) {
+    if (element != null) {
+      throw new _DeclarationMismatchException();
+    }
+  }
+
   void _assertSameType(TypeName node, DartType type) {
     // no return type == dynamic
     if (node == null) {
       return _assertTrue(type == null || type.isDynamic);
     }
     // check specific type kinds
     String nodeName = node.name.name;
     if (type is InterfaceType) {
       _assertEquals(nodeName, type.name);
       // check arguments
@@ skipping 22 matching lines @@
     }
   }
 
   void _assertTrue(bool condition) {
     if (!condition) {
       throw new _DeclarationMismatchException();
     }
   }
 
   /**
-   * Given that the comparison is to begin with the given element, capture the enclosing elements
-   * that might be used while performing the comparison.
-   *
-   * @param element the element corresponding to the AST structure to be compared
+   * Given that the comparison is to begin with the given [element], capture
+   * the enclosing elements that might be used while performing the comparison.
    */
   void _captureEnclosingElements(Element element) {
     Element parent =
         element is CompilationUnitElement ? element : element.enclosingElement;
     while (parent != null) {
       if (parent is CompilationUnitElement) {
         _enclosingUnit = parent as CompilationUnitElement;
+        _enclosingLibrary = element.library;
       } else if (parent is ClassElement) {
         if (_enclosingClass == null) {
           _enclosingClass = parent as ClassElement;
         }
       } else if (parent is FunctionTypeAliasElement) {
         if (_enclosingAlias == null) {
           _enclosingAlias = parent as FunctionTypeAliasElement;
         }
       } else if (parent is ParameterElement) {
         if (_enclosingParameter == null) {
@@ skipping 10 matching lines @@
   Element _findElement(List<Element> elements, String name) {
     for (Element element in elements) {
       if (element.displayName == name) {
         return element;
       }
     }
     return null;
   }
 
   /**
-   * Return the export element from the given array whose library has the given source, or
-   * `null` if there is no such export.
-   *
-   * @param exports the export elements being searched
-   * @param source the source of the library associated with the export element to being searched
-   *          for
-   * @return the export element whose library has the given source
-   */
-  ExportElement _findExport(List<ExportElement> exports, Source source) {
-    for (ExportElement export in exports) {
-      if (export.exportedLibrary.source == source) {
-        return export;
-      }
-    }
-    return null;
-  }
-
-  /**
    * Return the element in the given array of elements that was created for the declaration with the
    * given name.
    *
    * @param elements the elements of the appropriate kind that exist in the current context
    * @param identifier the name node in the declaration of the element to be returned
    * @return the element created for the declaration with the given name
    */
   Element _findIdentifier(List<Element> elements,
       SimpleIdentifier identifier) =>
       _findWithNameAndOffset(elements, identifier.name, identifier.offset);
 
   /**
-   * Return the import element from the given array whose library has the given source and that has
-   * the given prefix, or `null` if there is no such import.
-   *
-   * @param imports the import elements being searched
-   * @param source the source of the library associated with the import element to being searched
-   *          for
-   * @param prefix the prefix with which the library was imported
-   * @return the import element whose library has the given source and prefix
-   */
-  ImportElement _findImport(List<ImportElement> imports, Source source,
-      SimpleIdentifier prefix) {
-    for (ImportElement element in imports) {
-      if (element.importedLibrary.source == source) {
-        PrefixElement prefixElement = element.prefix;
-        if (prefix == null) {
-          if (prefixElement == null) {
-            return element;
-          }
-        } else {
-          if (prefixElement != null &&
-              prefix.name == prefixElement.displayName) {
-            return element;
-          }
-        }
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Return the element for the part with the given source, or `null` if there is no element
-   * for the given source.
-   *
-   * @param parts the elements for the parts
-   * @param partSource the source for the part whose element is to be returned
-   * @return the element for the part with the given source
-   */
-  CompilationUnitElement _findPart(List<CompilationUnitElement> parts,
-      Source partSource) {
-    for (CompilationUnitElement part in parts) {
-      if (part.source == partSource) {
-        return part;
-      }
-    }
-    return null;
-  }
-
-  /**
    * Return the element in the given array of elements that was created for the declaration with the
    * given name at the given offset.
    *
    * @param elements the elements of the appropriate kind that exist in the current context
    * @param name the name of the element to be returned
    * @param offset the offset of the name of the element to be returned
    * @return the element with the given name and offset
    */
   Element _findWithNameAndOffset(List<Element> elements, String name,
       int offset) {
     for (Element element in elements) {
       if (element.displayName == name && element.nameOffset == offset) {
         return element;
       }
     }
     return null;
   }
 
   void _gatherElements(Element element) {
-    element.accept(new _ElementsGatherer(this));
+    _ElementsGatherer gatherer = new _ElementsGatherer(this);
+    element.accept(gatherer);
+    // TODO(scheglov) push into CompilationUnitElement
+    if (identical(_enclosingUnit, _enclosingLibrary.definingCompilationUnit)) {
+      gatherer.addElements(_enclosingLibrary.imports);
+      gatherer.addElements(_enclosingLibrary.exports);
+      gatherer.addElements(_enclosingLibrary.parts);
+    }
   }
 
   /**
    * Return the value of the given string literal, or `null` if the string is not a constant
    * string without any string interpolation.
    *
    * @param literal the string literal whose value is to be returned
    * @return the value of the given string literal
    */
   String _getStringValue(StringLiteral literal) {
     if (literal is StringInterpolation) {
       return null;
     }
     return literal.stringValue;
   }
 
   void _processElement(Element element) {
     _assertNotNull(element);
     if (!_allElements.contains(element)) {
       throw new _DeclarationMismatchException();
     }
     _unmatchedElements.remove(element);
   }
+
+  /**
+   * Return the [UriReferencedElement] from [elements] with the given [uri], or
+   * `null` if there is no such element.
+   */
+  static UriReferencedElement
+      _findUriReferencedElement(List<UriReferencedElement> elements, String uri) {
+    for (UriReferencedElement element in elements) {
+      if (element.uri == uri) {
+        return element;
+      }
+    }
+    return null;
+  }
 }
 
 
 /**
  * Instances of the class [IncrementalResolver] resolve the smallest portion of
  * an AST structure that we currently know how to resolve.
  */
 class IncrementalResolver {
   /**
    * The error listener that will be informed of any errors that are found
@@ skipping 320 matching lines @@
     super.visitElement(element);
   }
 }
 
 
 class _ElementsGatherer extends GeneralizingElementVisitor {
   final DeclarationMatcher matcher;
 
   _ElementsGatherer(this.matcher);
 
+  void addElements(List<Element> elements) {
+    for (Element element in elements) {
+      if (!element.isSynthetic) {
+        _addElement(element);
+      }
+    }
+  }
+
   @override
   visitElement(Element element) {
     _addElement(element);
     super.visitElement(element);
   }
 
   @override
   visitExecutableElement(ExecutableElement element) {
     _addElement(element);
   }
@@ skipping 14 matching lines @@
     // Don't visit children (such as property accessors).
   }
 
   void _addElement(Element element) {
     if (element != null) {
       matcher._allElements.add(element);
       matcher._unmatchedElements.add(element);
     }
   }
 }