Fix for indirect recursion in resynthesizing function type aliases.

pkg/analyzer/lib/src/summary/resynthesize.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 summary_resynthesizer;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
@@ skipping 1211 matching lines @@
    * Otherwise `null`.
    */
   DartType _type;
 
   /**
    * The number of type parameters accepted by the entity referred to by this
    * reference, or zero if it doesn't accept any type parameters.
    */
   final int numTypeParameters;
 
+  bool _isBeingInstantiatedToBounds = false;
+  bool _isRecursiveWhileInstantiateToBounds = false;
+
   /**
    * Create a new [_ReferenceInfo] object referring to an element called [name]
    * via the element handle [element], and having [numTypeParameters] type
    * parameters.
    *
    * For the special types `dynamic` and `void`, [specialType] should point to
    * the type itself.  Otherwise, pass `null` and the type will be computed
    * when appropriate.
    */
   _ReferenceInfo(
@@ skipping 13 matching lines @@
    * If this reference refers to a non-generic type, the type it refers to.
    * Otherwise `null`.
    */
   DartType get type {
     if (_type == null) {
       _type = _buildType(true, 0, (_) => DynamicTypeImpl.instance, const []);
     }
     return _type;
   }
 
+  List<DartType> get _dynamicTypeArguments =>
+      new List<DartType>.filled(numTypeParameters, DynamicTypeImpl.instance);
+
   /**
    * Build a [DartType] corresponding to the result of applying some type
    * arguments to the entity referred to by this [_ReferenceInfo].  The type
    * arguments are retrieved by calling [getTypeArgument].
    *
    * If [implicitFunctionTypeIndices] is not empty, a [DartType] should be
    * created which refers to a function type implicitly defined by one of the
    * element's parameters.  [implicitFunctionTypeIndices] is interpreted as in
    * [EntityRef.implicitFunctionTypeIndices].
    *
@@ skipping 40 matching lines @@
       InterfaceTypeImpl type =
           new InterfaceTypeImpl.elementWithNameAndArgs(element, name, () {
         if (typeArguments == null) {
           if (libraryResynthesizer.summaryResynthesizer.strongMode &&
               instantiateToBoundsAllowed) {
             InterfaceType instantiatedToBounds = libraryResynthesizer
                 .summaryResynthesizer.context.typeSystem
                 .instantiateToBounds(element.type) as InterfaceType;
             return instantiatedToBounds.typeArguments;
           } else {
-            return new List<DartType>.filled(
-                numTypeParameters, DynamicTypeImpl.instance);
+            return _dynamicTypeArguments;
           }
         }
         return typeArguments;
       });
       // Mark the type as having implicit type arguments, so that we don't
       // attempt to request them during constant expression resynthesizing.
       if (typeArguments == null) {
         libraryResynthesizer.typesWithImplicitTypeArguments.add(type);
       }
       // Done.
       return type;
     } else if (element is GenericTypeAliasElementHandle) {
       GenericTypeAliasElementImpl actualElement = element.actualElement;
       List<DartType> argumentTypes =
           new List.generate(numTypeArguments, getTypeArgument);
       return actualElement.typeAfterSubstitution(argumentTypes);
     } else if (element is FunctionTypedElement) {
       if (element is FunctionTypeAliasElementHandle) {
         List<DartType> typeArguments;
         if (numTypeArguments == numTypeParameters) {
           typeArguments =
               _buildTypeArguments(numTypeArguments, getTypeArgument);
         } else if (libraryResynthesizer.summaryResynthesizer.strongMode &&
             instantiateToBoundsAllowed) {
-          FunctionType instantiatedToBounds = libraryResynthesizer
-              .summaryResynthesizer.context.typeSystem
-              .instantiateToBounds(element.type) as FunctionType;
-          typeArguments = instantiatedToBounds.typeArguments;
+          if (!_isBeingInstantiatedToBounds) {
+            _isBeingInstantiatedToBounds = true;
+            _isRecursiveWhileInstantiateToBounds = false;
+            try {
+              FunctionType instantiatedToBounds = libraryResynthesizer
+                  .summaryResynthesizer.context.typeSystem
+                  .instantiateToBounds(element.type) as FunctionType;
+              if (!_isRecursiveWhileInstantiateToBounds) {
+                typeArguments = instantiatedToBounds.typeArguments;
+              } else {
+                typeArguments = _dynamicTypeArguments;
+              }
+            } finally {
+              _isBeingInstantiatedToBounds = false;
+            }
+          } else {
+            _isRecursiveWhileInstantiateToBounds = true;
+            typeArguments = _dynamicTypeArguments;
+          }
         } else {
-          typeArguments = new List<DartType>.filled(
-              numTypeParameters, DynamicTypeImpl.instance);
+          typeArguments = _dynamicTypeArguments;
         }
         return new FunctionTypeImpl.elementWithNameAndArgs(
             element, name, typeArguments, numTypeParameters != 0);
       } else {
         FunctionTypedElementComputer computer;
         if (implicitFunctionTypeIndices.isNotEmpty) {
           numTypeArguments = numTypeParameters;
           computer = () {
             FunctionTypedElement element = this.element;
             for (int index in implicitFunctionTypeIndices) {
@@ skipping 625 matching lines @@
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
       if (!name.endsWith('=')) {
         return name + '?';
       }
     }
     return name;
   }
 }