Use package: URIs for files in lib

pkg/analysis_server/lib/src/context_manager.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 context.directory.manager;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/file_system/file_system.dart';
@@ skipping 18 matching lines @@
  */
 const String PUBSPEC_NAME = 'pubspec.yaml';
 
 
 /**
  * Class that maintains a mapping from included/excluded paths to a set of
  * folders that should correspond to analysis contexts.
  */
 abstract class ContextManager {
   /**
+   * The name of the `lib` directory.
+   */
+  static const String LIB_DIR_NAME = 'lib';
+
+  /**
    * [_ContextInfo] object for each included directory in the most
    * recent successful call to [setRoots].
    */
   Map<Folder, _ContextInfo> _contexts = new HashMap<Folder, _ContextInfo>();
 
   /**
    * The [ResourceProvider] using which paths are converted into [Resource]s.
    */
   final ResourceProvider resourceProvider;
 
@@ skipping 29 matching lines @@
    * Provider which is used to determine the mapping from package name to
    * package folder.
    */
   final PackageMapProvider _packageMapProvider;
 
   ContextManager(this.resourceProvider, this._packageMapProvider) {
     pathContext = resourceProvider.pathContext;
   }
 
   /**
-   * Called when a new context needs to be created.
+   * Create and return a new analysis context.
    */
-  void addContext(Folder folder, UriResolver packageUriResolver);
+  AnalysisContext addContext(Folder folder, UriResolver packageUriResolver);
 
   /**
    * Called when the set of files associated with a context have changed (or
    * some of those files have been modified).  [changeSet] is the set of
    * changes that need to be applied to the context.
    */
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet);
 
   /**
    * We are about to start computing the package map.
@@ skipping 174 matching lines @@
           continue;
         }
         _addPreviouslyExcludedSources(info, changeSet, child, oldExcludedPaths);
       }
     }
   }
 
   /**
    * Resursively adds all Dart and HTML files to the [changeSet].
    */
-  void _addSourceFiles(ChangeSet changeSet, Folder folder, _ContextInfo info) {
+  void _addSourceFiles(ChangeSet changeSet, Folder folder, _ContextInfo info,
+      bool pubspecExists, bool createPackageUri) {
     if (info.excludesResource(folder) || folder.shortName.startsWith('.')) {
       return;
     }
     List<Resource> children = folder.getChildren();
     for (Resource child in children) {
       String path = child.path;
       // ignore excluded files or folders
       if (_isExcluded(path)) {
         continue;
       }
       // add files, recurse into folders
       if (child is File) {
         if (_shouldFileBeAnalyzed(child)) {
           Source source = child.createSource();
+          if (createPackageUri) {

[Paul Berry, 2015/02/12 21:56:09]

I think we could achieve the same effect with less effort by just doing this
logic unconditionally.  If the file is inside the package's "lib" folder, then
restoreUri() will return a "package:" URI for it.  If not, then it will fall
back to the ResourceUriResolver, which will just return the source's file URI.

The advantage of doing that would be that we don't have to hard code the name of
the "lib" directory (we get it from "pub list" instead), and we don't have to do
any bookkeeping inside this function to remember whether we're inside the "lib"
directory.

[Brian Wilkerson, 2015/02/13 17:46:07]

Your comment got me to thinking more deeply about this, and I became convinced
that we can't use the UriResolvers at all because they don't know about files in
their own package. I wrote a test to confirm that, and it failed as I expected
it to. I have re-written this slightly, but it's possible that there's still a
way to simplify the code.

+            Uri uri = info.context.sourceFactory.restoreUri(source);
+            source = child.createSource(uri);
+          }
           changeSet.addedSource(source);
           info.sources[path] = source;
         }
       } else if (child is Folder) {
-        if (child.shortName == PACKAGES_NAME) {
+        String shortName = child.shortName;
+        if (shortName == PACKAGES_NAME) {
           continue;
         }
-        _addSourceFiles(changeSet, child, info);
+        if (pubspecExists &&
+            !createPackageUri &&
+            shortName == LIB_DIR_NAME &&
+            child.parent == info.folder) {
+          createPackageUri = true;
+        }
+        _addSourceFiles(
+            changeSet,
+            child,
+            info,
+            pubspecExists,
+            createPackageUri);
       }
     }
   }
 
   /**
    * Compute the appropriate package URI resolver for [folder], and store
    * dependency information in [info]. Return `null` if no package map can
    * be computed.
    */
   UriResolver _computePackageUriResolver(Folder folder, _ContextInfo info) {
@@ skipping 13 matching lines @@
           resourceProvider,
           packageMapInfo.packageMap);
       // TODO(paulberry): if any of the dependencies is outside of [folder],
       // we'll need to watch their parent folders as well.
     }
   }
 
   /**
    * Create a new empty context associated with [folder].
    */
-  _ContextInfo _createContext(Folder folder, List<_ContextInfo> children) {
-    _ContextInfo info =
-        new _ContextInfo(folder, children, normalizedPackageRoots[folder.path]);
+  _ContextInfo _createContext(Folder folder, File pubspecFile,
+      List<_ContextInfo> children) {
+    _ContextInfo info = new _ContextInfo(
+        folder,
+        pubspecFile,
+        children,
+        normalizedPackageRoots[folder.path]);
     _contexts[folder] = info;
     info.changeSubscription = folder.changes.listen((WatchEvent event) {
       _handleWatchEvent(folder, info, event);
     });
     UriResolver packageUriResolver = _computePackageUriResolver(folder, info);
-    addContext(folder, packageUriResolver);
+    info.context = addContext(folder, packageUriResolver);
     return info;
   }
 
   /**
    * Creates a new context associated with [folder].
    *
    * If there are subfolders with 'pubspec.yaml' files, separate contexts
    * are created for them, and excluded from the context associated with
    * [folder].
    *
    * If [folder] itself contains a 'pubspec.yaml' file, subfolders are ignored.
    *
    * If [withPubspecOnly] is `true`, a context will be created only if there
    * is a 'pubspec.yaml' file in [folder].
    *
    * Returns create pubspec-based contexts.
    */
   List<_ContextInfo> _createContexts(Folder folder, bool withPubspecOnly) {
-    // check if there is a pubspec in the folder
-    {
-      File pubspecFile = folder.getChild(PUBSPEC_NAME);
-      if (pubspecFile.exists) {
-        _ContextInfo info = _createContextWithSources(folder, <_ContextInfo>[]);
-        return [info];
-      }
+    // check whether there is a pubspec in the folder
+    File pubspecFile = folder.getChild(PUBSPEC_NAME);
+    bool pubspecExists = pubspecFile.exists;
+    if (pubspecExists) {
+      _ContextInfo info = _createContextWithSources(
+          folder,
+          pubspecFile,
+          pubspecExists,
+          <_ContextInfo>[]);
+      return [info];
     }
     // try to find subfolders with pubspec files
     List<_ContextInfo> children = <_ContextInfo>[];
     for (Resource child in folder.getChildren()) {
       if (child is Folder) {
         List<_ContextInfo> childContexts = _createContexts(child, true);
         children.addAll(childContexts);
       }
     }
     // no pubspec, done
     if (withPubspecOnly) {
       return children;
     }
     // OK, create a context without a pubspec
-    _createContextWithSources(folder, children);
+    _createContextWithSources(folder, pubspecFile, pubspecExists, children);
     return children;
   }
 
   /**
-   * Create a new context associated with [folder] and fills its with sources.
+   * Create a new context associated with the given [folder]. The [pubspecFile]
+   * is the `pubspec.yaml` file contained in the folder, and [pubspecExists] is
+   * `true` if the file exists. Add any sources that are not included in one of
+   * the [children] to the context.
    */
-  _ContextInfo _createContextWithSources(Folder folder,
-      List<_ContextInfo> children) {
-    _ContextInfo info = _createContext(folder, children);
+  _ContextInfo _createContextWithSources(Folder folder, File pubspecFile,
+      bool pubspecExists, List<_ContextInfo> children) {
+    _ContextInfo info = _createContext(folder, pubspecFile, children);
     ChangeSet changeSet = new ChangeSet();
-    _addSourceFiles(changeSet, folder, info);
+    _addSourceFiles(changeSet, folder, info, pubspecExists, false);
     applyChangesToContext(folder, changeSet);
     return info;
   }
 
   /**
    * Clean up and destroy the context associated with the given folder.
    */
   void _destroyContext(Folder folder) {
     _contexts[folder].changeSubscription.cancel();
     _contexts.remove(folder);
     removeContext(folder);
   }
 
   /**
    * Extract a new [pubspecFile]-based context from [oldInfo].
    */
   void _extractContext(_ContextInfo oldInfo, File pubspecFile) {
     Folder newFolder = pubspecFile.parent;
-    _ContextInfo newInfo = _createContext(newFolder, []);
+    _ContextInfo newInfo = _createContext(newFolder, pubspecFile, []);
     newInfo.parent = oldInfo;
     // prepare sources to extract
     Map<String, Source> extractedSources = new HashMap<String, Source>();
     oldInfo.sources.forEach((path, source) {
       if (newFolder.contains(path)) {
         extractedSources[path] = source;
       }
     });
     // update new context
     {
@@ skipping 192 matching lines @@
    */
   String pubspecPath;
 
   /**
    * Stream subscription we are using to watch the context's directory for
    * changes.
    */
   StreamSubscription<WatchEvent> changeSubscription;
 
   /**
+   * The analysis context that was created for the [folder].
+   */
+  AnalysisContext context;
+
+  /**
    * Map from full path to the [Source] object, for each source that has been
    * added to the context.
    */
   Map<String, Source> sources = new HashMap<String, Source>();
 
   /**
    * Dependencies of the context's package map.
    * If any of these files changes, the package map needs to be recomputed.
    */
   Set<String> packageMapDependencies;
 
-  _ContextInfo(this.folder, this.children, this.packageRoot) {
-    pubspecPath = folder.getChild(PUBSPEC_NAME).path;
+  _ContextInfo(this.folder, File pubspecFile, this.children, this.packageRoot) {
+    pubspecPath = pubspecFile.path;
     for (_ContextInfo child in children) {
       child.parent = this;
     }
   }
 
   /**
    * Returns `true` if this context is root folder based.
    */
   bool get isRoot => parent == null;
 
@@ skipping 13 matching lines @@
     return excludes(resource.path);
   }
 
   /**
    * Returns `true` if [path] is the pubspec file of this context.
    */
   bool isPubspec(String path) {
     return path == pubspecPath;
   }
 }