Fix for issue 14497

editor/tools/plugins/com.google.dart.engine/src/com/google/dart/engine/internal/resolver/LibraryResolver2.java

 /*
  * Copyright (c) 2013, the Dart project authors.
  * 
  * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
  * in compliance with the License. You may obtain a copy of the License at
  * 
  * http://www.eclipse.org/legal/epl-v10.html
  * 
  * Unless required by applicable law or agreed to in writing, software distributed under the License
  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
 package com.google.dart.engine.internal.resolver;
 
 import com.google.dart.engine.ast.Combinator;
 import com.google.dart.engine.ast.CompilationUnit;
+import com.google.dart.engine.ast.CompilationUnitMember;
 import com.google.dart.engine.ast.Directive;
 import com.google.dart.engine.ast.ExportDirective;
+import com.google.dart.engine.ast.FunctionTypeAlias;
 import com.google.dart.engine.ast.HideCombinator;
 import com.google.dart.engine.ast.ImportDirective;
 import com.google.dart.engine.ast.NamespaceDirective;
 import com.google.dart.engine.ast.NodeList;
 import com.google.dart.engine.ast.ShowCombinator;
 import com.google.dart.engine.ast.SimpleIdentifier;
 import com.google.dart.engine.ast.StringLiteral;
+import com.google.dart.engine.ast.TypeAlias;
 import com.google.dart.engine.context.AnalysisContext;
 import com.google.dart.engine.context.AnalysisException;
 import com.google.dart.engine.element.Element;
 import com.google.dart.engine.element.ExportElement;
 import com.google.dart.engine.element.FunctionElement;
 import com.google.dart.engine.element.ImportElement;
 import com.google.dart.engine.element.LibraryElement;
 import com.google.dart.engine.element.NamespaceCombinator;
 import com.google.dart.engine.error.AnalysisError;
 import com.google.dart.engine.error.AnalysisErrorListener;
@@ skipping 32 matching lines @@
 import java.util.List;
 
 /**
  * Instances of the class {@code LibraryResolver} are used to resolve one or more mutually dependent
  * libraries within a single context.
  * 
  * @coverage dart.engine.resolver
  */
 public class LibraryResolver2 {
   /**
+   * Instances of the class {@code TypeAliasInfo} hold information about a {@link TypeAlias}.
+   */
+  private static class TypeAliasInfo {
+    private ResolvableLibrary library;
+    private Source source;
+    private FunctionTypeAlias typeAlias;
+
+    /**
+     * Initialize a newly created information holder with the given information.
+     * 
+     * @param library the library containing the type alias
+     * @param source the source of the file containing the type alias
+     * @param typeAlias the type alias being remembered
+     */
+    public TypeAliasInfo(ResolvableLibrary library, Source source, FunctionTypeAlias typeAlias) {
+      this.library = library;
+      this.source = source;
+      this.typeAlias = typeAlias;
+    }
+  }
+
+  /**
    * Report that the core library could not be resolved in the given analysis context and throw an
    * exception.
    * 
    * @param analysisContext the analysis context in which the failure occurred
    * @param coreLibrarySource the source representing the core library
    * @throws AnalysisException always
    */
   @DartBlockBody({"throw new AnalysisException(\"Could not resolve dart:core\");"})
   public static void missingCoreLibrary(AnalysisContext analysisContext, Source coreLibrarySource)
       throws AnalysisException {
@@ skipping 140 matching lines @@
       buildElementModels();
       instrumentation.metric("buildElementModels", "complete");
       LibraryElement coreElement = coreLibrary.getLibraryElement();
       if (coreElement == null) {
         missingCoreLibrary(analysisContext, coreLibrarySource);
       }
       buildDirectiveModels();
       instrumentation.metric("buildDirectiveModels", "complete");
       typeProvider = new TypeProviderImpl(coreElement);
       buildEnumMembers();
+      buildTypeAliases();
       buildTypeHierarchies();
       instrumentation.metric("buildTypeHierarchies", "complete");
       //
       // 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 method and punt the decision to the clients.
@@ skipping 212 matching lines @@
       for (int j = 0; j < dependencyCount; j++) {
         ResolvableLibrary dependency = dependencies[j];
         //dependency.setErrorListener(errorListener);
         libraryMap.put(dependency.getLibrarySource(), 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
+   */
+  private void buildTypeAliases() throws AnalysisException {
+    TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start();
+    try {
+      List<TypeAliasInfo> typeAliases = new ArrayList<TypeAliasInfo>();
+      for (ResolvableLibrary library : librariesInCycle) {
+        for (ResolvableCompilationUnit unit : library.getResolvableCompilationUnits()) {
+          for (CompilationUnitMember member : unit.getCompilationUnit().getDeclarations()) {
+            if (member instanceof FunctionTypeAlias) {
+              typeAliases.add(new TypeAliasInfo(
+                  library,
+                  unit.getSource(),
+                  (FunctionTypeAlias) 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 (TypeAliasInfo info : typeAliases) {
+        TypeResolverVisitor visitor = new TypeResolverVisitor(
+            info.library,
+            info.source,
+            typeProvider);
+        info.typeAlias.accept(visitor);
+      }
+    } finally {
+      timeCounter.stop();
+    }
+  }
+
+  /**
    * 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
    */
   private void buildTypeHierarchies() throws AnalysisException {
     TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start();
     try {
       for (ResolvableLibrary library : librariesInCycle) {
         for (ResolvableCompilationUnit unit : library.getResolvableCompilationUnits()) {
@@ skipping 96 matching lines @@
     try {
       for (Source source : library.getCompilationUnitSources()) {
         CompilationUnit ast = library.getAST(source);
         new PolymerCompilationUnitBuilder(ast).build();
       }
     } finally {
       timeCounter.stop();
     }
   }
 }