Suppress NO_DEFAULT_BOUND errors.

pkg/analyzer/lib/src/generated/type_system.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 analyzer.src.generated.type_system;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'package:analyzer/dart/ast/ast.dart' show AstNode;
@@ skipping 40 matching lines @@
    * A list of non-nullable type names (e.g., 'int', 'bool', etc.).
    */
   final List<String> nonnullableTypes;
 
   final TypeProvider typeProvider;
 
   StrongTypeSystemImpl(this.typeProvider,
       {this.implicitCasts: true,
       this.nonnullableTypes: AnalysisOptionsImpl.NONNULLABLE_TYPES});
 
+  @override
+  bool get isStrong => true;
+
   bool anyParameterType(FunctionType ft, bool predicate(DartType t)) {
     return ft.parameters.any((p) => predicate(p.type));
   }
 
   @override
-  bool get isStrong => true;
-
-  @override
   FunctionType functionTypeToConcreteType(FunctionType t) {
     // TODO(jmesserly): should we use a real "fuzzyArrow" bit on the function
     // type? That would allow us to implement this in the subtype relation.
     // TODO(jmesserly): we'll need to factor this differently if we want to
     // move CodeChecker's functionality into existing analyzer. Likely we can
     // let the Expression have a strict arrow, then in places were we do
     // inference, convert back to a fuzzy arrow.
 
     if (!t.parameters.any((p) => p.type.isDynamic)) {
       return t;
@@ skipping 285 matching lines @@
           defaults[parameter] = value.substitute2(
               defaults.values.toList(), defaults.keys.toList());
           partials.remove(parameter);
           hasProgress = true;
           break;
         }
       }
     }
 
     // If we stopped making progress, and not all types are ground,
-    // then the whole type is malbounded and an error should be reported.
+    // then the whole type is malbounded and an error should be reported
+    // if errors are requested, and a partially completed type should
+    // be returned.
     if (partials.isNotEmpty) {
       if (hasError != null) {
         hasError[0] = true;
       }
-      return instantiateType(
-          type, new List<DartType>.filled(count, DynamicTypeImpl.instance));
+      var domain = defaults.keys.toList();
+      var range = defaults.values.toList();
+      // Build a substitution Phi mapping each uncompleted type variable to
+      // dynamic, and each completed type variable to its default.
+      for (TypeParameterType parameter in partials.keys) {
+        domain.add(parameter);
+        range.add(DynamicTypeImpl.instance);
+      }
+      // Set the default for an uncompleted type variable (T extends B)
+      // to be Phi(B)
+      for (TypeParameterType parameter in partials.keys) {
+        defaults[parameter] = partials[parameter].substitute2(range, domain);
+      }
     }
 
     List<DartType> orderedArguments =
         typeFormals.map((p) => defaults[p.type]).toList();
     return instantiateType(type, orderedArguments);
   }
 
   @override
   bool isAssignableTo(DartType fromType, DartType toType) {
     // TODO(leafp): Document the rules in play here
@@ skipping 1310 matching lines @@
       } else {
         passedOut = true;
       }
     } else if (type is FunctionType) {
       _visitFunctionType(typeParam, type, paramIn);
     } else if (type is InterfaceType) {
       _visitInterfaceType(typeParam, type, paramIn);
     }
   }
 }