Implement 'instantiate to bounds' feature in resynthesizer.

pkg/analyzer/lib/src/summary/link.dart

 // Copyright (c) 2016, 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.
 
 /**
  * This library is capable of producing linked summaries from unlinked
  * ones (or prelinked ones).  It functions by building a miniature
  * element model to represent the contents of the summaries, and then
  * scanning the element model to gather linked information and adding
  * it to the summary data structures.
@@ skipping 564 matching lines @@
 
   @override
   List<UnlinkedTypeParam> get _unlinkedTypeParams =>
       _unlinkedClass.typeParameters;
 
   @override
   DartType buildType(
       DartType getTypeArgument(int i), List<int> implicitFunctionTypeIndices) {
     int numTypeParameters = _unlinkedClass.typeParameters.length;
     if (numTypeParameters != 0) {
-      List<DartType> typeArguments = new List<DartType>(numTypeParameters);
-      for (int i = 0; i < numTypeParameters; i++) {
-        typeArguments[i] = getTypeArgument(i);
-      }
-      return new InterfaceTypeImpl.elementWithNameAndArgs(
-          this, name, typeArguments);
+      return new InterfaceTypeImpl.elementWithNameAndArgs(this, name, () {
+        List<DartType> typeArguments = new List<DartType>(numTypeParameters);
+        for (int i = 0; i < numTypeParameters; i++) {
+          typeArguments[i] = getTypeArgument(i);
+        }
+        return typeArguments;
+      });
     } else {
       return _type ??= new InterfaceTypeImpl(this);
     }
   }
 
   @override
   PropertyAccessorElement getGetter(String getterName) {
     for (PropertyAccessorElement accessor in accessors) {
       if (accessor.isGetter && accessor.name == getterName) {
         return accessor;
@@ skipping 1634 matching lines @@
     int numNamed = _getNextInt();
     int numPositional = _getNextInt();
     // TODO(paulberry): don't just pop the args; use their types
     // to infer the type of type arguments.
     stack.length -= numNamed + numPositional;
     strPtr += numNamed;
     EntityRef ref = _getNextRef();
     ConstructorElementForLink element =
         unit._resolveRef(ref.reference).asConstructor;
     if (element != null) {
-      stack.add(element.enclosingClass.buildType(
-          (int i) => i >= ref.typeArguments.length
-              ? DynamicTypeImpl.instance
-              : unit._resolveTypeRef(
-                  ref.typeArguments[i], variable._typeParameterContext),
-          const []));
+      ClassElementForLink_Class enclosingClass = element.enclosingClass;
+      int numTypeParameters = enclosingClass.typeParameters.length;
+      int numTypeArguments = ref.typeArguments.length;
+      stack.add(enclosingClass.buildType((int i) {
+        if (linker.strongMode &&
+            numTypeArguments != numTypeParameters &&
+            i < numTypeParameters) {

[Paul Berry, 2016/05/10 15:55:59]

I *think* this will work, but the logic seems strange to me, because (a) the
caller guarantees that i < numTypeParameters, (b) it's not obvious that
`numTypeArguments != numTypeParameters` means "caller didn't specify this type
parameter", and (c) the logic for defaulting to dynamic in strong mode and the
logic for defaulting to dynamic in spec mode now look very different.

Consider something like this instead?

  ClassElementForLink_Class enclosingClass = element.enclosingClass;
  stack.add(enclosingClass.buildType((int i) {
    if (i < numTypeArguments) {
      // Type argument explicitly specified
      return unit._resolveTypeRef(
          ref.typeArguments[i], variable._typeParameterContext);
    } else if (linker.strongMode && typeParameter.bound != null) {
      // In strong mode, type argument defaults to bound (if any)
      return typeParameter.bound;
    } else {
      // Otherwise type argument defaults to `dynamic`
      return DynamicTypeImpl.instance;
    }
  }, const []));

+          TypeParameterElement typeParameter = enclosingClass.typeParameters[i];
+          return typeParameter.bound ?? DynamicTypeImpl.instance;
+        }
+        return i >= numTypeArguments
+            ? DynamicTypeImpl.instance
+            : unit._resolveTypeRef(
+                ref.typeArguments[i], variable._typeParameterContext);
+      }, const []));
     } else {
       stack.add(DynamicTypeImpl.instance);
     }
   }
 
   void _doInvokeMethod() {
     int numNamed = unlinkedConst.ints[intPtr++];
     int numPositional = unlinkedConst.ints[intPtr++];
     List<String> namedArgNames = _getNextStrings(numNamed);
     List<DartType> namedArgTypeList = _popList(numNamed);
@@ skipping 2023 matching lines @@
    * declared earlier in the file.
    */
   final int nestingLevel;
 
   @override
   final TypeParameterizedElementForLink enclosingElement;
 
   TypeParameterTypeImpl _type;
   ElementLocation _location;
 
+  DartType _bound;
+
   TypeParameterElementForLink(
       this.enclosingElement, this._unlinkedTypeParam, this.nestingLevel);
 
   @override
   DartType get bound {
     if (_unlinkedTypeParam.bound == null) {
       return null;
     }
-    // TODO(scheglov) implement
-    throw new UnimplementedError();
+    return _bound ??= enclosingElement.compilationUnit
+        ._resolveTypeRef(_unlinkedTypeParam.bound, enclosingElement);
   }
 
   @override
   String get identifier => name;
 
   @override
   ElementKind get kind => ElementKind.TYPE_PARAMETER;
 
   @override
   ElementLocation get location =>
@@ skipping 423 matching lines @@
    * there are no type parameters in scope.
    */
   TypeParameterizedElementForLink get _typeParameterContext;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }