Partial implementation of the 'setAnalysisRoots' API.

pkg/analysis_server/lib/src/analysis_server.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 analysis.server;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/analysis_logger.dart';
 import 'package:analysis_server/src/channel.dart';
 import 'package:analysis_server/src/protocol.dart';
+import 'package:analysis_server/src/resource.dart';
+import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_core.dart';
+import 'package:analyzer/src/generated/sdk.dart';
+import 'package:analyzer/src/generated/sdk_io.dart';
+import 'package:analyzer/src/generated/source_io.dart';
 
 /**
  * Instances of the class [AnalysisServer] implement a server that listens on a
  * [CommunicationChannel] for analysis requests and process them.
  */
 class AnalysisServer {
   /**
    * The name of the notification of new errors associated with a source.
    */
   static const String ERROR_NOTIFICATION_NAME = 'context.errors';
@@ skipping 18 matching lines @@
    */
   static const String CONNECTED_NOTIFICATION = 'server.connected';
 
   /**
    * The channel from which requests are received and to which responses should
    * be sent.
    */
   final ServerCommunicationChannel channel;
 
   /**
+   * The [ResourceProvider] using which paths are converted into [Resource]s.
+   */
+  final ResourceProvider resourceProvider;
+
+  /**
    * A flag indicating whether the server is running.  When false, contexts
    * will no longer be added to [contextWorkQueue], and [performTask] will
    * discard any tasks it finds on [contextWorkQueue].
    */
   bool running;
 
   /**
    * A list of the request handlers used to handle the requests sent to this
    * server.
    */
   List<RequestHandler> handlers;
 
-  /**
-   * A table mapping context id's to the analysis contexts associated with them.
-   */
-  final Map<String, AnalysisContext> contextMap = new Map<String, AnalysisContext>();
+  // TODO(scheglov) remove once setAnalysisRoots() is completely implemented
+//  /**
+//   * A table mapping context id's to the analysis contexts associated with them.
+//   */
+//  final Map<String, AnalysisContext> contextMap = new Map<String, AnalysisContext>();
+//
+//  /**
+//   * A table mapping analysis contexts to the context id's associated with them.
+//   */
+//  final Map<AnalysisContext, String> contextIdMap = new Map<AnalysisContext, String>();
 
   /**
-   * A table mapping analysis contexts to the context id's associated with them.
+   * A table mapping [Folder]s to the [PubFolder]s associated with them.
    */
-  final Map<AnalysisContext, String> contextIdMap = new Map<AnalysisContext, String>();
+  final Map<Folder, PubFolder> folderMap = <Folder, PubFolder>{};
 
   /**
    * A list of the analysis contexts for which analysis work needs to be
    * performed.
    *
    * Invariant: when this list is non-empty, there is exactly one pending call
    * to [performTask] on the event queue.  When this list is empty, there are
    * no calls to [performTask] on the event queue.
    */
   final List<AnalysisContext> contextWorkQueue = new List<AnalysisContext>();
 
   /**
    * A set of the [ServerService]s to send notifications for.
    */
   Set<ServerService> serverServices = new Set<ServerService>();
 
   /**
    * Initialize a newly created server to receive requests from and send
    * responses to the given [channel].
    */
-  AnalysisServer(this.channel) {
+  AnalysisServer(this.channel, this.resourceProvider) {
     AnalysisEngine.instance.logger = new AnalysisLogger();
     running = true;
     Notification notification = new Notification(CONNECTED_NOTIFICATION);
     channel.sendNotification(notification);
     channel.listen(handleRequest, onDone: done, onError: error);
   }
 
   /**
    * If [running] is true, add the given [context] to the list of analysis
    * contexts for which analysis work needs to be performed, and ensure that
@@ skipping 60 matching lines @@
       contextWorkQueue.clear();
     }
     if (contextWorkQueue.isEmpty) {
       // Nothing to do.
       return;
     }
     //
     // Look for a context that has work to be done and then perform one task.
     //
     List<ChangeNotice> notices = null;
-    String contextId;
+//    String contextId;
     try {
       AnalysisContext context = contextWorkQueue[0];
-      contextId = contextIdMap[context];
+//      contextId = contextIdMap[context];
       AnalysisResult result = context.performAnalysisTask();
       notices = result.changeNotices;
     } finally {
       if (notices == null) {
         // Either we have no more work to do for this context, or there was an
         // unhandled exception trying to perform the analysis.  In either case,
         // remove the context form the work queue so we won't try to do more
         // analysis on it.
         contextWorkQueue.removeAt(0);
       }
       //
       // Schedule this method to be run again if there is any more work to be
       // done.
       //
       if (!contextWorkQueue.isEmpty) {
         _scheduleTask();
       }
     }
-    if (notices != null) {
-      sendNotices(contextId, notices);
+    // TODO(scheglov) implement for [PubFolder]
+//    if (notices != null) {
+//      sendNotices(contextId, notices);
+//    }
+  }
+
+  // TODO(scheglov) rewrite for the new API.
+//  /**
+//   * Send the information in the given list of notices back to the client.
+//   */
+//  void sendNotices(String contextId, List<ChangeNotice> notices) {
+//    for (int i = 0; i < notices.length; i++) {
+//      ChangeNotice notice = notices[i];
+//      Notification notification = new Notification(ERROR_NOTIFICATION_NAME);
+//      notification.setParameter(CONTEXT_ID_PARAM, contextId);
+//      notification.setParameter(SOURCE_PARAM, notice.source.encoding);
+//      notification.setParameter(ERRORS_PARAM, notice.errors.map(
+//          errorToJson).toList());
+//      sendNotification(notification);
+//    }
+//  }
+
+  void setAnalysisRoots(Set<Folder> includedFolders, Set<Folder> excludedFolders) {

[Brian Wilkerson, 2014/05/27 14:09:57]

This doesn't look for nested pub folders.

[scheglov, 2014/05/27 18:24:24]

Yes, and it is intentional.
I've added comment to this method to specify this temporary limitation.

+    Set<Folder> currentFolders = new Set<Folder>.from(folderMap.keys);

[Paul Berry, 2014/05/27 16:30:29]

What about analysis roots that aren't folders?

+    Set<Folder> newFolders = includedFolders.difference(currentFolders);
+    Set<Folder> oldFolders = currentFolders.difference(includedFolders);
+    // remove old contexts
+    for (Folder folder in oldFolders) {
+      // TODO(scheglov) implement
+    }
+    // add new contexts
+    for (Folder folder in newFolders) {
+      PubFolder pubFolder = new PubFolder(folder);

[Brian Wilkerson, 2014/05/27 14:09:57]

What about analysis roots that do not contain a pubspec?

+      folderMap[folder] = pubFolder;
+      addContextToWorkQueue(pubFolder.context);
     }
   }
 
   /**
-   * Send the information in the given list of notices back to the client.
+   * Return the [AnalysisContext] that is used to analyze the given [path].
+   * Return `null` if there is no such context.
    */
-  void sendNotices(String contextId, List<ChangeNotice> notices) {
-    for (int i = 0; i < notices.length; i++) {
-      ChangeNotice notice = notices[i];
-      Notification notification = new Notification(ERROR_NOTIFICATION_NAME);
-      notification.setParameter(CONTEXT_ID_PARAM, contextId);
-      notification.setParameter(SOURCE_PARAM, notice.source.encoding);
-      notification.setParameter(ERRORS_PARAM, notice.errors.map(
-          errorToJson).toList());
-      sendNotification(notification);
+  AnalysisContext test_getAnalysisContext(String path) {

[Paul Berry, 2014/05/27 16:30:29]

What does it mean that this function (and test_getResolvedCompilationUnit) begin
with "test_"?

[scheglov, 2014/05/27 18:24:24]

These methods are supposed to be used only by tests.

+    for (Folder folder in folderMap.keys) {
+      if (path.startsWith(folder.fullName)) {

[Brian Wilkerson, 2014/05/27 14:09:57]

Would it be better to use the names of folders as keys rather than the folders
themselves?

[scheglov, 2014/05/27 18:24:24]

I don't know.
In theory Resource can provide some services, like Folder.containsPath(path).

But I don't have a strong opinion.

+        return folderMap[folder].context;
+      }
     }
+    return null;
+  }
+
+  /**
+   * Return the [CompilationUnit] of the Dart file with the given [path].

[Paul Berry, 2014/05/27 16:30:29]

What happens if the dart file in question isn't underneath a directory with a
pubspec?  This could happen if the file in question is inside the SDK.  It will
also be possible for files in packages, once we move away from relying on the
"packages" links (which I'm hoping we can do ASAP).

[scheglov, 2014/05/27 18:24:24]

I guess we will have to check if the file is under SDK directory and ask SDK for
the context instead of a PubFolder.

+   * Return `null` if the file is not a part of any context.
+   */
+  CompilationUnit test_getResolvedCompilationUnit(String path) {
+    // prepare AnalysisContext
+    AnalysisContext context = test_getAnalysisContext(path);
+    if (context == null) {
+      return null;
+    }
+    // prepare sources
+    File file = resourceProvider.getResource(path);
+    Source unitSource = file.createSource(UriKind.FILE_URI);
+    List<Source> librarySources = context.getLibrariesContaining(unitSource);
+    if (librarySources.isEmpty) {
+      return null;
+    }
+    // get a resolved unit
+    return context.getResolvedCompilationUnit2(unitSource, librarySources[0]);
   }
 
   static Map<String, Object> errorToJson(AnalysisError analysisError) {
     // TODO(paulberry): move this function into the AnalysisError class.
 
     // TODO(paulberry): we really shouldn't be exposing errorCode.ordinal
     // outside the analyzer, since the ordinal numbers change whenever we
     // regenerate the analysis engine.
     Map<String, Object> result = {
       'source': analysisError.source.encoding,
@@ skipping 33 matching lines @@
   static const AnalysisService OUTLINE = const AnalysisService('OUTLINE', 3);
 
   static const List<AnalysisService> VALUES =
       const [ERRORS, HIGHLIGHTS, NAVIGATION, OUTLINE];
 
   const AnalysisService(String name, int ordinal) : super(name, ordinal);
 }
 
 
 /**
+ * Instances of [PubFolder] represents a [Folder] with a Pub `pubspec.yaml`.
+ *
+ * TODO(scheglov) implement complete projects/contexts semantics.
+ *
+ * This class is intentionally simplified to serve as a base to start working
+ * on services while work on complete semantics is being done in parallel.
+ */
+class PubFolder {
+  static final DartSdk DEFAULT_SDK = DirectoryBasedDartSdk.defaultSdk;

[Brian Wilkerson, 2014/05/27 14:09:57]

I don't think this is the best place to store the default SDK. I think the
instance of the AnalysisServer would be better.

Also, this cannot be final because clients can reset the default SDK.

[scheglov, 2014/05/27 18:24:24]

Done.

+
+  /**
+   * The root [Folder] of this [PubFolder].
+   */
+  final Folder _folder;
+
+  /**
+   * The `pubspec.yaml` file in [_folder].
+   */
+  File _pubspecFile;
+
+  /**
+   * The [AnalysisContext] of this [_folder].
+   */
+  AnalysisContext _context;
+
+  PubFolder(this._folder) {
+    // prepare pubspec.yaml
+    _pubspecFile = _folder.getChild('pubspec.yaml');
+    if (!_pubspecFile.exists) {
+      throw new ArgumentError('$_pubspecFile does not exist');
+    }
+    // TODO(scheglov) use configurable default SDK
+    DartSdk sdk = DEFAULT_SDK;
+    // create AnalysisContext
+    _context = AnalysisEngine.instance.createAnalysisContext();
+    // TODO(scheglov) replace FileUriResolver with an Resource based resolver
+    // TODO(scheglov) create packages resolver
+    _context.sourceFactory = new SourceFactory([
+      new DartUriResolver(sdk),
+      new FileUriResolver(),
+      // new PackageUriResolver(),
+    ]);
+    // add folder files
+    {
+      ChangeSet changeSet = new ChangeSet();
+      _addSourceFiles(changeSet, _folder);
+      _context.applyChanges(changeSet);
+    }
+  }
+
+  /**
+   * Return the [AnalysisContext] of this folder.
+   */
+  AnalysisContext get context => _context;
+
+  /**
+   * Resursively adds all Dart and HTML files to the [changeSet].
+   */
+  static void _addSourceFiles(ChangeSet changeSet, Folder folder) {
+    List<Resource> children = folder.getChildren();
+    for (Resource child in children) {
+      if (child is File) {
+        String fileName = child.shortName;
+        if (AnalysisEngine.isDartFileName(fileName)
+            || AnalysisEngine.isHtmlFileName(fileName)) {
+          Source source = child.createSource(UriKind.FILE_URI);
+          changeSet.addedSource(source);
+        }
+      } else if (child is Folder) {
+        _addSourceFiles(changeSet, child);
+      }
+    }
+  }
+}
+
+
+/**
  * An enumeration of the services provided by the server domain.
  */
 class ServerService extends Enum2<ServerService> {
   static const ServerService STATUS = const ServerService('STATUS', 0);
 
   static const List<ServerService> VALUES = const [STATUS];
 
   const ServerService(String name, int ordinal) : super(name, ordinal);
 }