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) {

[Brian Wilkerson, 2014/11/21 19:50:41]

Export directives also have combinators. Do we need to prepare them here as we
did for import directives?

[scheglov, 2014/11/21 20:07:17]

Done.

+    String uri = _getStringValue(node.uri);
+    if (uri != null) {
+      ExportElement element =
+          _findUriReferencedElement(_enclosingLibrary.exports, uri);
+      _processElement(element);
+    }
   }
 
   @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);
+      }
+      // prepare shown/hidden names in the element
+      Set<String> showNames = new Set<String>();
+      Set<String> hideNames = new Set<String>();
+      for (NamespaceCombinator combinator in element.combinators) {
+        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 node.combinators) {
+        if (combinator is ShowCombinator) {
+          for (SimpleIdentifier nameNode in combinator.shownNames) {
+            String name = nameNode.name;
+            _assertTrue(showNames.remove(name));
+          }
+          _assertTrue(showNames.isEmpty);
+        } else if (combinator is HideCombinator) {
+          for (SimpleIdentifier nameNode in combinator.hiddenNames) {
+            String name = nameNode.name;
+            _assertTrue(hideNames.remove(name));
+          }
+          _assertTrue(hideNames.isEmpty);
+        }
+      }
     }
-    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 77 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);
@@ skipping 59 matching lines @@
       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);
     }
   }
 }