Issue 29388. Resynthesize non-generic types for ReferenceInfo lazily.

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 1203 matching lines @@
    * The element referred to by this reference, or `null` if there is no
    * associated element (e.g. because it is a reference to an undefined
    * entity).
    */
   final Element element;
 
   /**
    * If this reference refers to a non-generic type, the type it refers to.
    * Otherwise `null`.
    */
-  DartType type;
+  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;
 
   /**
    * 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(
       this.libraryResynthesizer,
       this.enclosing,
       this.name,
       this.isDeclarableType,
       this.element,
       DartType specialType,
       this.numTypeParameters) {
     if (specialType != null) {
-      type = specialType;
-    } else {
-      type = _buildType(true, 0, (_) => DynamicTypeImpl.instance, const []);
+      _type = specialType;
     }
   }
 
   /**
+   * 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;
+  }
+
+  /**
    * 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].
    *
    * If the entity referred to by this [_ReferenceInfo] is not a type, `null`
@@ skipping 64 matching lines @@
       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) {
+                instantiateToBoundsAllowed
+//            && !_isBeingInstantiatedToBounds

[Brian Wilkerson, 2017/04/24 18:35:47]

Should we remove the commented out code?

+            ) {
+//          _isBeingInstantiatedToBounds = true;
+//          try {
           FunctionType instantiatedToBounds = libraryResynthesizer
               .summaryResynthesizer.context.typeSystem
               .instantiateToBounds(element.type) as FunctionType;
           typeArguments = instantiatedToBounds.typeArguments;
+//          } finally {
+//            _isBeingInstantiatedToBounds = false;
+//          }
         } else {
           typeArguments = new List<DartType>.filled(
               numTypeParameters, DynamicTypeImpl.instance);
         }
         return new FunctionTypeImpl.elementWithNameAndArgs(
             element, name, typeArguments, numTypeParameters != 0);
       } else {
         FunctionTypedElementComputer computer;
         if (implicitFunctionTypeIndices.isNotEmpty) {
           numTypeArguments = numTypeParameters;
@@ skipping 628 matching lines @@
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
       if (!name.endsWith('=')) {
         return name + '?';
       }
     }
     return name;
   }
 }