Issue 21883. Add checks if type parameters can be used.

pkg/analysis_server/lib/src/services/correction/util.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 services.src.correction.util;
 
 import 'dart:math';
 
 import 'package:analysis_server/src/protocol.dart' show SourceChange,
     SourceEdit;
@@ skipping 516 matching lines @@
       return parent;
     }
   }
   return expression;
 }
 
 
 class CorrectionUtils {
   final CompilationUnit unit;
 
+  /**
+   * The [ClassElement] the generated code is inserted to, so we can decide if
+   * a type parameter may or may not be used.
+   */
+  ClassElement targetClassElement;
+
   LibraryElement _library;
   String _buffer;
   String _endOfLine;
 
   CorrectionUtils(this.unit) {
     CompilationUnitElement unitElement = unit.element;
     this._library = unitElement.library;
     this._buffer = unitElement.context.getContents(unitElement.source).data;
   }
 
@@ skipping 323 matching lines @@
     if (type == null || type.isDynamic) {
       return name;
     }
     // function type
     if (type is FunctionType) {
       FunctionType functionType = type;
       StringBuffer sb = new StringBuffer();
       // return type
       DartType returnType = functionType.returnType;
       if (returnType != null && !returnType.isDynamic) {
-        sb.write(getTypeSource(returnType, librariesToImport));
+        String returnTypeSource = getTypeSource(returnType, librariesToImport);
+        sb.write(returnTypeSource);
         sb.write(' ');
       }
       // parameter name
       sb.write(name);
       // parameters
       sb.write('(');
       List<ParameterElement> fParameters = functionType.parameters;
       for (int i = 0; i < fParameters.length; i++) {
         ParameterElement fParameter = fParameters[i];
         if (i != 0) {
@@ skipping 67 matching lines @@
       }
     }
     // append simple name
     String name = element.displayName;
     sb.write(name);
     // may be type arguments
     if (type is ParameterizedType) {
       List<DartType> arguments = type.typeArguments;
       // check if has arguments
       bool hasArguments = false;
+      bool allArgumentsVisible = true;
       for (DartType argument in arguments) {
-        if (!argument.isDynamic) {
-          hasArguments = true;
-          break;
-        }
+        hasArguments = hasArguments || !argument.isDynamic;
+        allArgumentsVisible = allArgumentsVisible && _isTypeVisible(argument);
       }
       // append type arguments
-      if (hasArguments) {
+      if (hasArguments && allArgumentsVisible) {
         sb.write("<");
         for (int i = 0; i < arguments.length; i++) {
           DartType argument = arguments[i];
           if (i != 0) {
             sb.write(", ");
           }
           String argumentSrc = getTypeSource(argument, librariesToImport);
           sb.write(argumentSrc);
         }
         sb.write(">");
       }
     }
     // done
     return sb.toString();
   }
 
   /**
+   * Checks if [type] is visible at [targetOffset].
+   */
+  bool _isTypeVisible(DartType type) {
+    // TODO(scheglov)

[Brian Wilkerson, 2014/12/15 23:29:15]

What's left to do?

+    if (type is TypeParameterType) {
+      TypeParameterElement parameterElement = type.element;
+      Element parameterClassElement = parameterElement.enclosingElement;
+      return identical(parameterClassElement, targetClassElement);
+    }
+    return true;
+  }
+
+  /**
    * Indents given source left or right.
    */
   String indentSourceLeftRight(String source, bool right) {
     StringBuffer sb = new StringBuffer();
     String indent = getIndent(1);
     String eol = endOfLine;
     List<String> lines = source.split(eol);
     for (int i = 0; i < lines.length; i++) {
       String line = lines[i];
       // last line, stop if empty
@@ skipping 447 matching lines @@
 
   @override
   Object visitExpression(Expression node) {
     if (node is BinaryExpression && node.operator.type == groupOperatorType) {
       return super.visitNode(node);
     }
     operands.add(node);
     return null;
   }
 }