Issue 28100. In strong mode verify that TypeParameter bound has required type arguments.

pkg/analyzer/lib/src/generated/error_verifier.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.generated.error_verifier;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 1205 matching lines @@
     return super.visitTypeName(node);
   }
 
   @override
   Object visitTypeParameter(TypeParameter node) {
     _checkForBuiltInIdentifierAsName(node.name,
         CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME);
     _checkForTypeParameterSupertypeOfItsBound(node);
     _checkForTypeAnnotationDeferredClass(node.bound);
     _checkForImplicitDynamicType(node.bound);
+    _checkForNotInstantiatedBound(node.bound);
     return super.visitTypeParameter(node);
   }
 
   @override
   Object visitTypeParameterList(TypeParameterList node) {
     _checkDuplicateDefinitionInTypeParameterList(node);
     return super.visitTypeParameterList(node);
   }
 
   @override
@@ skipping 3953 matching lines @@
   void _checkForNonVoidReturnTypeForSetter(TypeAnnotation typeName) {
     if (typeName != null) {
       DartType type = typeName.type;
       if (type != null && !type.isVoid) {
         _errorReporter.reportErrorForNode(
             StaticWarningCode.NON_VOID_RETURN_FOR_SETTER, typeName);
       }
     }
   }
 
+  void _checkForNotInstantiatedBound(TypeAnnotation node) {
+    if (!_options.strongMode ||
+        node == null ||
+        (node is TypeName && node.typeArguments != null)) {
+      return;
+    }
+    DartType type = node.type;
+    if (type is InterfaceType && type.element.typeParameters.isNotEmpty) {

[Leaf, 2017/01/20 01:43:16]

I don't think this handles nested types.  This perhaps should have been made
more clear in the proposal, but the intent with proposal 2 is that all types in
the bound need to be instantiated.  I think this check here still allows

class A<T extends List<List>> {}

[scheglov, 2017/01/20 15:36:26]

ACK.
https://codereview.chromium.org/2646983003 will fix this.

+      _errorReporter.reportErrorForNode(
+          StrongModeCode.NOT_INSTANTIATED_BOUND, node, [type]);
+    }
+  }
+
   /**
    * Verify the given operator-method [declaration], does not have an optional
    * parameter. This method assumes that the method declaration was tested to be
    * an operator declaration before being called.
    *
    * See [CompileTimeErrorCode.OPTIONAL_PARAMETER_IN_OPERATOR].
    */
   void _checkForOptionalParameterInOperator(MethodDeclaration declaration) {
     FormalParameterList parameterList = declaration.parameters;
     if (parameterList == null) {
@@ skipping 1829 matching lines @@
 class _InvocationCollector extends RecursiveAstVisitor {
   final List<String> superCalls = <String>[];
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     if (node.target is SuperExpression) {
       superCalls.add(node.methodName.name);
     }
   }
 }