Remove BuildFunctionTypeAliasesTask.

pkg/analyzer/lib/src/generated/resolver.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 engine.resolver;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/src/generated/utilities_collection.dart';
@@ skipping 7819 matching lines @@
     LibraryElement coreElement = _coreLibrary.libraryElement;
     if (coreElement == null) {
       throw new AnalysisException("Could not resolve dart:core");
     }
     LibraryElement asyncElement = _asyncLibrary.libraryElement;
     if (asyncElement == null) {
       throw new AnalysisException("Could not resolve dart:async");
     }
     _buildDirectiveModels();
     _typeProvider = new TypeProviderImpl(coreElement, asyncElement);
-    _buildTypeAliases();
     _buildTypeHierarchies();
     //
     // Perform resolution and type analysis.
     //
     // TODO(brianwilkerson) Decide whether we want to resolve all of the
     // libraries or whether we want to only resolve the target library.
     // The advantage to resolving everything is that we have already done part
     // of the work so we'll avoid duplicated effort. The disadvantage of
     // resolving everything is that we might do extra work that we don't
     // really care about. Another possibility is to add a parameter to this
@@ skipping 59 matching lines @@
     if (coreElement == null) {
       throw new AnalysisException("Could not resolve dart:core");
     }
     LibraryElement asyncElement = _asyncLibrary.libraryElement;
     if (asyncElement == null) {
       throw new AnalysisException("Could not resolve dart:async");
     }
     _buildDirectiveModels();
     _typeProvider = new TypeProviderImpl(coreElement, asyncElement);
     _buildEnumMembers();
-    _buildTypeAliases();
     _buildTypeHierarchies();
     _buildImplicitConstructors();
     //
     // Perform resolution and type analysis.
     //
     // TODO(brianwilkerson) Decide whether we want to resolve all of the
     // libraries or whether we want to only resolve the target library. The
     // advantage to resolving everything is that we have already done part of
     // the work so we'll avoid duplicated effort. The disadvantage of
     // resolving everything is that we might do extra work that we don't
@@ skipping 278 matching lines @@
     PerformanceStatistics.resolve.makeCurrentWhile(() {
       ImplicitConstructorComputer computer = new ImplicitConstructorComputer();
       for (Library library in _librariesInCycles) {
         computer.add(_errorListener, library.libraryElement);
       }
       computer.compute();
     });
   }
 
   /**
-   * Resolve the types referenced by function type aliases across all of the function type aliases
-   * defined in the current cycle.
-   *
-   * @throws AnalysisException if any of the function type aliases could not be resolved
-   */
-  void _buildTypeAliases() {
-    PerformanceStatistics.resolve.makeCurrentWhile(() {
-      List<LibraryResolver_TypeAliasInfo> typeAliases =
-          new List<LibraryResolver_TypeAliasInfo>();
-      for (Library library in _librariesInCycles) {
-        for (Source source in library.compilationUnitSources) {
-          CompilationUnit ast = library.getAST(source);
-          for (CompilationUnitMember member in ast.declarations) {
-            if (member is FunctionTypeAlias) {
-              typeAliases.add(
-                  new LibraryResolver_TypeAliasInfo(library, source, member));
-            }
-          }
-        }
-      }
-      // TODO(brianwilkerson) We need to sort the type aliases such that all
-      // aliases referenced by an alias T are resolved before we resolve T.
-      for (LibraryResolver_TypeAliasInfo info in typeAliases) {
-        TypeResolverVisitor visitor = new TypeResolverVisitor.con1(
-            info._library, info._source, _typeProvider);
-        info._typeAlias.accept(visitor);
-      }
-    });
-  }
-
-  /**
    * Resolve the type hierarchy across all of the types declared in the libraries in the current
    * cycle.
    *
    * @throws AnalysisException if any of the type hierarchies could not be resolved
    */
   void _buildTypeHierarchies() {
     PerformanceStatistics.resolve.makeCurrentWhile(() {
       for (Library library in _librariesInCycles) {
         for (Source source in library.compilationUnitSources) {
           TypeResolverVisitorFactory typeResolverVisitorFactory =
@@ skipping 418 matching lines @@
     if (coreElement == null) {
       missingCoreLibrary(analysisContext, _coreLibrarySource);
     }
     LibraryElement asyncElement = _asyncLibrary.libraryElement;
     if (asyncElement == null) {
       missingAsyncLibrary(analysisContext, _asyncLibrarySource);
     }
     _buildDirectiveModels();
     _typeProvider = new TypeProviderImpl(coreElement, asyncElement);
     _buildEnumMembers();
-    _buildTypeAliases();
     _buildTypeHierarchies();
     _buildImplicitConstructors();
     //
     // Perform resolution and type analysis.
     //
     // TODO(brianwilkerson) Decide whether we want to resolve all of the
     // libraries or whether we want to only resolve the target library. The
     // advantage to resolving everything is that we have already done part of
     // the work so we'll avoid duplicated effort. The disadvantage of
     // resolving everything is that we might do extra work that we don't
@@ skipping 219 matching lines @@
       for (int j = 0; j < dependencyCount; j++) {
         ResolvableLibrary dependency = dependencies[j];
         //dependency.setErrorListener(errorListener);
         libraryMap[dependency.librarySource] = dependency;
       }
     }
     return libraryMap;
   }
 
   /**
-   * Resolve the types referenced by function type aliases across all of the function type aliases
-   * defined in the current cycle.
-   *
-   * @throws AnalysisException if any of the function type aliases could not be resolved
-   */
-  void _buildTypeAliases() {
-    PerformanceStatistics.resolve.makeCurrentWhile(() {
-      List<LibraryResolver2_TypeAliasInfo> typeAliases =
-          new List<LibraryResolver2_TypeAliasInfo>();
-      for (ResolvableLibrary library in _librariesInCycle) {
-        for (ResolvableCompilationUnit unit
-            in library.resolvableCompilationUnits) {
-          for (CompilationUnitMember member
-              in unit.compilationUnit.declarations) {
-            if (member is FunctionTypeAlias) {
-              typeAliases.add(new LibraryResolver2_TypeAliasInfo(
-                  library, unit.source, member));
-            }
-          }
-        }
-      }
-      // TODO(brianwilkerson) We need to sort the type aliases such that all
-      // aliases referenced by an alias T are resolved before we resolve T.
-      for (LibraryResolver2_TypeAliasInfo info in typeAliases) {
-        TypeResolverVisitor visitor = new TypeResolverVisitor.con4(
-            info._library, info._source, _typeProvider);
-        info._typeAlias.accept(visitor);
-      }
-    });
-  }
-
-  /**
    * Resolve the type hierarchy across all of the types declared in the libraries in the current
    * cycle.
    *
    * @throws AnalysisException if any of the type hierarchies could not be resolved
    */
   void _buildTypeHierarchies() {
     PerformanceStatistics.resolve.makeCurrentWhile(() {
       for (ResolvableLibrary library in _librariesInCycle) {
         for (ResolvableCompilationUnit unit
             in library.resolvableCompilationUnits) {
@@ skipping 5065 matching lines @@
       type.typeArguments = definingClass.type.typeArguments;
     }
     element.type = type;
     return null;
   }
 
   @override
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     FunctionTypeAliasElementImpl element =
         node.element as FunctionTypeAliasElementImpl;
-    if (element.returnType == null) {
-      // Only visit function type aliases once.
-      super.visitFunctionTypeAlias(node);
-      element.returnType = _computeReturnType(node.returnType);
-    }
+    super.visitFunctionTypeAlias(node);
+    element.returnType = _computeReturnType(node.returnType);
     return null;
   }
 
   @override
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     super.visitFunctionTypedFormalParameter(node);
     Element element = node.identifier.staticElement;
     if (element is ParameterElementImpl) {
       _setFunctionTypedParameterType(element, node.returnType, node.parameters);
     } else {
@@ skipping 1538 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }