Tests for generic functions in summaries.

pkg/analyzer/test/src/summary/summary_test.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.test.src.summary.summary_test;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
@@ skipping 133 matching lines @@
    * equivalent to that produced by [summarize_elements.serializeLibrary].
    */
   void verifyPublicNamespace() {
     for (int i = 0; i < unlinkedUnits.length; i++) {
       Source source = analysisContext.sourceFactory.forUri(unitUris[i]);
       String text = analysisContext.getContents(source).data;
       CharacterReader reader = new CharSequenceReader(text);
       Scanner scanner =
           new Scanner(source, reader, AnalysisErrorListener.NULL_LISTENER);
       Parser parser = new Parser(source, AnalysisErrorListener.NULL_LISTENER);
+      parser.parseGenericMethods = true;
       CompilationUnit unit = parser.parseCompilationUnit(scanner.tokenize());
       UnlinkedPublicNamespace namespace =
           new UnlinkedPublicNamespace.fromBuffer(public_namespace
               .computePublicNamespace(builderContext, unit)
               .toBuffer());
       expect(canonicalize(namespace),
           canonicalize(unlinkedUnits[i].publicNamespace),
           reason: 'publicNamespace(${unitUris[i]})');
     }
   }
@@ skipping 389 matching lines @@
 
   /**
    * Serialize a type declaration using the given [text] as a type name, and
    * return a summary of the corresponding [UnlinkedTypeRef].  If the type
    * declaration needs to refer to types that are not available in core, those
    * types may be declared in [otherDeclarations].
    */
   UnlinkedTypeRef serializeTypeText(String text,
       {String otherDeclarations: '', bool allowErrors: false}) {
     return serializeVariableText('$otherDeclarations\n$text v;',
-        allowErrors: allowErrors).type;
+            allowErrors: allowErrors)
+        .type;
   }
 
   /**
    * Serialize the given library [text] and return the summary of the variable
    * with the given [variableName].
    */
   UnlinkedVariable serializeVariableText(String text,
       {String variableName: 'v', bool allowErrors: false}) {
     serializeLibraryText(text, allowErrors: allowErrors);
     return findVariable(variableName, failIfAbsent: true);
@@ skipping 917 matching lines @@
     expect(executable.isConst, false);
     expect(executable.isFactory, false);
     expect(executable.isStatic, false);
     expect(executable.parameters, hasLength(1));
     checkTypeRef(executable.returnType, 'dart:core', 'dart:core', 'bool');
     expect(executable.typeParameters, isEmpty);
   }
 
   test_executable_operator_index_set() {
     UnlinkedExecutable executable = serializeClassText(
-        'class C { void operator[]=(int i, bool v) => null; }').executables[0];
+            'class C { void operator[]=(int i, bool v) => null; }')
+        .executables[0];
     expect(executable.kind, UnlinkedExecutableKind.functionOrMethod);
     expect(executable.name, '[]=');
     expect(executable.hasImplicitReturnType, false);
     expect(executable.isAbstract, false);
     expect(executable.isConst, false);
     expect(executable.isFactory, false);
     expect(executable.isStatic, false);
     expect(executable.parameters, hasLength(2));
     expect(executable.returnType, isNull);
     expect(executable.typeParameters, isEmpty);
@@ skipping 169 matching lines @@
     checkTypeRef(
         executable.parameters[0].type, 'dart:core', 'dart:core', 'int');
   }
 
   test_executable_static() {
     UnlinkedExecutable executable =
         serializeClassText('class C { static f() {} }').executables[0];
     expect(executable.isStatic, isTrue);
   }
 
-  test_executable_type_param_f_bound() {
-    // TODO(paulberry): also test top level executables.
+  test_executable_type_param_f_bound_function() {
+    UnlinkedExecutable ex =
+        serializeExecutableText('void f<T, U extends List<T>>() {}');
+    UnlinkedTypeRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
+    checkParamTypeRef(typeArgument, 2);
+  }
+
+  test_executable_type_param_f_bound_method() {
     UnlinkedExecutable ex =
         serializeMethodText('void f<T, U extends List<T>>() {}');
     UnlinkedTypeRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
     checkParamTypeRef(typeArgument, 2);
   }
 
-  test_executable_type_param_f_bound_self_ref() {
-    // TODO(paulberry): also test top level executables.
+  test_executable_type_param_f_bound_self_ref_function() {
+    UnlinkedExecutable ex =
+        serializeExecutableText('void f<T, U extends List<U>>() {}');
+    UnlinkedTypeRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
+    checkParamTypeRef(typeArgument, 1);
+  }
+
+  test_executable_type_param_f_bound_self_ref_method() {
     UnlinkedExecutable ex =
         serializeMethodText('void f<T, U extends List<U>>() {}');
     UnlinkedTypeRef typeArgument = ex.typeParameters[1].bound.typeArguments[0];
     checkParamTypeRef(typeArgument, 1);
   }
 
-  test_executable_type_param_in_parameter() {
-    // TODO(paulberry): also test top level executables.
+  test_executable_type_param_in_parameter_function() {
+    UnlinkedExecutable ex = serializeExecutableText('void f<T>(T t) {}');
+    checkParamTypeRef(ex.parameters[0].type, 1);
+  }
+
+  test_executable_type_param_in_parameter_method() {
     UnlinkedExecutable ex = serializeMethodText('void f<T>(T t) {}');
     checkParamTypeRef(ex.parameters[0].type, 1);
   }
 
-  test_executable_type_param_in_return_type() {
-    // TODO(paulberry): also test top level executables.
+  test_executable_type_param_in_return_type_function() {
+    UnlinkedExecutable ex = serializeExecutableText('T f<T>() => null;');
+    checkParamTypeRef(ex.returnType, 1);
+  }
+
+  test_executable_type_param_in_return_type_method() {
     UnlinkedExecutable ex = serializeMethodText('T f<T>() => null;');
     checkParamTypeRef(ex.returnType, 1);
   }
 
   test_export_hide_order() {
     serializeLibraryText('export "dart:async" hide Future, Stream;');
     expect(unlinkedUnits[0].publicNamespace.exports, hasLength(1));
     expect(
         unlinkedUnits[0].publicNamespace.exports[0].combinators, hasLength(1));
     expect(unlinkedUnits[0].publicNamespace.exports[0].combinators[0].shows,
@@ skipping 638 matching lines @@
     UnlinkedVariable variable =
         serializeVariableText('int i;', variableName: 'i');
     checkTypeRef(variable.type, 'dart:core', 'dart:core', 'int');
   }
 
   test_varible_private() {
     serializeVariableText('int _i;', variableName: '_i');
     expect(unlinkedUnits[0].publicNamespace.names, isEmpty);
   }
 }