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 155 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 177 matching lines @@
     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) {
     return <String, TaskInput>{
-      'defining_LIBRARY_ELEMENT1': LIBRARY_ELEMENT1.inputFor(libSource),
+      'defining_LIBRARY_ELEMENT1': LIBRARY_ELEMENT1.of(libSource),
       UNIT_INPUT_NAME:
-          RESOLVED_UNIT1.inputFor(new LibraryUnitTarget(libSource, libSource)),
+          RESOLVED_UNIT1.of(new LibraryUnitTarget(libSource, 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 240 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) {
     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)))
+          RESOLVED_UNIT1.of(new LibraryUnitTarget(libSource, libSource)),
+      PARTS_UNIT_INPUT: INCLUDED_PARTS.of(libSource).toList((Source unit) {
+        LibraryUnitTarget lut = new LibraryUnitTarget(libSource, unit);
+        return RESOLVED_UNIT1.of(lut);
+      })
     };
   }
 
   /**
    * 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 110 matching lines @@
     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) {
     return <String, TaskInput>{
-      LIBRARY_INPUT: LIBRARY_ELEMENT4.inputFor(libSource),
+      LIBRARY_INPUT: LIBRARY_ELEMENT4.of(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))),
+          RESOLVED_UNIT4.of(new LibraryUnitTarget(libSource, libSource)),
+      'resolvedPartsUnit': INCLUDED_PARTS.of(libSource).toMap((Source source) =>
+          RESOLVED_UNIT4.of(new LibraryUnitTarget(libSource, 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);
   }
 }