Compute mixin application constructors in the ClassElement.constructors getter.

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 'dart:math' as math;
 
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart'
     hide AnalysisCache, AnalysisTask;
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/error_verifier.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
@@ skipping 33 matching lines @@
  *
  * The list will be empty if there were no errors, but will not be `null`.
  *
  * The result is only available for [Source]s representing a library.
  */
 final ListResultDescriptor<AnalysisError> BUILD_LIBRARY_ERRORS =
     new ListResultDescriptor<AnalysisError>(
         'BUILD_LIBRARY_ERRORS', AnalysisError.NO_ERRORS);
 
 /**
- * The [ClassElement]s of a [Source] representing a Dart library.
- *
- * The list contains the elements for all of the classes defined in the library,
- * not just those in the defining compilation unit. The list will be empty if
- * there are no classes, but will not be `null`.
- */
-final ListResultDescriptor<ClassElement> CLASS_ELEMENTS =
-    new ListResultDescriptor<ClassElement>('CLASS_ELEMENTS', null,
-        cachingPolicy: ELEMENT_CACHING_POLICY);
-
-/**
  * A list of the [ConstantEvaluationTarget]s defined in a unit.  This includes
  * constants defined at top level, statically inside classes, and local to
  * functions, as well as constant constructors, annotations, and default values
  * of parameters to constant constructors.
  */
 final ListResultDescriptor<ConstantEvaluationTarget> COMPILATION_UNIT_CONSTANTS =
     new ListResultDescriptor<ConstantEvaluationTarget>(
         'COMPILATION_UNIT_CONSTANTS', null,
         cachingPolicy: ELEMENT_CACHING_POLICY);
 
@@ skipping 22 matching lines @@
 /**
  * A [ConstantEvaluationTarget] that has been successfully constant-evaluated.
  *
  * TODO(paulberry): is ELEMENT_CACHING_POLICY the correct caching policy?
  */
 final ResultDescriptor<ConstantEvaluationTarget> CONSTANT_VALUE =
     new ResultDescriptor<ConstantEvaluationTarget>('CONSTANT_VALUE', null,
         cachingPolicy: ELEMENT_CACHING_POLICY);
 
 /**
- * The [ConstructorElement]s of a [ClassElement].
- */
-final ListResultDescriptor<ConstructorElement> CONSTRUCTORS =
-    new ListResultDescriptor<ConstructorElement>('CONSTRUCTORS', null);
-
-/**
- * The errors produced while building a [ClassElement] constructors.
- *
- * The list will be empty if there were no errors, but will not be `null`.
- *
- * The result is only available for targets representing a [ClassElement].
- */
-final ListResultDescriptor<AnalysisError> CONSTRUCTORS_ERRORS =
-    new ListResultDescriptor<AnalysisError>(
-        'CONSTRUCTORS_ERRORS', AnalysisError.NO_ERRORS);
-
-/**
  * The sources representing the libraries that include a given source as a part.
  *
  * The result is only available for [Source]s representing a compilation unit.
  */
 final ListResultDescriptor<Source> CONTAINING_LIBRARIES =
     new ListResultDescriptor<Source>('CONTAINING_LIBRARIES', Source.EMPTY_LIST);
 
 /**
  * The [ResultCachingPolicy] for [Element]s.
  */
@@ skipping 84 matching lines @@
  *
  * [LIBRARY_ELEMENT4] plus resolved types for every element.
  *
  * The result is only available for [Source]s representing a library.
  */
 final ResultDescriptor<LibraryElement> LIBRARY_ELEMENT5 =
     new ResultDescriptor<LibraryElement>('LIBRARY_ELEMENT5', null,
         cachingPolicy: ELEMENT_CACHING_POLICY);
 
 /**
- * The partial [LibraryElement] associated with a library.
- *
- * [LIBRARY_ELEMENT5] plus resolved elements and types for all expressions.
- *
- * The result is only available for [Source]s representing a library.
- */
-final ResultDescriptor<LibraryElement> LIBRARY_ELEMENT6 =
-    new ResultDescriptor<LibraryElement>('LIBRARY_ELEMENT6', null,
-        cachingPolicy: ELEMENT_CACHING_POLICY);
-
-/**
  * The flag specifying whether all analysis errors are computed in a specific
  * library.
  *
  * The result is only available for [Source]s representing a library.
  */
 final ResultDescriptor<bool> LIBRARY_ERRORS_READY =
     new ResultDescriptor<bool>('LIBRARY_ERRORS_READY', false);
 
 /**
  * The analysis errors associated with a compilation unit in a specific library.
@@ skipping 163 matching lines @@
  * but with duplications removed.
  */
 List<AnalysisError> removeDuplicateErrors(List<AnalysisError> errors) {
   if (errors.isEmpty) {
     return errors;
   }
   return errors.toSet().toList();
 }
 
 /**
- * A task that builds implicit constructors for a [ClassElement], or keeps
- * the existing explicit constructors if the class has them.
- */
-class BuildClassConstructorsTask extends SourceBasedAnalysisTask {
-  /**
-   * The name of the [CONSTRUCTORS] input for the superclass.
-   */
-  static const String SUPER_CONSTRUCTORS = 'SUPER_CONSTRUCTORS';
-
-  /**
-   * The task descriptor describing this kind of task.
-   */
-  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
-      'BuildConstructorsForClassTask', createTask, buildInputs,
-      <ResultDescriptor>[CONSTRUCTORS, CONSTRUCTORS_ERRORS]);
-
-  BuildClassConstructorsTask(
-      InternalAnalysisContext context, AnalysisTarget target)
-      : super(context, target);
-
-  @override
-  TaskDescriptor get descriptor => DESCRIPTOR;
-
-  @override
-  void internalPerform() {
-    List<AnalysisError> errors = <AnalysisError>[];
-    //
-    // Prepare inputs.
-    //
-    ClassElementImpl classElement = this.target;
-    List<ConstructorElement> superConstructors = inputs[SUPER_CONSTRUCTORS];
-    DartType superType = classElement.supertype;
-    if (superType == null) {
-      return;
-    }
-    //
-    // Shortcut for ClassElement(s) without implicit constructors.
-    //
-    if (superConstructors == null) {
-      outputs[CONSTRUCTORS] = classElement.constructors;
-      outputs[CONSTRUCTORS_ERRORS] = AnalysisError.NO_ERRORS;
-      return;
-    }
-    //
-    // ClassTypeAlias
-    //
-    if (classElement.isMixinApplication) {
-      List<ConstructorElement> implicitConstructors =
-          new List<ConstructorElement>();
-      void callback(ConstructorElement explicitConstructor,
-          List<DartType> parameterTypes, List<DartType> argumentTypes) {
-        implicitConstructors.add(_createImplicitContructor(classElement.type,
-            explicitConstructor, parameterTypes, argumentTypes));
-      }
-      if (_findForwardedConstructors(classElement, superType, callback)) {
-        if (implicitConstructors.isEmpty) {
-          errors.add(new AnalysisError(classElement.source,
-              classElement.nameOffset, classElement.name.length,
-              CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS,
-              [superType.element.name]));
-        } else {
-          classElement.constructors = implicitConstructors;
-        }
-      }
-      outputs[CONSTRUCTORS] = classElement.constructors;
-      outputs[CONSTRUCTORS_ERRORS] = errors;
-    }
-    //
-    // ClassDeclaration
-    //
-    if (!classElement.isMixinApplication) {
-      bool constructorFound = false;
-      void callback(ConstructorElement explicitConstructor,
-          List<DartType> parameterTypes, List<DartType> argumentTypes) {
-        constructorFound = true;
-      }
-      if (_findForwardedConstructors(classElement, superType, callback) &&
-          !constructorFound) {
-        SourceRange withRange = classElement.withClauseRange;
-        errors.add(new AnalysisError(classElement.source, withRange.offset,
-            withRange.length, CompileTimeErrorCode.MIXIN_HAS_NO_CONSTRUCTORS,
-            [superType.element.name]));
-        classElement.mixinErrorsReported = true;
-      }
-      outputs[CONSTRUCTORS] = classElement.constructors;
-      outputs[CONSTRUCTORS_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 [classElement].
-   */
-  static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
-    ClassElement element = target;
-    Source librarySource = element.library.source;
-    DartType superType = element.supertype;
-    if (superType is InterfaceType) {
-      if (element.isMixinApplication || element.mixins.isNotEmpty) {
-        ClassElement superElement = superType.element;
-        return <String, TaskInput>{
-          'libraryDep': LIBRARY_ELEMENT5.of(librarySource),
-          SUPER_CONSTRUCTORS: CONSTRUCTORS.of(superElement)
-        };
-      }
-    }
-    // No implicit constructors.
-    // Depend on LIBRARY_ELEMENT5 for invalidation.
-    return <String, TaskInput>{
-      'libraryDep': LIBRARY_ELEMENT5.of(librarySource)
-    };
-  }
-
-  /**
-   * Create a [BuildClassConstructorsTask] based on the given
-   * [target] in the given [context].
-   */
-  static BuildClassConstructorsTask createTask(
-      AnalysisContext context, AnalysisTarget target) {
-    return new BuildClassConstructorsTask(context, target);
-  }
-
-  /**
-   * Create an implicit constructor that is copied from the given
-   * [explicitConstructor], but that is in the given class.
-   *
-   * [classType] - the class in which the implicit constructor is defined.
-   * [explicitConstructor] - the constructor on which the implicit constructor
-   *    is modeled.
-   * [parameterTypes] - the types to be replaced when creating parameters.
-   * [argumentTypes] - the types with which the parameters are to be replaced.
-   */
-  static ConstructorElement _createImplicitContructor(InterfaceType classType,
-      ConstructorElement explicitConstructor, List<DartType> parameterTypes,
-      List<DartType> argumentTypes) {
-    ConstructorElementImpl implicitConstructor =
-        new ConstructorElementImpl(explicitConstructor.name, -1);
-    implicitConstructor.synthetic = true;
-    implicitConstructor.redirectedConstructor = explicitConstructor;
-    implicitConstructor.const2 = explicitConstructor.isConst;
-    implicitConstructor.returnType = classType;
-    List<ParameterElement> explicitParameters = explicitConstructor.parameters;
-    int count = explicitParameters.length;
-    if (count > 0) {
-      List<ParameterElement> implicitParameters =
-          new List<ParameterElement>(count);
-      for (int i = 0; i < count; i++) {
-        ParameterElement explicitParameter = explicitParameters[i];
-        ParameterElementImpl implicitParameter =
-            new ParameterElementImpl(explicitParameter.name, -1);
-        implicitParameter.const3 = explicitParameter.isConst;
-        implicitParameter.final2 = explicitParameter.isFinal;
-        implicitParameter.parameterKind = explicitParameter.parameterKind;
-        implicitParameter.synthetic = true;
-        implicitParameter.type =
-            explicitParameter.type.substitute2(argumentTypes, parameterTypes);
-        implicitParameters[i] = implicitParameter;
-      }
-      implicitConstructor.parameters = implicitParameters;
-    }
-    FunctionTypeImpl type = new FunctionTypeImpl(implicitConstructor);
-    type.typeArguments = classType.typeArguments;
-    implicitConstructor.type = type;
-    return implicitConstructor;
-  }
-
-  /**
-   * Find all the constructors that should be forwarded from the given
-   * [superType], to the class or mixin application [classElement],
-   * and pass information about them to [callback].
-   *
-   * Return `true` if some constructors were considered. (A `false` return value
-   * can only happen if the supeclass is a built-in type, in which case it
-   * can't be used as a mixin anyway).
-   */
-  static bool _findForwardedConstructors(ClassElementImpl classElement,
-      InterfaceType superType, void callback(
-          ConstructorElement explicitConstructor, List<DartType> parameterTypes,
-          List<DartType> argumentTypes)) {
-    if (superType == null) {
-      return false;
-    }
-    ClassElement superclassElement = superType.element;
-    List<ConstructorElement> constructors = superclassElement.constructors;
-    int count = constructors.length;
-    if (count == 0) {
-      return false;
-    }
-    List<DartType> parameterTypes =
-        TypeParameterTypeImpl.getTypes(superType.typeParameters);
-    List<DartType> argumentTypes = _getArgumentTypes(superType, parameterTypes);
-    for (int i = 0; i < count; i++) {
-      ConstructorElement explicitConstructor = constructors[i];
-      if (!explicitConstructor.isFactory &&
-          classElement.isSuperConstructorAccessible(explicitConstructor)) {
-        callback(explicitConstructor, parameterTypes, argumentTypes);
-      }
-    }
-    return true;
-  }
-
-  /**
-   * Return a list of argument types that corresponds to the [parameterTypes]
-   * and that are derived from the type arguments of the given [superType].
-   */
-  static List<DartType> _getArgumentTypes(
-      InterfaceType superType, List<DartType> parameterTypes) {
-    DynamicTypeImpl dynamic = DynamicTypeImpl.instance;
-    int parameterCount = parameterTypes.length;
-    List<DartType> types = new List<DartType>(parameterCount);
-    if (superType == null) {
-      types = new List<DartType>.filled(parameterCount, dynamic);
-    } else {
-      List<DartType> typeArguments = superType.typeArguments;
-      int argumentCount = math.min(typeArguments.length, parameterCount);
-      for (int i = 0; i < argumentCount; i++) {
-        types[i] = typeArguments[i];
-      }
-      for (int i = argumentCount; i < parameterCount; i++) {
-        types[i] = dynamic;
-      }
-    }
-    return types;
-  }
-}
-
-/**
  * 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 AST for the compilation unit.
    */
   static const String PARSED_UNIT_INPUT_NAME = 'PARSED_UNIT_INPUT_NAME';
 
   /**
    * The task descriptor describing this kind of task.
@@ skipping 453 matching lines @@
    * Create a [BuildExportNamespaceTask] based on the given [target] in
    * the given [context].
    */
   static BuildExportNamespaceTask createTask(
       AnalysisContext context, AnalysisTarget target) {
     return new BuildExportNamespaceTask(context, target);
   }
 }
 
 /**
- * This task builds [LIBRARY_ELEMENT6] by forcing building constructors for
- * all the classes of the defining and part units of a library.
- */
-class BuildLibraryConstructorsTask extends SourceBasedAnalysisTask {
-  /**
-   * The name of the [LIBRARY_ELEMENT5] input.
-   */
-  static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
-
-  /**
-   * The task descriptor describing this kind of task.
-   */
-  static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
-      'BuildLibraryConstructorsTask', createTask, buildInputs,
-      <ResultDescriptor>[LIBRARY_ELEMENT6]);
-
-  BuildLibraryConstructorsTask(
-      InternalAnalysisContext context, AnalysisTarget target)
-      : super(context, target);
-
-  @override
-  TaskDescriptor get descriptor => DESCRIPTOR;
-
-  @override
-  void internalPerform() {
-    LibraryElement library = getRequiredInput(LIBRARY_INPUT);
-    outputs[LIBRARY_ELEMENT6] = 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(AnalysisTarget target) {
-    Source source = target;
-    return <String, TaskInput>{
-      LIBRARY_INPUT: LIBRARY_ELEMENT5.of(source),
-      'resolvedConstructors': CLASS_ELEMENTS.of(source).toListOf(CONSTRUCTORS),
-    };
-  }
-
-  /**
-   * Create a [BuildLibraryConstructorsTask] based on the given [target] in
-   * the given [context].
-   */
-  static BuildLibraryConstructorsTask createTask(
-      AnalysisContext context, AnalysisTarget target) {
-    return new BuildLibraryConstructorsTask(context, target);
-  }
-}
-
-/**
  * A task that builds a library element for a Dart library.
  */
 class BuildLibraryElementTask extends SourceBasedAnalysisTask {
   /**
    * The name of the input whose value is the defining [RESOLVED_UNIT1].
    */
   static const String DEFINING_UNIT_INPUT = 'DEFINING_UNIT_INPUT';
 
   /**
    * 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 PARTS_UNIT_INPUT = 'PARTS_UNIT_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'BuildLibraryElementTask', createTask, buildInputs, <ResultDescriptor>[
     BUILD_LIBRARY_ERRORS,
-    CLASS_ELEMENTS,
     LIBRARY_ELEMENT1,
     IS_LAUNCHABLE
   ]);
 
   /**
    * The constant used as an unknown common library name in parts.
    */
   static const String _UNKNOWN_LIBRARY_NAME = 'unknown-library-name';
 
   /**
@@ skipping 115 matching lines @@
     libraryElement.definingCompilationUnit = definingCompilationUnitElement;
     libraryElement.entryPoint = entryPoint;
     libraryElement.parts = sourcedCompilationUnits;
     for (Directive directive in directivesToResolve) {
       directive.element = libraryElement;
     }
     if (sourcedCompilationUnits.isNotEmpty) {
       _patchTopLevelAccessors(libraryElement);
     }
     //
-    // Prepare all class elements.
-    //
-    List<ClassElement> classElements = libraryElement.units
-        .map((CompilationUnitElement unitElement) => unitElement.types)
-        .expand((List<ClassElement> unitClassElements) => unitClassElements)
-        .toList();
-    //
     // Record outputs.
     //
     outputs[BUILD_LIBRARY_ERRORS] = errors;
-    outputs[CLASS_ELEMENTS] = classElements;
     outputs[LIBRARY_ELEMENT1] = libraryElement;
     outputs[IS_LAUNCHABLE] = entryPoint != null;
   }
 
   /**
    * 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 1246 matching lines @@
    */
   static const String VARIABLE_REFERENCE_ERRORS_INPUT =
       'VARIABLE_REFERENCE_ERRORS';
 
   /**
    * The name of the [VERIFY_ERRORS] input.
    */
   static const String VERIFY_ERRORS_INPUT = 'VERIFY_ERRORS';
 
   /**
-   * The name of the [CONSTRUCTORS_ERRORS] input.
-   */
-  static const String CONSTRUCTORS_ERRORS_INPUT = 'CONSTRUCTORS_ERRORS';
-
-  /**
    * The task descriptor describing this kind of task.
    */
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'LibraryUnitErrorsTask', createTask, buildInputs,
       <ResultDescriptor>[LIBRARY_UNIT_ERRORS]);
 
   LibraryUnitErrorsTask(InternalAnalysisContext context, AnalysisTarget target)
       : super(context, target);
 
   @override
   TaskDescriptor get descriptor => DESCRIPTOR;
 
   @override
   void internalPerform() {
     //
     // Prepare inputs.
     //
     List<List<AnalysisError>> errorLists = <List<AnalysisError>>[];
-    errorLists.addAll(getRequiredInput(CONSTRUCTORS_ERRORS_INPUT));
     errorLists.add(getRequiredInput(HINTS_INPUT));
     errorLists.add(getRequiredInput(RESOLVE_REFERENCES_ERRORS_INPUT));
     errorLists.add(getRequiredInput(RESOLVE_TYPE_NAMES_ERRORS_INPUT));
     errorLists.add(getRequiredInput(VARIABLE_REFERENCE_ERRORS_INPUT));
     errorLists.add(getRequiredInput(VERIFY_ERRORS_INPUT));
     //
     // Record outputs.
     //
     outputs[LIBRARY_UNIT_ERRORS] = AnalysisError.mergeLists(errorLists);
   }
 
   /**
    * 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 [unit].
    */
   static Map<String, TaskInput> buildInputs(AnalysisTarget target) {
     LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
-      CONSTRUCTORS_ERRORS_INPUT: COMPILATION_UNIT_ELEMENT
-          .of(unit)
-          .mappedToList((CompilationUnitElement element) => element.types)
-          .toListOf(CONSTRUCTORS_ERRORS),
       HINTS_INPUT: HINTS.of(unit),
       RESOLVE_REFERENCES_ERRORS_INPUT: RESOLVE_REFERENCES_ERRORS.of(unit),
       RESOLVE_TYPE_NAMES_ERRORS_INPUT: RESOLVE_TYPE_NAMES_ERRORS.of(unit),
       VARIABLE_REFERENCE_ERRORS_INPUT: VARIABLE_REFERENCE_ERRORS.of(unit),
       VERIFY_ERRORS_INPUT: VERIFY_ERRORS.of(unit)
     };
   }
 
   /**
    * Create a [LibraryUnitErrorsTask] based on the given [target] in the given
@@ skipping 329 matching lines @@
     }
   }
 }
 
 /**
  * A task that finishes resolution by requesting [RESOLVED_UNIT_NO_CONSTANTS] for every
  * unit in the libraries closure and produces [LIBRARY_ELEMENT].
  */
 class ResolveLibraryReferencesTask extends SourceBasedAnalysisTask {
   /**
-   * The name of the [LIBRARY_ELEMENT6] input.
+   * The name of the [LIBRARY_ELEMENT5] input.
    */
   static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
 
   /**
    * The name of the list of [RESOLVED_UNIT5] input.
    */
   static const String UNITS_INPUT = 'UNITS_INPUT';
 
   /**
    * The task descriptor describing this kind of task.
@@ skipping 29 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) {
     Source source = target;
     return <String, TaskInput>{
-      LIBRARY_INPUT: LIBRARY_ELEMENT6.of(source),
+      LIBRARY_INPUT: LIBRARY_ELEMENT5.of(source),
       UNITS_INPUT: UNITS.of(source).toList((Source unit) =>
           RESOLVED_UNIT5.of(new LibrarySpecificUnit(source, unit))),
       'resolvedUnits': IMPORT_EXPORT_SOURCE_CLOSURE
           .of(source)
           .toMapOf(UNITS)
           .toFlattenList((Source library, Source unit) =>
               RESOLVED_UNIT5.of(new LibrarySpecificUnit(library, unit))),
     };
   }
 
@@ skipping 59 matching lines @@
       AnalysisContext context, AnalysisTarget target) {
     return new ResolveLibraryTypeNamesTask(context, target);
   }
 }
 
 /**
  * A task that builds [RESOLVED_UNIT5] for a unit.
  */
 class ResolveUnitReferencesTask extends SourceBasedAnalysisTask {
   /**
-   * The name of the [LIBRARY_ELEMENT6] input.
+   * The name of the [LIBRARY_ELEMENT5] input.
    */
   static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
 
   /**
    * The name of the [RESOLVED_UNIT4] input.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
   /**
    * The name of the [TYPE_PROVIDER] input.
@@ skipping 45 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) {
     LibrarySpecificUnit unit = target;
     return <String, TaskInput>{
       'fullyBuiltLibraryElements': IMPORT_EXPORT_SOURCE_CLOSURE
           .of(unit.library)
-          .toListOf(LIBRARY_ELEMENT6),
-      LIBRARY_INPUT: LIBRARY_ELEMENT6.of(unit.library),
+          .toListOf(LIBRARY_ELEMENT5),
+      LIBRARY_INPUT: LIBRARY_ELEMENT5.of(unit.library),
       UNIT_INPUT: RESOLVED_UNIT4.of(unit),
       TYPE_PROVIDER_INPUT: TYPE_PROVIDER.of(AnalysisContextTarget.request)
     };
   }
 
   /**
    * Create a [ResolveUnitReferencesTask] based on the given [target] in
    * the given [context].
    */
   static ResolveUnitReferencesTask createTask(
@@ skipping 85 matching lines @@
       AnalysisContext context, AnalysisTarget target) {
     return new ResolveUnitTypeNamesTask(context, target);
   }
 }
 
 /**
  * A task that builds [RESOLVED_UNIT4] for a unit.
  */
 class ResolveVariableReferencesTask extends SourceBasedAnalysisTask {
   /**
-   * The name of the [LIBRARY_ELEMENT6] input.
+   * The name of the [LIBRARY_ELEMENT1] input.
    */
   static const String LIBRARY_INPUT = 'LIBRARY_INPUT';
 
   /**
    * The name of the [RESOLVED_UNIT3] input.
    */
   static const String UNIT_INPUT = 'UNIT_INPUT';
 
   /**
    * The name of the [TYPE_PROVIDER] input.
@@ skipping 417 matching lines @@
 
   @override
   bool moveNext() {
     if (_newSources.isEmpty) {
       return false;
     }
     currentTarget = _newSources.removeLast();
     return true;
   }
 }