support part file completions

pkg/analysis_server/lib/src/services/completion/dart_completion_cache.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 services.completion.dart.cache;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analysis_server/src/protocol_server.dart' hide Element,
@@ skipping 63 matching lines @@
   DartCompletionCache(AnalysisContext context, Source source)
       : super(context, source);
 
   /**
    * Return a hash of the import directives for the cached import info
    * or `null` if nothing has been cached.
    */
   String get importKey => _importKey;
 
   /**
-   * Compute suggestions based upon the imports in the given compilation unit.
-   * On return, the cache will be populated except for lower priority
-   * suggestions added as a result of a global search. Callers may wait
-   * on the returned future if they want to ensure those lower priority
-   * suggestions are part of the cached suggestions.
+   * Given a resolved compilation unit, compute suggestions based upon the
+   * imports and other dart files (e.g. "part" files) in the library containing
+   * the given compilation unit. On return, the cache will be populated
+   * except for lower priority suggestions added as a result of a global search.
+   * Callers may wait on the returned future if they want to ensure those lower
+   * priority suggestions are part of the cached suggestions.
    */
   Future<bool> computeImportInfo(CompilationUnit unit,
       SearchEngine searchEngine) {
     importedTypeSuggestions = <CompletionSuggestion>[];
     libraryPrefixSuggestions = <CompletionSuggestion>[];
     otherImportedSuggestions = <CompletionSuggestion>[];
     importedVoidReturnSuggestions = <CompletionSuggestion>[];
     importedClassMap = new Map<String, ClassElement>();
     _importedCompletions = new HashSet<String>();
 
+    // Assert the that compilation unit is resolved
+    // and represents the expected source
+    assert(unit.element.source == source);
+
     // Exclude elements from local library
     // because they are provided by LocalComputer
     Set<LibraryElement> excludedLibs = new Set<LibraryElement>();
     excludedLibs.add(unit.element.enclosingElement);
 
+    // Determine the compilation unit defining the library containing
+    // this compilation unit
+    List<Source> libraries = context.getLibrariesContaining(source);
+    Source libSource = null;
+    CompilationUnit libUnit = null;
+    if (libraries != null && libraries.length > 0) {
+      libSource = libraries[0];
+      if (libSource == source) {
+        // If the sources are the same then we already have the library unit
+        libUnit = unit;
+      } else {
+        // If this is a part and we have the resolved  unit for the part,
+        // then assume that the library unit is cached
+        // or is not-costly to recompute
+        libUnit = context.resolveCompilationUnit2(libSource, libSource);

[Paul Berry, 2014/12/18 18:37:02]

Two issues:
1. context.resolveCompilationUnit2(libSource, libSource) will give us the
resolved AST for libSource.  I think we want the resolved AST for source, so
this should be context.resolveCompilationUnit2(source, libSource).

2. Why not use context.computeResolvedCompilationUnitAsync()?  Its whole reason
for existence is to allow the completion engine to get resolved AST's without
blocking, which is exactly what we want here.  If your assumption is correct
that the AST is cached or is not costly to recompute, then there's no harm; and
if your assumption is wrong and it is costly to recompute (say because a bunch
of other libraries need to be analyzed first) the server will still be able to
respond to other requests from the client.

[danrubel, 2014/12/19 18:46:09]

I need the library unit not the part unit to traverse the library directives and
cache the imported elements.
Right! I use computeResolvedCompilationUnitAsync elsewhere and should use it
here as well. Done.

[Paul Berry, 2014/12/19 19:13:30]

Ok.  It would be nice to add a comment to the code explaining this, since at
first glance it looks like a mistake.

[danrubel, 2014/12/20 05:12:30]

Good point. Done.

+      }
+    }
+
     // Include explicitly imported elements
-    unit.directives.forEach((Directive directive) {
-      if (directive is ImportDirective) {
-        ImportElement importElem = directive.element;
-        if (importElem != null && importElem.importedLibrary != null) {
-          if (directive.prefix == null) {
-            Namespace importNamespace =
-                new NamespaceBuilder().createImportNamespaceForDirective(importElem);
-            // Include top level elements
-            importNamespace.definedNames.forEach((String name, Element elem) {
-              if (elem is ClassElement) {
-                importedClassMap[name] = elem;
-              }
-              addSuggestion(elem, CompletionRelevance.DEFAULT);
-            });
-          } else {
-            // Exclude elements from prefixed imports
-            // because they are provided by InvocationComputer
-            excludedLibs.add(importElem.importedLibrary);
-            _addLibraryPrefixSuggestion(importElem);
+    if (libUnit != null) {
+      libUnit.directives.forEach((Directive directive) {
+        if (directive is ImportDirective) {
+          ImportElement importElem = directive.element;
+          if (importElem != null && importElem.importedLibrary != null) {
+            if (directive.prefix == null) {
+              Namespace importNamespace =
+                  new NamespaceBuilder().createImportNamespaceForDirective(importElem);
+              // Include top level elements
+              importNamespace.definedNames.forEach((String name, Element elem) {
+                if (elem is ClassElement) {
+                  importedClassMap[name] = elem;
+                }
+                addSuggestion(elem, CompletionRelevance.DEFAULT);
+              });
+            } else {
+              // Exclude elements from prefixed imports
+              // because they are provided by InvocationComputer
+              excludedLibs.add(importElem.importedLibrary);
+              _addLibraryPrefixSuggestion(importElem);
+            }
+          }
+        } else if (directive is PartDirective) {
+          CompilationUnitElement partElem = directive.element;
+          if (partElem != null && partElem.source != source) {
+            partElem.accept(new _NonLocalElementCacheVisitor(this));
           }
         }
+      });
+      if (libSource != source) {
+        libUnit.element.accept(new _NonLocalElementCacheVisitor(this));
       }
-    });
+    }
 
     // Include implicitly imported dart:core elements
     Source coreUri = context.sourceFactory.forUri('dart:core');
     LibraryElement coreLib = context.getLibraryElement(coreUri);
     Namespace coreNamespace =
         new NamespaceBuilder().createPublicNamespaceForLibrary(coreLib);
     coreNamespace.definedNames.forEach((String name, Element elem) {
       if (elem is ClassElement) {
         importedClassMap[name] = elem;
       }
@@ skipping 100 matching lines @@
   String _computeImportKey(CompilationUnit unit) {
     StringBuffer sb = new StringBuffer();
     unit.directives.forEach((Directive directive) {
       if (directive is ImportDirective) {
         sb.write(directive.toSource());
       }
     });
     return sb.toString();
   }
 }
+
+/**
+ * A visitor for building suggestions based upon the elements defined by
+ * a source file contained in the same library but not the same as
+ * the source in which the completions are being requested.
+ */
+class _NonLocalElementCacheVisitor extends GeneralizingElementVisitor {
+  final DartCompletionCache cache;
+
+  _NonLocalElementCacheVisitor(this.cache);
+
+  @override
+  void visitClassElement(ClassElement element) {
+    cache.addSuggestion(element, CompletionRelevance.DEFAULT);
+  }
+
+  @override
+  void visitCompilationUnitElement(CompilationUnitElement element) {
+    element.visitChildren(this);
+  }
+
+  @override
+  void visitElement(Element element) {
+    // ignored
+  }
+
+  @override
+  void visitFunctionElement(FunctionElement element) {
+    cache.addSuggestion(element, CompletionRelevance.DEFAULT);
+  }
+
+  @override
+  void visitFunctionTypeAliasElement(FunctionTypeAliasElement element) {
+    cache.addSuggestion(element, CompletionRelevance.DEFAULT);
+  }
+
+  @override
+  void visitTopLevelVariableElement(TopLevelVariableElement element) {
+    cache.addSuggestion(element, CompletionRelevance.DEFAULT);
+  }
+}