Task: Build Directive Elements.

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/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.
+ */
+final ResultDescriptor<List<AnalysisError>> BUILD_DIRECTIVES_ERRORS =
+    new ResultDescriptor<List<AnalysisError>>(
+        'BUILD_DIRECTIVES_ERRORS', AnalysisError.NO_ERRORS,
+        contributesTo: ANALYSIS_ERRORS);
+
+/**
+ * The errors produced while builing a library element.
+ *
+ * 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.
+ */
+final ResultDescriptor<List<AnalysisError>> BUILD_LIBRARY_ERRORS =
+    new ResultDescriptor<List<AnalysisError>>(
+        'BUILD_LIBRARY_ERRORS', AnalysisError.NO_ERRORS,
+        contributesTo: ANALYSIS_ERRORS);
+
+/**
+ * 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 =
+    new ResultDescriptor<LibraryElement>('LIBRARY_ELEMENT1', null);
+
+/**
+ * The partially resolved [CompilationUnit] associated with a unit.
+ *
+ * All declarations bound to the element defined by the declaration.
+ *
+ * The result is only available for targets representing a unit.
+ */
+final ResultDescriptor<CompilationUnit> RESOLVED_UNIT1 =
+    new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT1', null);
+
+/**
+ * The partially resolved [CompilationUnit] associated with a unit.
+ *
+ * Directives 'library', 'part' and 'part of' are resolved.
+ *
+ * The result is only available for targets representing a library.
+ */
+final ResultDescriptor<CompilationUnit> RESOLVED_UNIT2 =
+    new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT2', null);
+
+/**
+ * The partially resolved [CompilationUnit] associated with a library.
+ *
+ * All the directives are resolved.
+ *
+ * The result is only available for targets representing a library.
+ */
+final ResultDescriptor<CompilationUnit> RESOLVED_UNIT3 =
+    new ResultDescriptor<CompilationUnit>('RESOLVED_UNIT3', null);
+
+String _input(ResultDescriptor result, [String suffix]) {

[Brian Wilkerson, 2015/03/12 17:56:26]

If this function stays, it needs a comment. But I don't see any value in it. It
isn't shorter code, and there's no requirement that the values of these fields
be the same as the name of the result that will be used to populate them. I
think this actually hurts the readability of the code.

[scheglov, 2015/03/12 18:27:00]

Removed.

+  if (suffix == null) {
+    return result.name;
+  }
+  return '${result.name} $suffix';
+}
+
+/**
  * 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 = "lineInfo";
+  static final String LINE_INFO_INPUT_NAME = _input(LINE_INFO);
 
   /**
    * The name of the input whose value is the AST for the compilation unit.
    */
-  static const String PARSED_UNIT_INPUT_NAME = "parsedUnit";
+  static final String PARSED_UNIT_INPUT_NAME = _input(PARSED_UNIT);
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'BUILD_COMPILATION_UNIT_ELEMENT', createTask, buildInputs,
-      <ResultDescriptor>[COMPILATION_UNIT_ELEMENT, BUILT_UNIT]);
+      <ResultDescriptor>[COMPILATION_UNIT_ELEMENT, RESOLVED_UNIT1]);
 
   /**
    * Initialize a newly created task to build a compilation unit element for
    * the given [target] in the given [context].
    */
   BuildCompilationUnitElementTask(
       InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     Source source = getRequiredSource();
     CompilationUnit unit = getRequiredInput(PARSED_UNIT_INPUT_NAME);
 
     CompilationUnitBuilder builder = new CompilationUnitBuilder();
     CompilationUnitElement element = builder.buildCompilationUnit(source, unit);
 
     outputs[COMPILATION_UNIT_ELEMENT] = element;
-    outputs[BUILT_UNIT] = unit;
+    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(AnalysisTarget target) {
     return <String, TaskInput>{
       PARSED_UNIT_INPUT_NAME: PARSED_UNIT.inputFor(target)
     };
   }
 
   /**
    * Create a [BuildCompilationUnitElementTask] based on the given [target] in
    * the given [context].
    */
   static BuildCompilationUnitElementTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildCompilationUnitElementTask(context, target);
   }
 }
 
 /**
+ * A task that builds [RESOLVED_UNIT3] for a library.
+ */
+class BuildDirectiveElementsTask extends SourceBasedAnalysisTask {
+  /**
+   * The name of the input for [RESOLVED_UNIT2] of a library unit.
+   */
+  static final String RESOLVED_UNIT2_INPUT_NAME =
+      _input(RESOLVED_UNIT2, 'defining');
+
+  /**
+   * The input with a list of [LIBRARY_ELEMENT1]s of imported libraries.
+   */
+  static final String IMPORTS_LIBRARY_ELEMENT1_INPUT_NAME =
+      _input(LIBRARY_ELEMENT1, 'imports');
+
+  /**
+   * The input with a list of [LIBRARY_ELEMENT1]s of exported libraries.
+   */
+  static final String EXPORTS_LIBRARY_ELEMENT1_INPUT_NAME =
+      _input(LIBRARY_ELEMENT1, 'exports');
+
+  /**
+   * The input with a list of [SOURCE_KIND]s of imported libraries.
+   */
+  static final String IMPORTS_SOURCE_KIND_INPUT_NAME =
+      _input(SOURCE_KIND, 'imports');
+
+  /**
+   * The input with a list of [SOURCE_KIND]s of exported libraries.
+   */
+  static final String EXPORTS_SOURCE_KIND_INPUT_NAME =
+      _input(SOURCE_KIND, 'exports');
+
+  /**
+   * The task descriptor describing this kind of task.
+   */
+  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
+      'BUILD_RESOLVED_UNIT3', createTask, buildInputs, <ResultDescriptor>[
+    RESOLVED_UNIT3,
+    BUILD_DIRECTIVES_ERRORS
+  ]);
+
+  BuildDirectiveElementsTask(
+      InternalAnalysisContext context, AnalysisTarget target)
+      : super(context, target);
+
+  @override
+  TaskDescriptor get descriptor => DESCRIPTOR;
+
+  @override
+  void internalPerform() {
+    List<AnalysisError> errors = <AnalysisError>[];
+    //
+    // Prepare inputs.
+    //
+    CompilationUnit libraryUnit = getRequiredInput(RESOLVED_UNIT2_INPUT_NAME);
+    Map<Source, LibraryElement> importLibraryMap =
+        getRequiredInput(IMPORTS_LIBRARY_ELEMENT1_INPUT_NAME);
+    Map<Source, LibraryElement> exportLibraryMap =
+        getRequiredInput(EXPORTS_LIBRARY_ELEMENT1_INPUT_NAME);
+    Map<Source, SourceKind> importSourceKindMap =
+        getRequiredInput(IMPORTS_SOURCE_KIND_INPUT_NAME);
+    Map<Source, SourceKind> exportSourceKindMap =
+        getRequiredInput(EXPORTS_SOURCE_KIND_INPUT_NAME);
+    //
+    // Process inputs.
+    //
+    LibraryElementImpl libraryElement = libraryUnit.element.library;
+    Source librarySource = libraryElement.source;
+    //
+    // Resolve directives.
+    //
+    HashMap<String, PrefixElementImpl> nameToPrefixMap =
+        new HashMap<String, PrefixElementImpl>();
+    List<ImportElement> imports = <ImportElement>[];
+    List<ExportElement> exports = <ExportElement>[];
+    bool explicitlyImportsCore = false;
+    for (Directive directive in libraryUnit.directives) {
+      if (directive is ImportDirective) {
+        ImportDirective importDirective = directive;
+        String uriContent = importDirective.uriContent;
+        if (DartUriResolver.isDartExtUri(uriContent)) {
+          libraryElement.hasExtUri = true;
+        }
+        Source importedSource = importDirective.source;
+        if (importedSource != null && context.exists(importedSource)) {
+          // The imported source will be null if the URI in the import
+          // directive was invalid.
+          LibraryElement importedLibrary = importLibraryMap[importedSource];
+          if (importedLibrary != null) {
+            ImportElementImpl importElement =
+                new ImportElementImpl(directive.offset);
+            StringLiteral uriLiteral = importDirective.uri;
+            if (uriLiteral != null) {
+              importElement.uriOffset = uriLiteral.offset;
+              importElement.uriEnd = uriLiteral.end;
+            }
+            importElement.uri = uriContent;
+            importElement.deferred = importDirective.deferredKeyword != null;
+            importElement.combinators = _buildCombinators(importDirective);
+            importElement.importedLibrary = importedLibrary;
+            SimpleIdentifier prefixNode = directive.prefix;
+            if (prefixNode != null) {
+              importElement.prefixOffset = prefixNode.offset;
+              String prefixName = prefixNode.name;
+              PrefixElementImpl prefix = nameToPrefixMap[prefixName];
+              if (prefix == null) {
+                prefix = new PrefixElementImpl.forNode(prefixNode);
+                nameToPrefixMap[prefixName] = prefix;
+              }
+              importElement.prefix = prefix;
+              prefixNode.staticElement = prefix;
+            }
+            directive.element = importElement;
+            imports.add(importElement);
+            if (importSourceKindMap[importedSource] != SourceKind.LIBRARY) {
+              ErrorCode errorCode = (importElement.isDeferred
+                  ? StaticWarningCode.IMPORT_OF_NON_LIBRARY
+                  : CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY);
+              errors.add(new AnalysisError.con2(importedSource,
+                  uriLiteral.offset, uriLiteral.length,
+                  errorCode, [uriLiteral.toSource()]));
+            }
+          }
+        }
+      } else if (directive is ExportDirective) {
+        ExportDirective exportDirective = directive;
+        Source exportedSource = exportDirective.source;
+        if (exportedSource != null && context.exists(exportedSource)) {
+          // The exported source will be null if the URI in the export
+          // directive was invalid.
+          LibraryElement exportedLibrary = exportLibraryMap[exportedSource];
+          if (exportedLibrary != null) {
+            ExportElementImpl exportElement =
+                new ExportElementImpl(directive.offset);
+            StringLiteral uriLiteral = exportDirective.uri;
+            if (uriLiteral != null) {
+              exportElement.uriOffset = uriLiteral.offset;
+              exportElement.uriEnd = uriLiteral.end;
+            }
+            exportElement.uri = exportDirective.uriContent;
+            exportElement.combinators = _buildCombinators(exportDirective);
+            exportElement.exportedLibrary = exportedLibrary;
+            directive.element = exportElement;
+            exports.add(exportElement);
+            if (exportSourceKindMap[exportedSource] != SourceKind.LIBRARY) {
+              errors.add(new AnalysisError.con2(exportedSource,
+                  uriLiteral.offset, uriLiteral.length,
+                  CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY, [
+                uriLiteral.toSource()
+              ]));
+            }
+          }
+        }
+      }
+    }
+    //
+    // Ensure "dart:core" import.
+    //
+    Source coreLibrarySource = context.sourceFactory.forUri(DartSdk.DART_CORE);
+    if (!explicitlyImportsCore && coreLibrarySource != librarySource) {
+      ImportElementImpl importElement = new ImportElementImpl(-1);
+      importElement.importedLibrary = importLibraryMap[coreLibrarySource];
+      importElement.synthetic = true;
+      imports.add(importElement);
+    }
+    //
+    // Populate the library element.
+    //
+    libraryElement.imports = imports;
+    libraryElement.exports = exports;
+    // TODO(scheglov) move after EXPORT_NAMESPACE or just this task
+//    if (libraryElement.entryPoint == null) {
+//      Namespace namespace = new NamespaceBuilder()
+//          .createExportNamespaceForLibrary(libraryElement);
+//      Element element = namespace.get(FunctionElement.MAIN_FUNCTION_NAME);
+//      if (element is FunctionElement) {
+//        libraryElement.entryPoint = element;
+//      }
+//    }
+    //
+    // Record outputs.
+    //
+    outputs[RESOLVED_UNIT3] = libraryUnit;
+    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 [target].
+   */
+  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
+    return <String, TaskInput>{
+      RESOLVED_UNIT2_INPUT_NAME: RESOLVED_UNIT2.inputFor(target),
+      IMPORTS_LIBRARY_ELEMENT1_INPUT_NAME:
+          new MapBasedTaskInput<Source, LibraryElement>(
+              new SimpleTaskInput<List<Source>>(target, IMPORTED_LIBRARIES),

[Brian Wilkerson, 2015/03/12 17:56:26]

Personally, I like
    IMPORTED_LIBRARIES.inputFor(target)
better than
    new SimpleTaskInput<List<Source>>(target, IMPORTED_LIBRARIES)
because it's shorter.

[scheglov, 2015/03/12 18:27:00]

Thank you.
My inputs look much better now!

+              (Source includedSource) => new SimpleTaskInput<LibraryElement>(
+                  includedSource, LIBRARY_ELEMENT1)),
+      EXPORTS_LIBRARY_ELEMENT1_INPUT_NAME:
+          new MapBasedTaskInput<Source, LibraryElement>(
+              new SimpleTaskInput<List<Source>>(target, EXPORTED_LIBRARIES),
+              (Source includedSource) => new SimpleTaskInput<LibraryElement>(
+                  includedSource, LIBRARY_ELEMENT1)),
+      IMPORTS_SOURCE_KIND_INPUT_NAME: new MapBasedTaskInput<Source, SourceKind>(
+          new SimpleTaskInput<List<Source>>(target, IMPORTED_LIBRARIES),
+          (Source includedSource) =>
+              new SimpleTaskInput<SourceKind>(includedSource, SOURCE_KIND)),
+      EXPORTS_SOURCE_KIND_INPUT_NAME: new MapBasedTaskInput<Source, SourceKind>(
+          new SimpleTaskInput<List<Source>>(target, EXPORTED_LIBRARIES),
+          (Source includedSource) =>
+              new SimpleTaskInput<SourceKind>(includedSource, 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);
+  }
+
+  /**
+   * Build the element model representing the combinators declared by
+   * the given [directive].
+   */
+  static List<NamespaceCombinator> _buildCombinators(
+      NamespaceDirective directive) {
+    List<NamespaceCombinator> combinators = <NamespaceCombinator>[];
+    for (Combinator combinator in directive.combinators) {
+      if (combinator is ShowCombinator) {
+        ShowElementCombinatorImpl show = new ShowElementCombinatorImpl();
+        show.offset = combinator.offset;
+        show.end = combinator.end;
+        show.shownNames = _getIdentifiers(combinator.shownNames);
+        combinators.add(show);
+      } else if (combinator is HideCombinator) {
+        HideElementCombinatorImpl hide = new HideElementCombinatorImpl();
+        hide.hiddenNames = _getIdentifiers(combinator.hiddenNames);
+        combinators.add(hide);
+      }
+    }
+    return combinators;
+  }
+
+  /**
+   * Return the lexical identifiers associated with the given [identifiers].
+   */
+  static List<String> _getIdentifiers(NodeList<SimpleIdentifier> identifiers) {
+    return identifiers.map((identifier) => identifier.name).toList();
+  }
+}
+
+/**
  * A task that builds a library element for a Dart library.
  */
 class BuildLibraryElementTask extends SourceBasedAnalysisTask {
   /**
-   * The name of the input whose value is the built compilation unit of the
-   * defining compilation unit of a library.
-   */
-  static const String DEFINING_BUILT_UNIT_INPUT_NAME = 'definingBuiltUnit';
-
-  /**
-   * The name of the input whose value is a list of built compilation units
+   * The name of the input whose value is the defining [RESOLVED_UNIT1].
+   */
+  static final String DEFINING_RESOLVER_UNIT1_INPUT_NAME =
+      _input(RESOLVED_UNIT1, 'defining');
+
+  /**
+   * The name of the input whose value is a list of built [RESOLVED_UNIT1]s
    * of the parts sourced by a library.
    */
-  static const String PART_BUILT_UNITS_INPUT_NAME = 'partBuiltUnits';
+  static final String PARTS_RESOLVED_UNIT1_INPUT_NAME =
+      _input(RESOLVED_UNIT1, 'parts');
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'BUILD_LIBRARY_ELEMENT', createTask, buildInputs, <ResultDescriptor>[
     BUILD_LIBRARY_ERRORS,
-    BUILT_LIBRARY_ELEMENT,
+    RESOLVED_UNIT2,
+    LIBRARY_ELEMENT1,
     IS_LAUNCHABLE,
     HAS_HTML_IMPORT
   ]);
 
   /**
    * Initialize a newly created task to build a library element for the given
    * [target] in the given [context].
    */
   BuildLibraryElementTask(
       InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     List<AnalysisError> errors = <AnalysisError>[];
     //
     // Prepare inputs.
     //
     Source librarySource = getRequiredSource();
     CompilationUnit definingCompilationUnit =
-        getRequiredInput(DEFINING_BUILT_UNIT_INPUT_NAME);
+        getRequiredInput(DEFINING_RESOLVER_UNIT1_INPUT_NAME);
     List<CompilationUnit> partUnits =
-        getRequiredInput(PART_BUILT_UNITS_INPUT_NAME);
+        getRequiredInput(PARTS_RESOLVED_UNIT1_INPUT_NAME);
     //
     // Process inputs.
     //
     CompilationUnitElementImpl definingCompilationUnitElement =
         definingCompilationUnit.element;
     Map<Source, CompilationUnit> partUnitMap =
         new HashMap<Source, CompilationUnit>();
     for (CompilationUnit partUnit in partUnits) {
       Source partSource = partUnit.element.source;
       partUnitMap[partSource] = partUnit;
@@ skipping 75 matching lines @@
     for (Directive directive in directivesToResolve) {
       directive.element = libraryElement;
     }
     if (sourcedCompilationUnits.isNotEmpty) {
       _patchTopLevelAccessors(libraryElement);
     }
     //
     // Record outputs.
     //
     outputs[BUILD_LIBRARY_ERRORS] = errors;
-    outputs[BUILT_LIBRARY_ELEMENT] = libraryElement;
+    outputs[RESOLVED_UNIT2] = definingCompilationUnit;
+    outputs[LIBRARY_ELEMENT1] = libraryElement;
     outputs[IS_LAUNCHABLE] = entryPoint != null;
     outputs[HAS_HTML_IMPORT] = hasHtmlImport;
   }
 
   /**
    * Add all of the non-synthetic [getters] and [setters] defined in the given
    * [unit] that have no corresponding accessor to one of the given collections.
    */
   void _collectAccessors(Map<String, PropertyAccessorElement> getters,
       List<PropertyAccessorElement> setters, CompilationUnitElement unit) {
@@ skipping 68 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
    * [target].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     return <String, TaskInput>{
-      DEFINING_BUILT_UNIT_INPUT_NAME: new SimpleTaskInput(target, BUILT_UNIT),
-      PART_BUILT_UNITS_INPUT_NAME:
+      DEFINING_RESOLVER_UNIT1_INPUT_NAME:
+          new SimpleTaskInput(target, RESOLVED_UNIT1),
+      PARTS_RESOLVED_UNIT1_INPUT_NAME:
           new ListBasedTaskInput<Source, CompilationUnit>(
               new SimpleTaskInput<List<Source>>(target, INCLUDED_PARTS),
               (Source includedSource) => new SimpleTaskInput<CompilationUnit>(
-                  includedSource, BUILT_UNIT))
+                  includedSource, 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);
   }
 }
 
 /**
  * A task that builds [PUBLIC_NAMESPACE] for a library.
  */
 class BuildPublicNamespaceTask extends SourceBasedAnalysisTask {
   /**
-   * The name of the [BUILT_LIBRARY_ELEMENT] input.
+   * The name of the input for [LIBRARY_ELEMENT1] of a library.
    */
-  static const String BUILT_LIBRARY_ELEMENT_INPUT_NAME = "builtLibraryElement";
+  static final String BUILT_LIBRARY_ELEMENT_INPUT_NAME =
+      _input(LIBRARY_ELEMENT1);
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'BUILD_PUBLIC_NAMESPACE', createTask, buildInputs, <ResultDescriptor>[
     PUBLIC_NAMESPACE
   ]);
 
   BuildPublicNamespaceTask(
@@ skipping 13 matching lines @@
     outputs[PUBLIC_NAMESPACE] = namespace;
   }
 
   /**
    * 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(AnalysisTarget target) {
     return <String, TaskInput>{
-      BUILT_LIBRARY_ELEMENT_INPUT_NAME: BUILT_LIBRARY_ELEMENT.inputFor(target)
+      BUILT_LIBRARY_ELEMENT_INPUT_NAME: LIBRARY_ELEMENT1.inputFor(target)
     };
   }
 
   /**
    * Create a [BuildPublicNamespaceTask] based on the given [target] in
    * the given [context].
    */
   static BuildPublicNamespaceTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildPublicNamespaceTask(context, target);
   }
 }
 
 /**
  * A task that parses the content of a Dart file, producing an AST structure.
  */
 class ParseDartTask extends SourceBasedAnalysisTask {
   /**
    * The name of the input whose value is the line information produced for the
    * file.
    */
-  static const String LINE_INFO_INPUT_NAME = "lineInfo";
+  static final String LINE_INFO_INPUT_NAME = _input(LINE_INFO);
 
   /**
    * The name of the input whose value is the token stream produced for the file.
    */
-  static const String TOKEN_STREAM_INPUT_NAME = "tokenStream";
+  static final String TOKEN_STREAM_INPUT_NAME = _input(TOKEN_STREAM);
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor('PARSE_DART',
       createTask, buildInputs, <ResultDescriptor>[
     EXPORTED_LIBRARIES,
     IMPORTED_LIBRARIES,
     INCLUDED_PARTS,
     PARSE_ERRORS,
@@ skipping 47 matching lines @@
                 includedSources.add(referencedSource);
               }
             } else {
               throw new AnalysisException(
                   "$runtimeType failed to handle a ${directive.runtimeType}");
             }
           }
         }
       }
     }
+    //
+    // Always include "dart:core" source.
+    //
+    Source coreLibrarySource = context.sourceFactory.forUri(DartSdk.DART_CORE);
+    importedSources.add(coreLibrarySource);
+    //
+    // Compute kind.
+    //
     SourceKind sourceKind = SourceKind.LIBRARY;
     if (!hasNonPartOfDirective && hasPartOfDirective) {
       sourceKind = SourceKind.PART;
     }
-
+    //
+    // Record outputs.
+    //
     outputs[EXPORTED_LIBRARIES] = exportedSources.toList();
     outputs[IMPORTED_LIBRARIES] = importedSources.toList();
     outputs[INCLUDED_PARTS] = includedSources.toList();
     outputs[PARSE_ERRORS] = errorListener.getErrorsForSource(source);
     outputs[PARSED_UNIT] = unit;
     outputs[SOURCE_KIND] = sourceKind;
   }
 
   /**
    * Return a map from the names of the inputs of this kind of task to the task
@@ skipping 57 matching lines @@
   }
 }
 
 /**
  * A task that scans the content of a file, producing a set of Dart tokens.
  */
 class ScanDartTask extends SourceBasedAnalysisTask {
   /**
    * The name of the input whose value is the content of the file.
    */
-  static const String CONTENT_INPUT_NAME = "content";
+  static final String CONTENT_INPUT_NAME = _input(CONTENT);
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor('SCAN_DART',
       createTask, buildInputs, <ResultDescriptor>[
     LINE_INFO,
     SCAN_ERRORS,
     TOKEN_STREAM
   ]);
@@ skipping 31 matching lines @@
   }
 
   /**
    * Create a [ScanDartTask] based on the given [target] in the given [context].
    */
   static ScanDartTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new ScanDartTask(context, target);
   }
 }