Instantiate parameterized types of type parameters with 'dynamic' type arguments.

pkg/analyzer/lib/src/dart/element/element.dart

 // Copyright (c) 2014, 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 analyzer.src.dart.element.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 8123 matching lines @@
    * be `dynamic`, but sometimes it will be the bound of the ith type parameter.
    */
   DartType computeDefaultTypeArgument(int i) {
     // If strong mode is off, or we can tell quickly from the summary that there
     // is no bound, then the default type argument is `dynamic`; we don't have
     // to call `typeParameters` to find that out.
     if (!context.analysisOptions.strongMode ||
         (unlinkedTypeParams != null && unlinkedTypeParams[i].bound == null)) {
       return DynamicTypeImpl.instance;
     }
-    return typeParameters[i].bound ?? DynamicTypeImpl.instance;
+    DartType bound = typeParameters[i].bound ?? DynamicTypeImpl.instance;
+    return context.typeSystem.instantiateToDynamic(bound);

[Leaf, 2016/09/30 23:44:52]

I don't think this is really right for strong mode, if I understand this
correctly.  The definition of instantiateToBounds for strong mode doesn't just
replace the variables with dynamic, it instead walks sequentially over the type
parameters computing for the ith bound Bi the default type argument Di as Bi
with dynamic for Ti and Dj for Tj for all j < i.  

I'm unhappy with this definition, and am working with the language team to get a
better solution here, but if the goal is consistency with instantiateToBounds I
think this isn't quite right.

   }
 
   /**
    * Convert the given [index] into a type parameter type.
    */
   TypeParameterType getTypeParameterType(int index) {
     List<TypeParameterType> types = typeParameterTypes;
     if (index <= types.length) {
       return types[types.length - index];
     } else if (enclosingTypeParameterContext != null) {
@@ skipping 290 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }