Fix for issue 14497

editor/tools/plugins/com.google.dart.engine/src/com/google/dart/engine/internal/resolver/LibraryResolver.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.AnalysisEngine;
 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.StringInterpolation;
 import com.google.dart.engine.ast.StringLiteral;
+import com.google.dart.engine.ast.TypeAlias;
 import com.google.dart.engine.ast.UriBasedDirective;
 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 20 matching lines @@
 import com.google.dart.engine.source.Source;
 import com.google.dart.engine.source.SourceKind;
 import com.google.dart.engine.utilities.general.TimeCounter.TimeCounterHandle;
 import com.google.dart.engine.utilities.instrumentation.Instrumentation;
 import com.google.dart.engine.utilities.instrumentation.InstrumentationBuilder;
 import com.google.dart.engine.utilities.io.UriUtilities;
 
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 
 /**
  * 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 LibraryResolver {
   /**
+   * Instances of the class {@code TypeAliasInfo} hold information about a {@link TypeAlias}.
+   */
+  private static class TypeAliasInfo {
+    private Library 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(Library library, Source source, FunctionTypeAlias typeAlias) {
+      this.library = library;
+      this.source = source;
+      this.typeAlias = typeAlias;
+    }
+  }
+
+  /**
    * The analysis context in which the libraries are being analyzed.
    */
   private InternalAnalysisContext analysisContext;
 
   /**
    * The listener to which analysis errors will be reported, this error listener is either
    * references {@link #recordingErrorListener}, or it unions the passed
    * {@link AnalysisErrorListener} with the {@link #recordingErrorListener}.
    */
   private RecordingErrorListener errorListener;
@@ skipping 115 matching lines @@
       //
       buildElementModels();
       instrumentation.metric("buildElementModels", "complete");
       LibraryElement coreElement = coreLibrary.getLibraryElement();
       if (coreElement == null) {
         throw new AnalysisException("Could not resolve dart:core");
       }
       buildDirectiveModels();
       instrumentation.metric("buildDirectiveModels", "complete");
       typeProvider = new TypeProviderImpl(coreElement);
+      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 67 matching lines @@
       buildElementModels();
       instrumentation.metric("buildElementModels", "complete");
       LibraryElement coreElement = coreLibrary.getLibraryElement();
       if (coreElement == null) {
         throw new AnalysisException("Could not resolve dart:core");
       }
       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 265 matching lines @@
           EnumMemberBuilder builder = new EnumMemberBuilder(typeProvider);
           library.getAST(source).accept(builder);
         }
       }
     } finally {
       timeCounter.stop();
     }
   }
 
   /**
+   * 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 (Library library : librariesInCycles) {
+        for (Source source : library.getCompilationUnitSources()) {
+          CompilationUnit ast = library.getAST(source);
+          for (CompilationUnitMember member : ast.getDeclarations()) {
+            if (member instanceof FunctionTypeAlias) {
+              typeAliases.add(new TypeAliasInfo(library, source, (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 (Library library : librariesInCycles) {
         for (Source source : library.getCompilationUnitSources()) {
@@ skipping 290 matching lines @@
       return null;
     }
     String uriContent = uriLiteral.getStringValue().trim();
     if (uriContent == null || uriContent.isEmpty()) {
       return null;
     }
     uriContent = UriUtilities.encode(uriContent);
     return analysisContext.getSourceFactory().resolveUri(librarySource, uriContent);
   }
 }