Fix some corner cases of inferring type parameters from bounds.

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 296 matching lines @@
  */
 typedef LinkedLibrary GetDependencyCallback(String absoluteUri);
 
 /**
  * Type of the callback used by [link] and [relink] to request
  * [UnlinkedUnit] objects.
  */
 typedef UnlinkedUnit GetUnitCallback(String absoluteUri);
 
 /**
+ * Stub implementation of [AnalysisOptions] used during linking.
+ */
+class AnalysisOptionsForLink implements AnalysisOptions {
+  final Linker _linker;
+
+  AnalysisOptionsForLink(this._linker);
+
+  @override
+  bool get strongMode => _linker.strongMode;
+
+  @override
+  noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
+}
+
+/**
  * Element representing a class or enum resynthesized from a summary
  * during linking.
  */
 abstract class ClassElementForLink extends Object
     with ReferenceableElementForLink
     implements ClassElementImpl {
   Map<String, ReferenceableElementForLink> _containedNames;
 
   @override
   final CompilationUnitElementForLink enclosingElement;
@@ skipping 12 matching lines @@
   ConstructorElementForLink get asConstructor => unnamedConstructor;
 
   @override
   DartType get asStaticType =>
       enclosingElement.enclosingElement._linker.typeProvider.typeType;
 
   @override
   List<ConstructorElementForLink> get constructors;
 
   @override
+  CompilationUnitElementForLink get enclosingUnit => enclosingElement;
+
+  @override
   List<FieldElementForLink> get fields;
 
   /**
    * Indicates whether this is the core class `Object`.
    */
   bool get isObject;
 
   @override
   LibraryElementForLink get library => enclosingElement.library;
 
@@ skipping 116 matching lines @@
       if (_constructors.isEmpty) {
         _unnamedConstructorComputed = true;
         _unnamedConstructor = new ConstructorElementForLink_Synthetic(this);
         _constructors.add(_unnamedConstructor);
       }
     }
     return _constructors;
   }
 
   @override
+  ContextForLink get context => enclosingUnit.context;
+
+  @override
   String get displayName => _unlinkedClass.name;
 
   @override
   TypeParameterizedElementMixin get enclosingTypeParameterContext => null;
 
   @override
   List<FieldElementForLink_ClassField> get fields {
     if (_fields == null) {
       _fields = <FieldElementForLink_ClassField>[];
       for (UnlinkedVariable field in _unlinkedClass.fields) {
@@ skipping 72 matching lines @@
   }
 
   @override
   DartType buildType(
       DartType getTypeArgument(int i), List<int> implicitFunctionTypeIndices) {
     int numTypeParameters = _unlinkedClass.typeParameters.length;
     if (numTypeParameters != 0) {
       return new InterfaceTypeImpl.elementWithNameAndArgs(this, name, () {
         List<DartType> typeArguments = new List<DartType>(numTypeParameters);
         for (int i = 0; i < numTypeParameters; i++) {
-          typeArguments[i] = getTypeArgument(i);
+          typeArguments[i] =
+              getTypeArgument(i) ?? computeDefaultTypeArgument(i);
         }
         return typeArguments;
       });
     } else {
       return _type ??= new InterfaceTypeImpl(this);
     }
   }
 
   @override
   PropertyAccessorElement getGetter(String getterName) {
@@ skipping 219 matching lines @@
         _accessors.add(variable.getter);
         if (!variable.isConst && !variable.isFinal) {
           _accessors.add(variable.setter);
         }
       }
     }
     return _accessors;
   }
 
   @override
+  ContextForLink get context => library.context;
+
+  @override
   LibraryElementForLink get enclosingElement;
 
   @override
   List<ClassElementForLink_Enum> get enums {
     if (_enums == null) {
       _enums = <ClassElementForLink_Enum>[];
       for (UnlinkedEnum unlinkedEnum in _unlinkedUnit.enums) {
         _enums.add(new ClassElementForLink_Enum(this, unlinkedEnum));
       }
     }
@@ skipping 111 matching lines @@
    * Compute the type referred to by the given linked type [slot] (interpreted
    * relative to [typeParameterContext]).  If there is no inferred type in the
    * given slot, `dynamic` is returned.
    */
   DartType getLinkedType(
       int slot, TypeParameterizedElementMixin typeParameterContext);
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
-  @override
-  DartType resolveTypeRef(
-      EntityRef type, TypeParameterizedElementMixin typeParameterContext,
-      {bool defaultVoid: false, bool instantiateToBoundsAllowed: true}) {
-    if (type == null) {
-      if (defaultVoid) {
-        return VoidTypeImpl.instance;
-      } else {
-        return DynamicTypeImpl.instance;
-      }
-    }
-    if (type.paramReference != 0) {
-      return typeParameterContext.getTypeParameterType(type.paramReference);
-    } else if (type.syntheticReturnType != null) {
-      // TODO(paulberry): implement.
-      throw new UnimplementedError();
-    } else if (type.implicitFunctionTypeIndices.isNotEmpty) {
-      // TODO(paulberry): implement.
-      throw new UnimplementedError();
-    } else {
-      DartType getTypeArgument(int i) {
-        if (i < type.typeArguments.length) {
-          return resolveTypeRef(type.typeArguments[i], typeParameterContext);
-        } else {
-          return DynamicTypeImpl.instance;
-        }
-      }
-      ReferenceableElementForLink element = resolveRef(type.reference);
-      return element.buildType(
-          getTypeArgument, type.implicitFunctionTypeIndices);
-    }
-  }
-
   /**
    * Return the element referred to by the given [index] in
    * [UnlinkedUnit.references].  If the reference is unresolved,
    * return [UndefinedElementForLink.instance].
    */
   ReferenceableElementForLink resolveRef(int index) {
     if (_references[index] == null) {
       UnlinkedReference unlinkedReference =
           index < _unlinkedUnit.references.length
               ? _unlinkedUnit.references[index]
@@ skipping 30 matching lines @@
       } else {
         LibraryElementForLink dependency =
             enclosingElement._getDependency(linkedReference.dependency);
         _references[index] = dependency.getContainedName(name);
       }
     }
     return _references[index];
   }
 
   @override
+  DartType resolveTypeRef(
+      EntityRef type, TypeParameterizedElementMixin typeParameterContext,
+      {bool defaultVoid: false, bool instantiateToBoundsAllowed: true}) {
+    if (type == null) {
+      if (defaultVoid) {
+        return VoidTypeImpl.instance;
+      } else {
+        return DynamicTypeImpl.instance;
+      }
+    }
+    if (type.paramReference != 0) {
+      return typeParameterContext.getTypeParameterType(type.paramReference);
+    } else if (type.syntheticReturnType != null) {
+      // TODO(paulberry): implement.
+      throw new UnimplementedError();
+    } else if (type.implicitFunctionTypeIndices.isNotEmpty) {
+      // TODO(paulberry): implement.
+      throw new UnimplementedError();
+    } else {
+      DartType getTypeArgument(int i) {
+        if (i < type.typeArguments.length) {
+          return resolveTypeRef(type.typeArguments[i], typeParameterContext);
+        } else if (!instantiateToBoundsAllowed) {
+          // Do not allow buildType to instantiate the bounds; force dynamic.
+          return DynamicTypeImpl.instance;
+        } else {
+          return null;
+        }
+      }
+      ReferenceableElementForLink element = resolveRef(type.reference);
+      return element.buildType(
+          getTypeArgument, type.implicitFunctionTypeIndices);
+    }
+  }
+
+  @override
   String toString() => enclosingElement.toString();
 }
 
 /**
  * Element representing a compilation unit which is part of the build
  * unit being linked.
  */
 class CompilationUnitElementInBuildUnit extends CompilationUnitElementForLink {
   @override
   final LinkedUnitBuilder _linkedUnit;
@@ skipping 570 matching lines @@
 /**
  * Stub implementation of [AnalysisContext] which provides just those methods
  * needed during linking.
  */
 class ContextForLink implements AnalysisContext {
   final Linker _linker;
 
   ContextForLink(this._linker);
 
   @override
+  AnalysisOptionsForLink get analysisOptions => _linker.analysisOptions;
+
+  @override
   TypeSystem get typeSystem => _linker.typeSystem;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }
 
 /**
  * An instance of [DependencyWalker] contains the core algorithms for
  * walking a dependency graph and evaluating nodes in a safe order.
  */
@@ skipping 135 matching lines @@
   DartType _inferredReturnType;
   FunctionTypeImpl _type;
   String _name;
   String _displayName;
 
   @override
   final CompilationUnitElementForLink compilationUnit;
 
   ExecutableElementForLink(this.compilationUnit, this._unlinkedExecutable);
 
+  @override
+  ContextForLink get context => compilationUnit.context;
+
   /**
    * If the executable element had an explicitly declared return type, return
    * it.  Otherwise return `null`.
    */
   DartType get declaredReturnType {
     if (_unlinkedExecutable.returnType == null) {
       return null;
     } else {
       return _declaredReturnType ??=
           compilationUnit.resolveTypeRef(_unlinkedExecutable.returnType, this);
@@ skipping 486 matching lines @@
     EntityRef ref = _getNextRef();
     ConstructorElementForLink element =
         unit.resolveRef(ref.reference).asConstructor;
     if (element != null) {
       ClassElementForLink_Class enclosingClass = element.enclosingClass;
       stack.add(enclosingClass.buildType((int i) {
         // Type argument explicitly specified.
         if (i < ref.typeArguments.length) {
           return unit.resolveTypeRef(
               ref.typeArguments[i], variable._typeParameterContext);
+        } else {
+          return null;
         }
-        // In strong mode, type argument defaults to bound (if any).
-        if (linker.strongMode) {
-          TypeParameterElement typeParameter = enclosingClass.typeParameters[i];
-          if (typeParameter.bound != null) {
-            return typeParameter.bound;
-          }
-        }
-        // Otherwise type argument defaults to `dynamic`.
-        return DynamicTypeImpl.instance;
       }, const []));
     } else {
       stack.add(DynamicTypeImpl.instance);
     }
   }
 
   void _doInvokeMethod() {
     int numNamed = unlinkedConst.ints[intPtr++];
     int numPositional = unlinkedConst.ints[intPtr++];
     List<String> namedArgNames = _getNextStrings(numNamed);
@@ skipping 553 matching lines @@
   DartType _returnType;
 
   FunctionTypeAliasElementForLink(this.enclosingElement, this._unlinkedTypedef);
 
   @override
   DartType get asStaticType {
     return enclosingElement.enclosingElement._linker.typeProvider.typeType;
   }
 
   @override
+  ContextForLink get context => enclosingElement.context;
+
+  @override
   TypeParameterizedElementMixin get enclosingTypeParameterContext => null;
 
   @override
   CompilationUnitElementInBuildUnit get enclosingUnit => enclosingElement;
 
   @override
   String get identifier => _unlinkedTypedef.name;
 
   @override
   List<int> get implicitFunctionTypeIndices => const <int>[];
@@ skipping 21 matching lines @@
   List<UnlinkedTypeParam> get unlinkedTypeParams =>
       _unlinkedTypedef.typeParameters;
 
   @override
   DartType buildType(
       DartType getTypeArgument(int i), List<int> implicitFunctionTypeIndices) {
     int numTypeParameters = _unlinkedTypedef.typeParameters.length;
     if (numTypeParameters != 0) {
       List<DartType> typeArguments = new List<DartType>(numTypeParameters);
       for (int i = 0; i < numTypeParameters; i++) {
-        typeArguments[i] = getTypeArgument(i);
+        typeArguments[i] = getTypeArgument(i) ?? computeDefaultTypeArgument(i);
       }
       return new FunctionTypeImpl.elementWithNameAndArgs(
           this, name, typeArguments, true);
     } else {
       return _type ??= new FunctionTypeImpl.forTypedef(this);
     }
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
@@ skipping 445 matching lines @@
   final bool strongMode;
 
   LibraryElementForLink _coreLibrary;
   LibraryElementForLink _asyncLibrary;
   TypeProviderForLink _typeProvider;
   TypeSystem _typeSystem;
   SpecialTypeElementForLink _voidElement;
   SpecialTypeElementForLink _dynamicElement;
   SpecialTypeElementForLink _bottomElement;
   ContextForLink _context;
+  AnalysisOptionsForLink _analysisOptions;
 
   Linker(Map<String, LinkedLibraryBuilder> linkedLibraries, this.getDependency,
       this.getUnit, this.strongMode) {
     // Create elements for the libraries to be linked.  The rest of
     // the element model will be created on demand.
     linkedLibraries
         .forEach((String absoluteUri, LinkedLibraryBuilder linkedLibrary) {
       Uri uri = Uri.parse(absoluteUri);
       _librariesInBuildUnit.add(_libraries[uri] =
           new LibraryElementInBuildUnit(this, uri, linkedLibrary));
     });
   }
 
   /**
+   * Get an instance of [AnalysisOptions] for use during linking.
+   */
+  AnalysisOptionsForLink get analysisOptions =>
+      _analysisOptions ??= new AnalysisOptionsForLink(this);
+
+  /**
    * Get the library element for `dart:async`.
    */
   LibraryElementForLink get asyncLibrary =>
       _asyncLibrary ??= getLibrary(Uri.parse('dart:async'));
 
   /**
    * Get the element representing the "bottom" type.
    */
   SpecialTypeElementForLink get bottomElement => _bottomElement ??=
       new SpecialTypeElementForLink(this, BottomTypeImpl.instance);
@@ skipping 693 matching lines @@
    * If this element can be used in a getter context as a type inference
    * dependency, return the [TypeInferenceNode] for the inferred type.
    * Otherwise return `null`.
    */
   TypeInferenceNode get asTypeInferenceNode => null;
 
   /**
    * Return the type indicated by this element when it is used in a
    * type instantiation context.  If this element can't legally be
    * instantiated as a type, return the dynamic type.
+   *
+   * If the type is parameterized, [getTypeArgument] will be called to retrieve
+   * the type parameters.  It should return `null` for unspecified type
+   * parameters.
    */
   DartType buildType(DartType getTypeArgument(int i),
           List<int> implicitFunctionTypeIndices) =>
       DynamicTypeImpl.instance;
 
   /**
    * If this element contains other named elements, return the
    * contained element having the given [name].  If this element can't
    * contain other named elements, or it doesn't contain an element
    * with the given name, return the singleton of
@@ skipping 553 matching lines @@
    * there are no type parameters in scope.
    */
   TypeParameterizedElementMixin get _typeParameterContext;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }