Implement 'instantiate to bounds' feature in resynthesizer.

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/token.dart';
@@ skipping 503 matching lines @@
       return AstFactory.identifier(enclosing, identifier);
     }
     SimpleIdentifier property = AstFactory.identifier3(info.name)
       ..staticElement = element;
     return AstFactory.propertyAccess(enclosing, property);
   }
 
   TypeName _buildTypeAst(DartType type) {
     List<TypeName> argumentNodes;
     if (type is ParameterizedType) {
-      List<DartType> typeArguments = type.typeArguments;
-      argumentNodes = typeArguments.every((a) => a.isDynamic)
-          ? null
-          : typeArguments.map(_buildTypeAst).toList();
+      if (!resynthesizer.libraryResynthesizer.typesWithImplicitTypeArguments
+          .contains(type)) {
+        List<DartType> typeArguments = type.typeArguments;
+        argumentNodes = typeArguments.every((a) => a.isDynamic)
+            ? null
+            : typeArguments.map(_buildTypeAst).toList();
+      }
     }
     TypeName node = AstFactory.typeName4(type.name, argumentNodes);
     node.type = type;
     (node.name as SimpleIdentifier).staticElement = type.element;
     return node;
   }
 
   PropertyAccessorElement _getStringLengthElement() =>
       resynthesizer.typeProvider.stringType.getGetter('length');
 
@@ skipping 405 matching lines @@
       <String, CompilationUnitElement>{};
 
   /**
    * Map of top level elements that have been resynthesized so far.  The first
    * key is the URI of the compilation unit; the second is the name of the top
    * level element.
    */
   final Map<String, Map<String, Element>> resynthesizedElements =
       <String, Map<String, Element>>{};
 
+  /**
+   * Types with implicit type arguments, which are the same as type parameter
+   * bounds (in strong mode), or `dynamic` (in spec mode).
+   */
+  final Set<DartType> typesWithImplicitTypeArguments =
+      new Set<DartType>.identity();
+
   _LibraryResynthesizer(this.summaryResynthesizer, this.linkedLibrary,
       this.unlinkedUnits, this.librarySource) {
     isCoreLibrary = librarySource.uri.toString() == 'dart:core';
   }
 
   /**
    * Resynthesize a [NamespaceCombinator].
    */
   NamespaceCombinator buildCombinator(UnlinkedCombinator serializedCombinator) {
     if (serializedCombinator.shows.isNotEmpty) {
@@ skipping 317 matching lines @@
   }
 }
 
 /**
  * Data structure used during resynthesis to record all the information that is
  * known about how to resynthesize a single entry in [LinkedUnit.references]
  * (and its associated entry in [UnlinkedUnit.references], if it exists).
  */
 class _ReferenceInfo {
   /**
+   * The [_LibraryResynthesizer] which is being used to obtain summaries.
+   */
+  final _LibraryResynthesizer libraryResynthesizer;
+
+  /**
    * The enclosing [_ReferenceInfo], or `null` for top-level elements.
    */
   final _ReferenceInfo enclosing;
 
   /**
    * The name of the entity referred to by this reference.
    */
   final String name;
 
   /**
@@ skipping 17 matching lines @@
 
   /**
    * 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.enclosing, this.name, this.element, DartType specialType,
-      this.numTypeParameters) {
+  _ReferenceInfo(this.libraryResynthesizer, this.enclosing, this.name,
+      this.element, DartType specialType, this.numTypeParameters) {
     if (specialType != null) {
       type = specialType;
     } else {
-      type = _buildType((_) => DynamicTypeImpl.instance, const []);
+      type = _buildType(true, 0, (_) => DynamicTypeImpl.instance, const []);
     }
   }
 
   /**
    * 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`
    * is returned.
    */
-  DartType buildType(
+  DartType buildType(bool instantiateToBoundsAllowed, int numTypeArguments,
       DartType getTypeArgument(int i), List<int> implicitFunctionTypeIndices) {
     DartType result =
         (numTypeParameters == 0 && implicitFunctionTypeIndices.isEmpty)
             ? type
-            : _buildType(getTypeArgument, implicitFunctionTypeIndices);
+            : _buildType(instantiateToBoundsAllowed, numTypeArguments,
+                getTypeArgument, implicitFunctionTypeIndices);
     if (result == null) {
       // TODO(paulberry): figure out how to handle this case (which should
       // only occur in the event of erroneous code).
       throw new UnimplementedError();
     }
     return result;
   }
 
   /**
-   * If this reference refers to a type, build a [DartType] which instantiates
-   * it with type arguments returned by [getTypeArgument].  Otherwise return
-   * `null`.
+   * If this reference refers to a type, build a [DartType].  Otherwise return
+   * `null`.  If [numTypeArguments] is the same as the [numTypeParameters],
+   * the type in instantiated with type arguments returned by [getTypeArgument],
+   * otherwise it is instantiated with type parameter bounds (if strong mode),
+   * or with `dynamic` type arguments.
    *
    * If [implicitFunctionTypeIndices] is not null, 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].
    */
-  DartType _buildType(
+  DartType _buildType(bool instantiateToBoundsAllowed, int numTypeArguments,
       DartType getTypeArgument(int i), List<int> implicitFunctionTypeIndices) {
     ElementHandle element = this.element; // To allow type promotion
     if (element is ClassElementHandle) {
-      return new InterfaceTypeImpl.elementWithNameAndArgs(element, name,
-          _buildTypeArguments(numTypeParameters, getTypeArgument));
+      List<DartType> typeArguments = null;
+      // If type arguments are specified, use them.
+      // Otherwise, delay until they are requested.
+      if (numTypeParameters == 0) {
+        typeArguments = const <DartType>[];
+      } else if (numTypeArguments == numTypeParameters) {
+        typeArguments = new List<DartType>(numTypeParameters);
+        for (int i = 0; i < numTypeParameters; i++) {
+          typeArguments[i] = getTypeArgument(i);
+        }
+      }
+      InterfaceTypeImpl type =
+          new InterfaceTypeImpl.elementWithNameAndArgs(element, name, () {
+        if (typeArguments == null) {
+          typeArguments = element.typeParameters.map((typeParameter) {
+            DartType bound = typeParameter.bound;
+            return libraryResynthesizer.summaryResynthesizer.strongMode &&
+                instantiateToBoundsAllowed &&
+                bound != null ? bound : DynamicTypeImpl.instance;
+          }).toList();
+        }
+        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 FunctionTypedElement) {
       int numTypeArguments;
       FunctionTypedElementComputer computer;
       if (implicitFunctionTypeIndices.isNotEmpty) {
         numTypeArguments = numTypeParameters;
         computer = () {
           FunctionTypedElement element = this.element;
           for (int index in implicitFunctionTypeIndices) {
             element = element.parameters[index].type.element;
           }
@@ skipping 816 matching lines @@
     element.propagatedType =
         buildLinkedType(serializedVariable.propagatedTypeSlot);
   }
 
   /**
    * Build a [DartType] object based on a [EntityRef].  This [DartType]
    * may refer to elements in other libraries than the library being
    * deserialized, so handles are used to avoid having to deserialize other
    * libraries in the process.
    */
-  DartType buildType(EntityRef type, {bool defaultVoid: false}) {
+  DartType buildType(EntityRef type,
+      {bool defaultVoid: false, bool instantiateToBoundsAllowed: true}) {
     if (type == null) {
       if (defaultVoid) {
         return VoidTypeImpl.instance;
       } else {
         return DynamicTypeImpl.instance;
       }
     }
     if (type.paramReference != 0) {
       return getTypeParameterFromScope(type.paramReference);
     } else if (type.syntheticReturnType != null) {
@@ skipping 10 matching lines @@
     } else {
       DartType getTypeArgument(int i) {
         if (i < type.typeArguments.length) {
           return buildType(type.typeArguments[i]);
         } else {
           return DynamicTypeImpl.instance;
         }
       }
       _ReferenceInfo referenceInfo = referenceInfos[type.reference];
       return referenceInfo.buildType(
-          getTypeArgument, type.implicitFunctionTypeIndices);
+          instantiateToBoundsAllowed,
+          type.typeArguments.length,
+          getTypeArgument,
+          type.implicitFunctionTypeIndices);
     }
   }
 
   /**
    * Resynthesize a [FunctionTypeAliasElement] and place it in the
    * [unitHolder].
    */
   void buildTypedef(UnlinkedTypedef serializedTypedef) {
     FunctionTypeAliasElementImpl functionTypeAliasElement =
         new FunctionTypeAliasElementImpl(
@@ skipping 124 matching lines @@
     initializerElement.setCodeRange(null, null);
     variable.initializer = initializerElement;
   }
 
   /**
    * Finish creating a [TypeParameterElement] by deserializing its bound.
    */
   void finishTypeParameter(UnlinkedTypeParam serializedTypeParameter,
       TypeParameterElementImpl typeParameterElement) {
     if (serializedTypeParameter.bound != null) {
-      typeParameterElement.bound = buildType(serializedTypeParameter.bound);
+      typeParameterElement.bound = buildType(serializedTypeParameter.bound,
+          instantiateToBoundsAllowed: false);
     }
   }
 
   /**
    * Return a list of type arguments corresponding to [currentTypeParameters],
    * skipping the innermost [skipLevels] nesting levels.
    *
    * Type parameters are listed in nesting order from innermost to outermost,
    * and then in declaration order.  So for instance if we are resynthesizing a
    * method declared as `class C<T, U> { void m<V, W>() { ... } }`, then the
@@ skipping 131 matching lines @@
             } else {
               throw new StateError('Unexpected element enclosing function:'
                   ' ${enclosingElement.runtimeType}');
             }
             break;
           case ReferenceKind.prefix:
           case ReferenceKind.unresolved:
             break;
         }
       }
-      referenceInfos[i] = new _ReferenceInfo(
+      referenceInfos[i] = new _ReferenceInfo(libraryResynthesizer,
           enclosingInfo, name, element, type, numTypeParameters);
     }
   }
 
   /**
    * Populate a [CompilationUnitElement] by deserializing all the elements
    * contained in it.
    */
   void populateUnit() {
     unlinkedUnit.classes.forEach(buildClass);
@@ skipping 66 matching lines @@
 
   /**
    * Return the defining type for a [ConstructorElement] by applying
    * [typeArgumentRefs] to the given linked [info].
    */
   InterfaceType _createConstructorDefiningType(
       _ReferenceInfo info, List<EntityRef> typeArgumentRefs) {
     bool isClass = info.element is ClassElement;
     _ReferenceInfo classInfo = isClass ? info : info.enclosing;
     List<DartType> typeArguments = typeArgumentRefs.map(buildType).toList();
-    return classInfo.buildType((i) {
+    return classInfo.buildType(true, typeArguments.length, (i) {
       if (i < typeArguments.length) {
         return typeArguments[i];
       } else {
         return DynamicTypeImpl.instance;
       }
     }, const <int>[]);
   }
 
   /**
    * Return the [ConstructorElement] corresponding to the given linked [info],
@@ skipping 22 matching lines @@
   static String _getElementIdentifier(String name, ReferenceKind kind) {
     if (kind == ReferenceKind.topLevelPropertyAccessor ||
         kind == ReferenceKind.propertyAccessor) {
       if (!name.endsWith('=')) {
         return name + '?';
       }
     }
     return name;
   }
 }