Add toMap / toMapOf / toList

pkg/analyzer/lib/src/task/dart.dart

 // Copyright (c) 2015, 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 analyzer.src.task.dart;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart' hide AnalysisTask;
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer/src/task/driver.dart';
 import 'package:analyzer/src/task/general.dart';
-import 'package:analyzer/src/task/inputs.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:analyzer/task/general.dart';
 import 'package:analyzer/task/model.dart';
 
 /**
  * The errors produced while resolving a library directives.
  *
  * The list will be empty if there were no errors, but will not be `null`.
  *
  * The result is only available for targets representing a Dart library.
@@ skipping 25 matching lines @@
 final ResultDescriptor<List<AnalysisError>> BUILD_LIBRARY_ERRORS =
     new ResultDescriptor<List<AnalysisError>>(
         'BUILD_LIBRARY_ERRORS', AnalysisError.NO_ERRORS,
         contributesTo: DART_ERRORS);
 
 /**
  * The sources representing the export closure of a library.
  *
  * The result is only available for targets representing a Dart library.
  */
-final ResultDescriptor<List<Source>> EXPORT_SOURCE_CLOSURE =
-    new ResultDescriptor<List<Source>>('EXPORT_SOURCE_CLOSURE', null);
+final ListResultDescriptor<Source> EXPORT_SOURCE_CLOSURE =
+    new ListResultDescriptor<Source>('EXPORT_SOURCE_CLOSURE', null);
 
 /**
  * The partial [LibraryElement] associated with a library.
  *
  * The [LibraryElement] and its [CompilationUnitElement]s are attached to each
  * other. Directives 'library', 'part' and 'part of' are resolved.
  *
  * The result is only available for targets representing a Dart library.
  */
 final ResultDescriptor<LibraryElement> LIBRARY_ELEMENT1 =
@@ skipping 96 matching lines @@
 final ResultDescriptor<CompilationUnit> RESOLVED_UNIT4 =
     new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT4', null);
 
 /**
  * The [TypeProvider] of the context.
  */
 final ResultDescriptor<TypeProvider> TYPE_PROVIDER =
     new ResultDescriptor<TypeProvider>('TYPE_PROVIDER', null);
 
 /**
+ * Return a [MapTaskInput] that maps unit [Source]s into [result]s for the
+ * pair of [libSource] and the unit [Source].
+ */
+MapTaskInput _lutMapInput(Source libSource, ResultDescriptor result) {

[Brian Wilkerson, 2015/03/24 15:07:10]

I'd really prefer a name that didn't include an abbreviation ("lut") I'll never
be able to remember. Given that it's only used in one place, I'd recommend
inlining it.

[scheglov, 2015/03/24 17:16:38]

Done.

+  return (Source unitSource) {
+    LibraryUnitTarget lut = new LibraryUnitTarget(libSource, unitSource);
+    return result.of(lut);
+  };
+}
+
+/**
  * A task that builds a compilation unit element for a single compilation unit.
  */
 class BuildCompilationUnitElementTask extends SourceBasedAnalysisTask {
   /**
    * The name of the input whose value is the line information for the
    * compilation unit.
    */
   static const String LINE_INFO_INPUT_NAME = 'LINE_INFO_INPUT_NAME';
 
   /**
@@ skipping 39 matching lines @@
     outputs[RESOLVED_UNIT1] = unit;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the given
    * [target].
    */
   static Map<String, TaskInput> buildInputs(LibraryUnitTarget target) {
     return <String, TaskInput>{
-      PARSED_UNIT_INPUT_NAME: PARSED_UNIT.inputFor(target.unit)
+      PARSED_UNIT_INPUT_NAME: PARSED_UNIT.of(target.unit)
     };
   }
 
   /**
    * Create a [BuildCompilationUnitElementTask] based on the given [target] in
    * the given [context].
    */
   static BuildCompilationUnitElementTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildCompilationUnitElementTask(context, target);
@@ skipping 176 matching lines @@
     outputs[LIBRARY_ELEMENT2] = libraryElement;
     outputs[BUILD_DIRECTIVES_ERRORS] = errors;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given library [libSource].
    */
   static Map<String, TaskInput> buildInputs(Source libSource) {
+    lut(Source unit) => new LibraryUnitTarget(libSource, unit);

[Brian Wilkerson, 2015/03/24 15:07:10]

I don't understand the point of defining a local method that's only used in one
place (especially when the name of the function doesn't add semantic content).

[scheglov, 2015/03/24 17:16:38]

Done.

     return <String, TaskInput>{
-      'defining_LIBRARY_ELEMENT1': LIBRARY_ELEMENT1.inputFor(libSource),
-      UNIT_INPUT_NAME:
-          RESOLVED_UNIT1.inputFor(new LibraryUnitTarget(libSource, libSource)),
+      'defining_LIBRARY_ELEMENT1': LIBRARY_ELEMENT1.of(libSource),
+      UNIT_INPUT_NAME: RESOLVED_UNIT1.of(lut(libSource)),
       IMPORTS_LIBRARY_ELEMENT_INPUT_NAME:
-          new ListToMapTaskInput<Source, LibraryElement>(
-              IMPORTED_LIBRARIES.inputFor(libSource),
-              (Source source) => LIBRARY_ELEMENT1.inputFor(source)),
+          IMPORTED_LIBRARIES.of(libSource).toMapOf(LIBRARY_ELEMENT1),
       EXPORTS_LIBRARY_ELEMENT_INPUT_NAME:
-          new ListToMapTaskInput<Source, LibraryElement>(
-              EXPORTED_LIBRARIES.inputFor(libSource),
-              (Source source) => LIBRARY_ELEMENT1.inputFor(source)),
+          EXPORTED_LIBRARIES.of(libSource).toMapOf(LIBRARY_ELEMENT1),
       IMPORTS_SOURCE_KIND_INPUT_NAME:
-          new ListToMapTaskInput<Source, SourceKind>(
-              IMPORTED_LIBRARIES.inputFor(libSource),
-              (Source source) => SOURCE_KIND.inputFor(source)),
+          IMPORTED_LIBRARIES.of(libSource).toMapOf(SOURCE_KIND),
       EXPORTS_SOURCE_KIND_INPUT_NAME:
-          new ListToMapTaskInput<Source, SourceKind>(
-              EXPORTED_LIBRARIES.inputFor(libSource),
-              (Source source) => SOURCE_KIND.inputFor(source))
+          EXPORTED_LIBRARIES.of(libSource).toMapOf(SOURCE_KIND)
     };
   }
 
   /**
    * Create a [BuildDirectiveElementsTask] based on the given [target] in
    * the given [context].
    */
   static BuildDirectiveElementsTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildDirectiveElementsTask(context, target);
@@ skipping 74 matching lines @@
     outputs[RESOLVED_UNIT2] = unit;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given [target].
    */
   static Map<String, TaskInput> buildInputs(LibraryUnitTarget target) {
     return <String, TaskInput>{
-      TYPE_PROVIDER_INPUT:
-          TYPE_PROVIDER.inputFor(AnalysisContextTarget.request),
-      UNIT_INPUT: RESOLVED_UNIT1.inputFor(target)
+      TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request),
+      UNIT_INPUT: RESOLVED_UNIT1.of(target)
     };
   }
 
   /**
    * Create a [BuildEnumMemberElementsTask] based on the given [target] in
    * the given [context].
    */
   static BuildEnumMemberElementsTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildEnumMemberElementsTask(context, target);
@@ skipping 47 matching lines @@
     outputs[LIBRARY_ELEMENT4] = library;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given library [libSource].
    */
   static Map<String, TaskInput> buildInputs(Source libSource) {
     return <String, TaskInput>{
-      LIBRARY_INPUT: LIBRARY_ELEMENT3.inputFor(libSource),
+      LIBRARY_INPUT: LIBRARY_ELEMENT3.of(libSource),
       'exportsLibraryPublicNamespace':
-          new ListToMapTaskInput<Source, LibraryElement>(
-              EXPORT_SOURCE_CLOSURE.inputFor(libSource),
-              (Source source) => LIBRARY_ELEMENT3.inputFor(source))
+          EXPORT_SOURCE_CLOSURE.of(libSource).toMapOf(LIBRARY_ELEMENT3)
     };
   }
 
   /**
    * Create a [BuildExportNamespaceTask] based on the given [target] in
    * the given [context].
    */
   static BuildExportNamespaceTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildExportNamespaceTask(context, target);
@@ skipping 38 matching lines @@
     outputs[EXPORT_SOURCE_CLOSURE] = sources;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given library [libSource].
    */
   static Map<String, TaskInput> buildInputs(Source libSource) {
     return <String, TaskInput>{
-      LIBRARY2_ELEMENT_INPUT: LIBRARY_ELEMENT2.inputFor(libSource)
+      LIBRARY2_ELEMENT_INPUT: LIBRARY_ELEMENT2.of(libSource)
     };
   }
 
   /**
    * Create a [BuildExportSourceClosureTask] based on the given [target] in
    * the given [context].
    */
   static BuildExportSourceClosureTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildExportSourceClosureTask(context, target);
@@ skipping 72 matching lines @@
     outputs[RESOLVED_UNIT3] = unit;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given [target].
    */
   static Map<String, TaskInput> buildInputs(LibraryUnitTarget target) {
     return <String, TaskInput>{
-      TYPE_PROVIDER_INPUT:
-          TYPE_PROVIDER.inputFor(AnalysisContextTarget.request),
-      'importsExportNamespace': new ListToMapTaskInput<Source, LibraryElement>(
-          IMPORTED_LIBRARIES.inputFor(target.library),
-          (Source importSource) => LIBRARY_ELEMENT4.inputFor(importSource)),
-      LIBRARY_INPUT: LIBRARY_ELEMENT4.inputFor(target.library),
-      UNIT_INPUT: RESOLVED_UNIT2.inputFor(target)
+      TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request),
+      'importsExportNamespace':
+          IMPORTED_LIBRARIES.of(target.library).toMapOf(LIBRARY_ELEMENT4),
+      LIBRARY_INPUT: LIBRARY_ELEMENT4.of(target.library),
+      UNIT_INPUT: RESOLVED_UNIT2.of(target)
     };
   }
 
   /**
    * Create a [BuildFunctionTypeAliasesTask] based on the given [target] in
    * the given [context].
    */
   static BuildFunctionTypeAliasesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildFunctionTypeAliasesTask(context, target);
@@ skipping 238 matching lines @@
       }
     }
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the given
    * [libSource].
    */
   static Map<String, TaskInput> buildInputs(Source libSource) {
+    lut(Source unit) => new LibraryUnitTarget(libSource, unit);
     return <String, TaskInput>{
-      DEFINING_UNIT_INPUT:
-          RESOLVED_UNIT1.inputFor(new LibraryUnitTarget(libSource, libSource)),
-      PARTS_UNIT_INPUT: new ListToListTaskInput<Source, CompilationUnit>(
-          INCLUDED_PARTS.inputFor(libSource), (Source source) =>
-              RESOLVED_UNIT1.inputFor(new LibraryUnitTarget(libSource, source)))
+      DEFINING_UNIT_INPUT: RESOLVED_UNIT1.of(lut(libSource)),
+      PARTS_UNIT_INPUT: INCLUDED_PARTS
+          .of(libSource)
+          .toList(_lutMapInput(libSource, RESOLVED_UNIT1))
     };
   }
 
   /**
    * Create a [BuildLibraryElementTask] based on the given [target] in the
    * given [context].
    */
   static BuildLibraryElementTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildLibraryElementTask(context, target);
@@ skipping 29 matching lines @@
     library.publicNamespace = new PublicNamespaceBuilder().build(library);
     outputs[LIBRARY_ELEMENT3] = library;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given library [libSource].
    */
   static Map<String, TaskInput> buildInputs(Source libSource) {
-    return <String, TaskInput>{
-      LIBRARY_INPUT: LIBRARY_ELEMENT2.inputFor(libSource)
-    };
+    return <String, TaskInput>{LIBRARY_INPUT: LIBRARY_ELEMENT2.of(libSource)};
   }
 
   /**
    * Create a [BuildPublicNamespaceTask] based on the given [target] in
    * the given [context].
    */
   static BuildPublicNamespaceTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildPublicNamespaceTask(context, target);
   }
@@ skipping 40 matching lines @@
         new TypeProviderImpl.forNamespaces(coreNamespace, asyncNamespace);
     (context as ExtendedAnalysisContext).typeProvider = typeProvider;
     outputs[TYPE_PROVIDER] = typeProvider;
   }
 
   static Map<String, TaskInput> buildInputs(AnalysisContextTarget target) {
     SourceFactory sourceFactory = target.context.sourceFactory;
     Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE);
     Source asyncSource = sourceFactory.forUri(DartSdk.DART_ASYNC);
     return <String, TaskInput>{
-      CORE_INPUT: LIBRARY_ELEMENT3.inputFor(coreSource),
-      ASYNC_INPUT: LIBRARY_ELEMENT3.inputFor(asyncSource)
+      CORE_INPUT: LIBRARY_ELEMENT3.of(coreSource),
+      ASYNC_INPUT: LIBRARY_ELEMENT3.of(asyncSource)
     };
   }
 
   /**
    * Create a [BuildTypeProviderTask] based on the given [context].
    */
   static BuildTypeProviderTask createTask(
       AnalysisContext context, AnalysisContextTarget target) {
     return new BuildTypeProviderTask(context, target);
   }
@@ skipping 231 matching lines @@
     outputs[SOURCE_KIND] = sourceKind;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the given
    * [source].
    */
   static Map<String, TaskInput> buildInputs(Source source) {
     return <String, TaskInput>{
-      LINE_INFO_INPUT_NAME: LINE_INFO.inputFor(source),
-      TOKEN_STREAM_INPUT_NAME: TOKEN_STREAM.inputFor(source)
+      LINE_INFO_INPUT_NAME: LINE_INFO.of(source),
+      TOKEN_STREAM_INPUT_NAME: TOKEN_STREAM.of(source)
     };
   }
 
   /**
    * Create a [ParseDartTask] based on the given [target] in the given
    * [context].
    */
   static ParseDartTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ParseDartTask(context, target);
@@ skipping 109 matching lines @@
     LibraryElement library = getRequiredInput(LIBRARY_INPUT);
     outputs[LIBRARY_ELEMENT5] = library;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given [target].
    */
   static Map<String, TaskInput> buildInputs(Source libSource) {
+    lut(Source unit) => new LibraryUnitTarget(libSource, unit);

[Brian Wilkerson, 2015/03/24 15:07:10]

Even if it's useful to abbreviate the code here (which isn't clear to me), we
need a meaningful name (which would probably negate the value of defining the
local function). Brevity doesn't always improve readability.

[scheglov, 2015/03/24 17:16:38]

Given that this local function is declared 3 lines above its usage, semantically
highlighted and named uniformly everywhere - in the source and docs, I'd expect
it to be pretty clear.

Fixed for now.

     return <String, TaskInput>{
-      LIBRARY_INPUT: LIBRARY_ELEMENT4.inputFor(libSource),
-      'resolvedDefiningUnit':
-          RESOLVED_UNIT4.inputFor(new LibraryUnitTarget(libSource, libSource)),
-      'resolvedPartsUnit': new ListToMapTaskInput<Source, CompilationUnit>(
-          INCLUDED_PARTS.inputFor(libSource), (Source source) => RESOLVED_UNIT4
-              .inputFor(new LibraryUnitTarget(libSource, source))),
+      LIBRARY_INPUT: LIBRARY_ELEMENT4.of(libSource),
+      'resolvedDefiningUnit': RESOLVED_UNIT4.of(lut(libSource)),
+      'resolvedPartsUnit': INCLUDED_PARTS
+          .of(libSource)
+          .toMap((Source source) => RESOLVED_UNIT4.of(lut(source)))
     };
   }
 
   /**
    * Create a [ResolveLibraryTypeNamesTask] based on the given [target] in
    * the given [context].
    */
   static ResolveLibraryTypeNamesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ResolveLibraryTypeNamesTask(context, target);
@@ skipping 46 matching lines @@
     outputs[RESOLVE_TYPE_NAMES_ERRORS] = errorListener.errors;
     outputs[RESOLVED_UNIT4] = unit;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the
    * given [target].
    */
   static Map<String, TaskInput> buildInputs(LibraryUnitTarget target) {
-    return <String, TaskInput>{UNIT_INPUT: RESOLVED_UNIT3.inputFor(target)};
+    return <String, TaskInput>{UNIT_INPUT: RESOLVED_UNIT3.of(target)};
   }
 
   /**
    * Create a [ResolveUnitTypeNamesTask] based on the given [target] in
    * the given [context].
    */
   static ResolveUnitTypeNamesTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ResolveUnitTypeNamesTask(context, target);
   }
@@ skipping 41 matching lines @@
     outputs[LINE_INFO] = new LineInfo(scanner.lineStarts);
     outputs[SCAN_ERRORS] = errorListener.getErrorsForSource(source);
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
    * input descriptors describing those inputs for a task with the given
    * [source].
    */
   static Map<String, TaskInput> buildInputs(Source source) {
-    return <String, TaskInput>{CONTENT_INPUT_NAME: CONTENT.inputFor(source)};
+    return <String, TaskInput>{CONTENT_INPUT_NAME: CONTENT.of(source)};
   }
 
   /**
    * Create a [ScanDartTask] based on the given [target] in the given [context].
    */
   static ScanDartTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ScanDartTask(context, target);
   }
 }