Change HashMap declarations back to Map.

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 'dart:collection';
 
 import 'package:analysis_server/src/analysis_logger.dart';
@@ skipping 32 matching lines @@
    * The default options used to create new analysis contexts.
    */
   AnalysisOptionsImpl defaultOptions = new AnalysisOptionsImpl();
 
   AnalysisServerContextDirectoryManager(
       this.analysisServer, ResourceProvider resourceProvider,
       PackageMapProvider packageMapProvider)
       : super(resourceProvider, packageMapProvider);
 
   @override
-  void addContext(Folder folder, HashMap<String, List<Folder>> packageMap) {
+  void addContext(Folder folder, Map<String, List<Folder>> packageMap) {
     AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
     analysisServer.folderMap[folder] = context;
     context.sourceFactory = _createSourceFactory(packageMap);
     context.analysisOptions = new AnalysisOptionsImpl.con1(defaultOptions);
     analysisServer.schedulePerformAnalysisOperation(context);
   }
 
   @override
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet) {
     AnalysisContext context = analysisServer.folderMap[contextFolder];
     context.applyChanges(changeSet);
     analysisServer.schedulePerformAnalysisOperation(context);
   }
 
   @override
   void removeContext(Folder folder) {
     analysisServer.folderMap.remove(folder);
   }
 
   @override
   void updateContextPackageMap(Folder contextFolder,
-                               HashMap<String, List<Folder>> packageMap) {
+                               Map<String, List<Folder>> packageMap) {
     AnalysisContext context = analysisServer.folderMap[contextFolder];
     context.sourceFactory = _createSourceFactory(packageMap);
     analysisServer.schedulePerformAnalysisOperation(context);
   }
 
   /**
    * Set up a [SourceFactory] that resolves packages using the given
    * [packageMap].
    */
-  SourceFactory _createSourceFactory(HashMap<String, List<Folder>> packageMap) {
+  SourceFactory _createSourceFactory(Map<String, List<Folder>> packageMap) {
     List<UriResolver> resolvers = <UriResolver>[
         new DartUriResolver(analysisServer.defaultSdk),
         new ResourceUriResolver(resourceProvider),
         new PackageMapUriResolver(resourceProvider, packageMap)
     ];
     return new SourceFactory(resolvers);
   }
 }
 
 /**
@@ skipping 38 matching lines @@
   List<RequestHandler> handlers;
 
   /**
    * The current default [DartSdk].
    */
   DartSdk defaultSdk = SHARED_SDK;
 
   /**
    * A table mapping [Folder]s to the [AnalysisContext]s associated with them.
    */
-  final HashMap<Folder, AnalysisContext> folderMap =
+  final Map<Folder, AnalysisContext> folderMap =
       new HashMap<Folder, AnalysisContext>();
 
   /**
    * A queue of the operations to perform in this server.
    *
    * Invariant: when this queue is non-empty, there is exactly one pending call
    * to [performOperation] on the event queue.  When this list is empty, there are
    * no calls to [performOperation] on the event queue.
    */
   ServerOperationQueue operationQueue;
 
   /**
    * A set of the [ServerService]s to send notifications for.
    */
   Set<ServerService> serverServices = new HashSet<ServerService>();
 
   /**
    * A table mapping [AnalysisService]s to the file paths for which these
    * notifications should be sent.
    */
-  HashMap<AnalysisService, Set<String>> analysisServices =
+  Map<AnalysisService, Set<String>> analysisServices =
       new HashMap<AnalysisService, Set<String>>();
 
   /**
    * True if any exceptions thrown by analysis should be propagated up the call
    * stack.
    */
   bool rethrowExceptions;
 
   /**
    * Initialize a newly created server to receive requests from and send
@@ skipping 39 matching lines @@
    * Send the given [notification] to the client.
    */
   void sendNotification(Notification notification) {
     channel.sendNotification(notification);
   }
 
   /**
    * Set the priority files to the given [files].
    */
   void setPriorityFiles(Request request, List<String> files) {
-    HashMap<AnalysisContext, List<Source>> sourceMap =
+    Map<AnalysisContext, List<Source>> sourceMap =
         new HashMap<AnalysisContext, List<Source>>();
     List<String> unanalyzed = new List<String>();
     files.forEach((file) {
       AnalysisContext analysisContext = _getAnalysisContext(file);
       if (analysisContext == null) {
         unanalyzed.add(file);
       } else {
         List<Source> sourceList = sourceMap[analysisContext];
         if (sourceList == null) {
           sourceList = <Source>[];
@@ skipping 156 matching lines @@
    * being performed or `null` if analysis is complete.
    */
   void sendStatusNotification(ServerOperation operation) {
     // Only send status when it changes
     bool isAnalyzing = operation != null;
     if (statusAnalyzing == isAnalyzing) {
       return;
     }
     statusAnalyzing = isAnalyzing;
     Notification notification = new Notification(SERVER_STATUS);
-    HashMap<String, Object> analysis = new HashMap();
+    Map<String, Object> analysis = new HashMap();
     analysis['analyzing'] = isAnalyzing;
     notification.params['analysis'] = analysis;
     channel.sendNotification(notification);
   }
 
   /**
    * Implementation for `analysis.setAnalysisRoots`.
    *
    * TODO(scheglov) implement complete projects/contexts semantics.
    *
@@ skipping 12 matching lines @@
     } on UnimplementedError catch (e) {
       throw new RequestFailure(
                   new Response.unsupportedFeature(
                       requestId, e.message));
     }
   }
 
   /**
    * Implementation for `analysis.updateContent`.
    */
-  void updateContent(HashMap<String, ContentChange> changes) {
+  void updateContent(Map<String, ContentChange> changes) {
     changes.forEach((file, change) {
       AnalysisContext analysisContext = _getAnalysisContext(file);
       // TODO(paulberry): handle the case where a file is referred to by more
       // than one context (e.g package A depends on package B using a local
       // path, user has both packages open for editing in separate contexts,
       // and user modifies a file in package B).
       if (analysisContext != null) {
         Source source = _getSource(file);
         if (change.offset == null) {
           analysisContext.setContents(source, change.content);
         } else {
           analysisContext.setChangedContents(source, change.content,
               change.offset, change.oldLength, change.newLength);
         }
         schedulePerformAnalysisOperation(analysisContext);
       }
     });
   }
 
   /**
    * Implementation for `analysis.setSubscriptions`.
    */
-  void setAnalysisSubscriptions(HashMap<AnalysisService, Set<String>> subscriptions) {
+  void setAnalysisSubscriptions(Map<AnalysisService, Set<String>> subscriptions) {
     // send notifications for already analyzed sources
     subscriptions.forEach((service, Set<String> newFiles) {
       Set<String> oldFiles = analysisServices[service];
       Set<String> todoFiles = oldFiles != null ? newFiles.difference(oldFiles) : newFiles;
       for (String file in todoFiles) {
         if (service == AnalysisService.ERRORS) {
           Source source = _getSource(file);
           AnalysisContext analysisContext = _getAnalysisContext(file);
           List<AnalysisError> errors = analysisContext.getErrors(source).errors;
           sendAnalysisNotificationErrors(this, file, errors);
@@ skipping 127 matching lines @@
 /**
  * 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);
 }