Add an optional 'typeParameters' to Element.

pkg/analysis_server/test/analysis/notification_outline_test.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 test.analysis.notification.outline;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/constants.dart';
 import 'package:analysis_server/src/protocol.dart';
@@ skipping 42 matching lines @@
       return prepareOutline().then((_) {
         Outline unitOutline = outline;
         List<Outline> outlines = unitOutline.children;
         expect(outlines, hasLength(2));
       });
     });
   }
 
   test_class() {
     addTestFile('''
-class A {
+class A<K, V> {
   int fa, fb;
   String fc;
   A(int i, String s);
   A.name(num p);
   A._privateName(num p);
   static String ma(int pa) => null;
   _mb(int pb);
   String get propA => null;
   set propB(int v) {}
 }
 class B {
   B(int p);
 }");
 ''');
     return prepareOutline().then((_) {
       Outline unitOutline = outline;
       List<Outline> topOutlines = unitOutline.children;
       expect(topOutlines, hasLength(2));
       // A
       {
         Outline outline_A = topOutlines[0];
         Element element_A = outline_A.element;
         expect(element_A.kind, ElementKind.CLASS);
         expect(element_A.name, "A");
+        expect(element_A.typeParameters, "<K, V>");
         {
           Location location = element_A.location;
-          expect(location.offset, testCode.indexOf("A {"));
+          expect(location.offset, testCode.indexOf("A<K, V> {"));
           expect(location.length, 1);
         }
         expect(element_A.parameters, null);
         expect(element_A.returnType, null);
         // A children
         List<Outline> outlines_A = outline_A.children;
         expect(outlines_A, hasLength(10));
         {
           Outline outline = outlines_A[0];
           Element element = outline.element;
@@ skipping 119 matching lines @@
           expect(element.parameters, "(int v)");
           expect(element.returnType, "");
         }
       }
       // B
       {
         Outline outline_B = topOutlines[1];
         Element element_B = outline_B.element;
         expect(element_B.kind, ElementKind.CLASS);
         expect(element_B.name, "B");
+        expect(element_B.typeParameters, isNull);
         {
           Location location = element_B.location;
           expect(location.offset, testCode.indexOf("B {"));
           expect(location.length, 1);
         }
         expect(element_B.parameters, null);
         expect(element_B.returnType, null);
         // B children
         List<Outline> outlines_B = outline_B.children;
         expect(outlines_B, hasLength(1));
@@ skipping 430 matching lines @@
           int end = testCode.indexOf(" // marker2");
           expect(outline.offset, offset);
           expect(outline.length, end - offset);
         }
       }
     });
   }
 
   test_topLevel() {
     addTestFile('''
-typedef String FTA(int i, String s);
+typedef String FTA<K, V>(int i, String s);
 typedef FTB(int p);
-class A {}
+class A<T> {}
 class B {}
-class CTA = A with B;
+class CTA<T> = A<T> with B;
+class CTB = A with B;
 String fA(int i, String s) => null;
 fB(int p) => null;
 String get propA => null;
 set propB(int v) {}
 ''');
     return prepareOutline().then((_) {
       Outline unitOutline = outline;
       List<Outline> topOutlines = unitOutline.children;
-      expect(topOutlines, hasLength(9));
+      expect(topOutlines, hasLength(10));
       // FTA
       {
         Outline outline = topOutlines[0];
         Element element = outline.element;
         expect(element.kind, ElementKind.FUNCTION_TYPE_ALIAS);
         expect(element.name, "FTA");
+        expect(element.typeParameters, "<K, V>");
         {
           Location location = element.location;
-          expect(location.offset, testCode.indexOf("FTA("));
+          expect(location.offset, testCode.indexOf("FTA<K, V>("));
           expect(location.length, "FTA".length);
         }
         expect(element.parameters, "(int i, String s)");
         expect(element.returnType, "String");
       }
       // FTB
       {
         Outline outline = topOutlines[1];
         Element element = outline.element;
         expect(element.kind, ElementKind.FUNCTION_TYPE_ALIAS);
         expect(element.name, "FTB");
+        expect(element.typeParameters, isNull);
         {
           Location location = element.location;
           expect(location.offset, testCode.indexOf("FTB("));
           expect(location.length, "FTB".length);
         }
         expect(element.parameters, "(int p)");
         expect(element.returnType, "");
       }
       // CTA
       {
         Outline outline = topOutlines[4];
         Element element = outline.element;
         expect(element.kind, ElementKind.CLASS_TYPE_ALIAS);
         expect(element.name, "CTA");
+        expect(element.typeParameters, '<T>');
         {
           Location location = element.location;
-          expect(location.offset, testCode.indexOf("CTA ="));
+          expect(location.offset, testCode.indexOf("CTA<T> ="));
           expect(location.length, "CTA".length);
         }
         expect(element.parameters, isNull);
         expect(element.returnType, isNull);
       }
+      // CTB
+      {
+        Outline outline = topOutlines[5];
+        Element element = outline.element;
+        expect(element.kind, ElementKind.CLASS_TYPE_ALIAS);
+        expect(element.name, 'CTB');
+        expect(element.typeParameters, isNull);
+        expect(element.returnType, isNull);
+      }
       // fA
       {
-        Outline outline = topOutlines[5];
+        Outline outline = topOutlines[6];
         Element element = outline.element;
         expect(element.kind, ElementKind.FUNCTION);
         expect(element.name, "fA");
         {
           Location location = element.location;
           expect(location.offset, testCode.indexOf("fA("));
           expect(location.length, "fA".length);
         }
         expect(element.parameters, "(int i, String s)");
         expect(element.returnType, "String");
       }
       // fB
       {
-        Outline outline = topOutlines[6];
+        Outline outline = topOutlines[7];
         Element element = outline.element;
         expect(element.kind, ElementKind.FUNCTION);
         expect(element.name, "fB");
         {
           Location location = element.location;
           expect(location.offset, testCode.indexOf("fB("));
           expect(location.length, "fB".length);
         }
         expect(element.parameters, "(int p)");
         expect(element.returnType, "");
       }
       // propA
       {
-        Outline outline = topOutlines[7];
+        Outline outline = topOutlines[8];
         Element element = outline.element;
         expect(element.kind, ElementKind.GETTER);
         expect(element.name, "propA");
         {
           Location location = element.location;
           expect(location.offset, testCode.indexOf("propA => null;"));
           expect(location.length, "propA".length);
         }
         expect(element.parameters, "");
         expect(element.returnType, "String");
       }
       // propB
       {
-        Outline outline = topOutlines[8];
+        Outline outline = topOutlines[9];
         Element element = outline.element;
         expect(element.kind, ElementKind.SETTER);
         expect(element.name, "propB");
         {
           Location location = element.location;
           expect(location.offset, testCode.indexOf("propB(int v) {}"));
           expect(location.length, "propB".length);
         }
         expect(element.parameters, "(int v)");
         expect(element.returnType, "");
       }
     });
   }
 
   void _isEnumConstant(Outline outline, String name) {
     Element element = outline.element;
     expect(element.kind, ElementKind.ENUM_CONSTANT);
     expect(element.name, name);
     expect(element.parameters, isNull);
     expect(element.returnType, isNull);
   }
 }