New tests and improvements for generics in comments parsing.

pkg/analyzer/test/generated/strong_mode_test.dart

 // Copyright (c) 2016, 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.generated.strong_mode_test;
 
 import 'dart:async';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
@@ skipping 1485 matching lines @@
       void test8() {
         A<C<int>, String> a0 = new E("hello");
       }
       void test9() { // Check named and optional arguments
         A<int, String> a0 = new F(3, "hello", a: [3], b: ["hello"]);
         A<int, String> a1 = new F(3, "hello", a: ["hello"], b:[3]);
         A<int, String> a2 = new F.named(3, "hello", 3, "hello");
         A<int, String> a3 = new F.named(3, "hello");
         A<int, String> a4 = new F.named(3, "hello", "hello", 3);
         A<int, String> a5 = new F.named(3, "hello", "hello");
-      }
-    }''';
+      }''';
     CompilationUnit unit = await resolveSource(code);
 
     Expression rhs(VariableDeclarationStatement stmt) {
       VariableDeclaration decl = stmt.variables.variables[0];
       Expression exp = decl.initializer;
       return exp;
     }
 
     void hasType(Asserter<DartType> assertion, Expression exp) =>
         assertion(exp.staticType);
@@ skipping 342 matching lines @@
     assertMapOfIntToDynamic(literal(0));
     assertMapOfIntToDynamic(literal(1));
     assertMapOfIntToDynamic(literal(2));
     assertMapOfIntToDynamic(literal(3));
   }
 
   test_methodDeclaration_body_propagation() async {
     String code = r'''
       class A {
         List<String> m0(int x) => ["hello"];
-        List<String> m1(int x) {return [3];};
+        List<String> m1(int x) {return [3];}
       }
    ''';
     CompilationUnit unit = await resolveSource(code);
     Expression methodReturnValue(String methodName) {
       MethodDeclaration method =
           AstFinder.getMethodInClass(unit, "A", methodName);
       FunctionBody body = method.body;
       if (body is ExpressionFunctionBody) {
         return body.expression;
       } else {
@@ skipping 389 matching lines @@
     ExpressionFunctionBody body = test.functionExpression.body;
     MethodInvocation call = body.expression;
     _isNum(call.staticType);
     _isFunction2Of(_isFunction2Of(_isString, _isNum), _isNum)(
         call.staticInvokeType);
   }
 
   test_superConstructorInvocation_propagation() async {
     String code = r'''
       class B {
-        B(List<String>);
+        B(List<String> p);
       }
       class A extends B {
         A() : super([]);
       }
    ''';
     CompilationUnit unit = await resolveSource(code);
 
     ConstructorDeclaration constructor =
         AstFinder.getConstructorInClass(unit, "A", null);
     SuperConstructorInvocation invocation = constructor.initializers[0];
@@ skipping 1630 matching lines @@
   var v = x;
   v; // marker
 }
 int x = 3;
 ''';
     CompilationUnit unit = await resolveSource(code);
     assertPropagatedAssignedType(code, unit, typeProvider.intType, null);
     assertTypeOfMarkedExpression(code, unit, typeProvider.intType, null);
   }
 }