Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(769)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: pkg/analyzer/test/generated/parser_test.dart

Issue 1434863003: initial generic method comment parsing (Closed) Base URL: git@github.com:dart-lang/sdk.git@master
Patch Set: Created 5 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« pkg/analyzer/lib/src/generated/scanner.dart ('K') | « pkg/analyzer/lib/src/generated/scanner.dart ('k') | pkg/analyzer/test/generated/scanner_test.dart » ('j') | pkg/analyzer/test/generated/scanner_test.dart » ('J')
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: pkg/analyzer/test/generated/parser_test.dart
diff --git a/pkg/analyzer/test/generated/parser_test.dart b/pkg/analyzer/test/generated/parser_test.dart
index 51e49416a3f3ff135984b366eafa3e9cab210d78..51b52bc1c5690705e68c89ac4440226e7f7153fb 100644
--- a/pkg/analyzer/test/generated/parser_test.dart
+++ b/pkg/analyzer/test/generated/parser_test.dart
@@ -204,6 +204,48 @@ class ComplexParserTest extends ParserTestCase {
expect(argumentList4.arguments, hasLength(1));
}
+ void test_assignableExpression_arguments_normal_chain_typeArgumentComments() {
+ enableGenericMethodComments = true;
+ PropertyAccess propertyAccess1 =
+ parseExpression("a/*<E>*/(b)/*<F>*/(c).d/*<G>*/(e).f");
+ expect(propertyAccess1.propertyName.name, "f");
+ //
+ // a<E>(b)<F>(c).d>G?(e)
Leaf 2015/11/11 21:04:05 Did something go wrong at the .d<G> in this commen
Jennifer Messerly 2015/11/11 21:45:31 it was like that in the test I copied from too. Fi
+ //
+ MethodInvocation invocation2 = EngineTestCase.assertInstanceOf(
+ (obj) => obj is MethodInvocation,
+ MethodInvocation,
+ propertyAccess1.target);
+ expect(invocation2.methodName.name, "d");
+ expect(invocation2.typeArguments, isNotNull);
+ ArgumentList argumentList2 = invocation2.argumentList;
+ expect(argumentList2, isNotNull);
+ expect(argumentList2.arguments, hasLength(1));
+ //
+ // a<E>(b)<F>(c)
+ //
+ FunctionExpressionInvocation invocation3 = EngineTestCase.assertInstanceOf(
+ (obj) => obj is FunctionExpressionInvocation,
+ FunctionExpressionInvocation,
+ invocation2.target);
+ expect(invocation3.typeArguments, isNotNull);
+ ArgumentList argumentList3 = invocation3.argumentList;
+ expect(argumentList3, isNotNull);
+ expect(argumentList3.arguments, hasLength(1));
+ //
+ // a(b)
+ //
+ MethodInvocation invocation4 = EngineTestCase.assertInstanceOf(
+ (obj) => obj is MethodInvocation,
+ MethodInvocation,
+ invocation3.function);
+ expect(invocation4.methodName.name, "a");
+ expect(invocation4.typeArguments, isNotNull);
+ ArgumentList argumentList4 = invocation4.argumentList;
+ expect(argumentList4, isNotNull);
+ expect(argumentList4.arguments, hasLength(1));
+ }
+
void test_assignableExpression_arguments_normal_chain_typeArguments() {
enableGenericMethods = true;
PropertyAccess propertyAccess1 = parseExpression("a<E>(b)<F>(c).d<G>(e).f");
@@ -2596,6 +2638,11 @@ class ParserTestCase extends EngineTestCase {
bool enableGenericMethods = false;
/**
+ * Whether generic method comments should be enabled for the test.
+ */
+ bool enableGenericMethodComments = false;
+
+ /**
* Return a CommentAndMetadata object with the given values that can be used for testing.
*
* @param comment the comment to be wrapped in the object
@@ -2638,6 +2685,7 @@ class ParserTestCase extends EngineTestCase {
//
Scanner scanner =
new Scanner(null, new CharSequenceReader(source), listener);
+ scanner.parseGenericMethodComments = enableGenericMethodComments;
Token tokenStream = scanner.tokenize();
listener.setLineInfo(new TestSource(), scanner.lineStarts);
//
@@ -2645,6 +2693,7 @@ class ParserTestCase extends EngineTestCase {
//
Parser parser = createParser(listener);
parser.parseGenericMethods = enableGenericMethods;
+ parser.parseGenericMethodComments = enableGenericMethodComments;
parser.parseFunctionBodies = parseFunctionBodies;
Object result =
invokeParserMethodImpl(parser, methodName, objects, tokenStream);
@@ -2772,10 +2821,12 @@ class ParserTestCase extends EngineTestCase {
GatheringErrorListener listener = new GatheringErrorListener();
Scanner scanner =
new Scanner(null, new CharSequenceReader(source), listener);
+ scanner.parseGenericMethodComments = enableGenericMethodComments;
listener.setLineInfo(new TestSource(), scanner.lineStarts);
Token token = scanner.tokenize();
Parser parser = createParser(listener);
parser.parseGenericMethods = enableGenericMethods;
+ parser.parseGenericMethodComments = enableGenericMethodComments;
Expression expression = parser.parseExpression(token);
expect(expression, isNotNull);
listener.assertErrorsWithCodes(errorCodes);
@@ -5110,6 +5161,21 @@ class SimpleParserTest extends ParserTestCase {
expect(propertyAccess.propertyName, isNotNull);
}
+ void test_parseAssignableExpression_expression_args_dot_typeParameterComments() {
+ enableGenericMethodComments = true;
+ PropertyAccess propertyAccess =
+ parse("parseAssignableExpression", <Object>[false], "(x)/*<F>*/(y).z");
+ FunctionExpressionInvocation invocation =
+ propertyAccess.target as FunctionExpressionInvocation;
+ expect(invocation.function, isNotNull);
+ expect(invocation.typeArguments, isNotNull);
+ ArgumentList argumentList = invocation.argumentList;
+ expect(argumentList, isNotNull);
+ expect(argumentList.arguments, hasLength(1));
+ expect(propertyAccess.operator, isNotNull);
+ expect(propertyAccess.propertyName, isNotNull);
+ }
+
void test_parseAssignableExpression_expression_args_dot_typeParameters() {
enableGenericMethods = true;
PropertyAccess propertyAccess =
@@ -5169,6 +5235,20 @@ class SimpleParserTest extends ParserTestCase {
expect(propertyAccess.propertyName, isNotNull);
}
+ void test_parseAssignableExpression_identifier_args_dot_typeParameterComments() {
+ enableGenericMethodComments = true;
+ PropertyAccess propertyAccess =
+ parse("parseAssignableExpression", <Object>[false], "x/*<E>*/(y).z");
+ MethodInvocation invocation = propertyAccess.target as MethodInvocation;
+ expect(invocation.methodName.name, "x");
+ expect(invocation.typeArguments, isNotNull);
+ ArgumentList argumentList = invocation.argumentList;
+ expect(argumentList, isNotNull);
+ expect(argumentList.arguments, hasLength(1));
+ expect(propertyAccess.operator, isNotNull);
+ expect(propertyAccess.propertyName, isNotNull);
+ }
+
void test_parseAssignableExpression_identifier_args_dot_typeParameters() {
enableGenericMethods = true;
PropertyAccess propertyAccess =
@@ -5391,6 +5471,16 @@ class SimpleParserTest extends ParserTestCase {
expect(section.argumentList, isNotNull);
}
+ void test_parseCascadeSection_ia_typeArgumentComments() {
+ enableGenericMethodComments = true;
+ FunctionExpressionInvocation section =
+ parse4("parseCascadeSection", "..[i]/*<E>*/(b)");
+ EngineTestCase.assertInstanceOf(
+ (obj) => obj is IndexExpression, IndexExpression, section.function);
+ expect(section.typeArguments, isNotNull);
+ expect(section.argumentList, isNotNull);
+ }
+
void test_parseCascadeSection_ia_typeArguments() {
enableGenericMethods = true;
FunctionExpressionInvocation section =
@@ -5412,6 +5502,19 @@ class SimpleParserTest extends ParserTestCase {
expect(section.argumentList.arguments, hasLength(1));
}
+ void test_parseCascadeSection_ii_typeArgumentComments() {
+ enableGenericMethodComments = true;
+ MethodInvocation section =
+ parse4("parseCascadeSection", "..a/*<E>*/(b).c/*<F>*/(d)");
+ EngineTestCase.assertInstanceOf(
+ (obj) => obj is MethodInvocation, MethodInvocation, section.target);
+ expect(section.operator, isNotNull);
+ expect(section.methodName, isNotNull);
+ expect(section.typeArguments, isNotNull);
+ expect(section.argumentList, isNotNull);
+ expect(section.argumentList.arguments, hasLength(1));
+ }
+
void test_parseCascadeSection_ii_typeArguments() {
enableGenericMethods = true;
MethodInvocation section =
@@ -5450,6 +5553,17 @@ class SimpleParserTest extends ParserTestCase {
(obj) => obj is IntegerLiteral, IntegerLiteral, rhs);
}
+ void test_parseCascadeSection_p_assign_withCascade_typeArgumentComments() {
+ enableGenericMethodComments = true;
+ AssignmentExpression section =
+ parse4("parseCascadeSection", "..a = 3..m/*<E>*/()");
+ expect(section.leftHandSide, isNotNull);
+ expect(section.operator, isNotNull);
+ Expression rhs = section.rightHandSide;
+ EngineTestCase.assertInstanceOf(
+ (obj) => obj is IntegerLiteral, IntegerLiteral, rhs);
+ }
+
void test_parseCascadeSection_p_assign_withCascade_typeArguments() {
enableGenericMethods = true;
AssignmentExpression section =
@@ -5478,6 +5592,17 @@ class SimpleParserTest extends ParserTestCase {
expect(section.argumentList.arguments, hasLength(1));
}
+ void test_parseCascadeSection_pa_typeArgumentComments() {
+ enableGenericMethodComments = true;
+ MethodInvocation section = parse4("parseCascadeSection", "..a/*<E>*/(b)");
+ expect(section.target, isNull);
+ expect(section.operator, isNotNull);
+ expect(section.methodName, isNotNull);
+ expect(section.typeArguments, isNotNull);
+ expect(section.argumentList, isNotNull);
+ expect(section.argumentList.arguments, hasLength(1));
+ }
+
void test_parseCascadeSection_pa_typeArguments() {
enableGenericMethods = true;
MethodInvocation section = parse4("parseCascadeSection", "..a<E>(b)");
@@ -5499,6 +5624,17 @@ class SimpleParserTest extends ParserTestCase {
expect(section.argumentList.arguments, hasLength(1));
}
+ void test_parseCascadeSection_paa_typeArgumentComments() {
+ enableGenericMethodComments = true;
+ FunctionExpressionInvocation section =
+ parse4("parseCascadeSection", "..a/*<E>*/(b)/*<F>*/(c)");
+ EngineTestCase.assertInstanceOf(
+ (obj) => obj is MethodInvocation, MethodInvocation, section.function);
+ expect(section.typeArguments, isNotNull);
+ expect(section.argumentList, isNotNull);
+ expect(section.argumentList.arguments, hasLength(1));
+ }
+
void test_parseCascadeSection_paa_typeArguments() {
enableGenericMethods = true;
FunctionExpressionInvocation section =
@@ -5520,6 +5656,17 @@ class SimpleParserTest extends ParserTestCase {
expect(section.argumentList.arguments, hasLength(1));
}
+ void test_parseCascadeSection_paapaa_typeArgumentComments() {
+ enableGenericMethodComments = true;
+ FunctionExpressionInvocation section = parse4(
+ "parseCascadeSection", "..a/*<E>*/(b)/*<F>*/(c).d/*<G>*/(e)/*<H>*/(f)");
+ EngineTestCase.assertInstanceOf(
+ (obj) => obj is MethodInvocation, MethodInvocation, section.function);
+ expect(section.typeArguments, isNotNull);
+ expect(section.argumentList, isNotNull);
+ expect(section.argumentList.arguments, hasLength(1));
+ }
+
void test_parseCascadeSection_paapaa_typeArguments() {
enableGenericMethods = true;
FunctionExpressionInvocation section =
@@ -5538,6 +5685,14 @@ class SimpleParserTest extends ParserTestCase {
expect(section.propertyName, isNotNull);
}
+ void test_parseCascadeSection_pap_typeArgumentComments() {
+ enableGenericMethodComments = true;
+ PropertyAccess section = parse4("parseCascadeSection", "..a/*<E>*/(b).c");
+ expect(section.target, isNotNull);
+ expect(section.operator, isNotNull);
+ expect(section.propertyName, isNotNull);
+ }
+
void test_parseCascadeSection_pap_typeArguments() {
enableGenericMethods = true;
PropertyAccess section = parse4("parseCascadeSection", "..a<E>(b).c");
@@ -5867,6 +6022,70 @@ class SimpleParserTest extends ParserTestCase {
expect(method.returnType, isNotNull);
}
+ void test_parseClassMember_method_generic_comment_noReturnType() {
+ enableGenericMethodComments = true;
+ MethodDeclaration method =
+ parse("parseClassMember", <Object>["C"], "m/*<T>*/() {}");
+ expect(method.documentationComment, isNull);
+ expect(method.externalKeyword, isNull);
+ expect(method.modifierKeyword, isNull);
+ expect(method.propertyKeyword, isNull);
+ expect(method.returnType, isNull);
+ expect(method.name, isNotNull);
+ expect(method.operatorKeyword, isNull);
+ expect(method.typeParameters, isNotNull);
+ expect(method.parameters, isNotNull);
+ expect(method.body, isNotNull);
+ }
+
+ void test_parseClassMember_method_generic_comment_returnType() {
+ enableGenericMethodComments = true;
+ MethodDeclaration method =
+ parse("parseClassMember", <Object>["C"], "dynamic/*=T*/ m/*<T>*/() {}");
+ expect(method.documentationComment, isNull);
+ expect(method.externalKeyword, isNull);
+ expect(method.modifierKeyword, isNull);
+ expect(method.propertyKeyword, isNull);
+ expect(method.returnType, isNotNull);
Leaf 2015/11/11 21:04:05 Maybe also expect(method.returnType.name.name, "T"
Jennifer Messerly 2015/11/11 21:45:31 yup, added in the latest. The /*=T*/ was actually
+ expect(method.name, isNotNull);
+ expect(method.operatorKeyword, isNull);
+ expect(method.typeParameters, isNotNull);
+ expect(method.parameters, isNotNull);
+ expect(method.body, isNotNull);
+ }
+
+ void test_parseClassMember_method_generic_comment_returnType_bound() {
+ enableGenericMethodComments = true;
+ MethodDeclaration method = parse("parseClassMember", <Object>["C"],
+ "num/*=T*/ m/*<T extends num>*/() {}");
+ expect(method.documentationComment, isNull);
+ expect(method.externalKeyword, isNull);
+ expect(method.modifierKeyword, isNull);
+ expect(method.propertyKeyword, isNull);
+ expect(method.returnType, isNotNull);
+ expect(method.name, isNotNull);
+ expect(method.operatorKeyword, isNull);
+ expect(method.typeParameters, isNotNull);
+ expect(method.parameters, isNotNull);
+ expect(method.body, isNotNull);
+ }
+
+ void test_parseClassMember_method_generic_comment_void() {
+ enableGenericMethodComments = true;
+ MethodDeclaration method =
+ parse("parseClassMember", <Object>["C"], "void m/*<T>*/() {}");
+ expect(method.documentationComment, isNull);
+ expect(method.externalKeyword, isNull);
+ expect(method.modifierKeyword, isNull);
+ expect(method.propertyKeyword, isNull);
+ expect(method.returnType, isNotNull);
+ expect(method.name, isNotNull);
+ expect(method.operatorKeyword, isNull);
+ expect(method.typeParameters, isNotNull);
+ expect(method.parameters, isNotNull);
+ expect(method.body, isNotNull);
+ }
+
void test_parseClassMember_method_generic_noReturnType() {
enableGenericMethods = true;
MethodDeclaration method =
@@ -7339,6 +7558,15 @@ void''');
expect(invocation.argumentList, isNotNull);
}
+ void test_parseExpression_superMethodInvocation_typeArgumentComments() {
+ enableGenericMethodComments = true;
+ MethodInvocation invocation = parse4("parseExpression", "super.m/*<E>*/()");
+ expect(invocation.target, isNotNull);
+ expect(invocation.methodName, isNotNull);
+ expect(invocation.typeArguments, isNotNull);
+ expect(invocation.argumentList, isNotNull);
+ }
+
void test_parseExpression_superMethodInvocation_typeArguments() {
enableGenericMethods = true;
MethodInvocation invocation = parse4("parseExpression", "super.m<E>()");
@@ -7386,6 +7614,16 @@ void''');
expect(invocation.argumentList, isNotNull);
}
+ void test_parseExpressionWithoutCascade_superMethodInvocation_typeArgumentComments() {
+ enableGenericMethodComments = true;
+ MethodInvocation invocation =
+ parse4("parseExpressionWithoutCascade", "super.m/*<E>*/()");
+ expect(invocation.target, isNotNull);
+ expect(invocation.methodName, isNotNull);
+ expect(invocation.typeArguments, isNotNull);
+ expect(invocation.argumentList, isNotNull);
+ }
+
void test_parseExpressionWithoutCascade_superMethodInvocation_typeArguments() {
enableGenericMethods = true;
MethodInvocation invocation =
@@ -8148,6 +8386,25 @@ void''');
expect(declaration.propertyKeyword, isNull);
}
+ void test_parseFunctionDeclaration_functionWithTypeParameters_comment() {
+ enableGenericMethodComments = true;
+ Comment comment = Comment.createDocumentationComment(new List<Token>(0));
+ TypeName returnType = new TypeName(new SimpleIdentifier(null), null);
+ FunctionDeclaration declaration = parse(
+ "parseFunctionDeclaration",
+ <Object>[commentAndMetadata(comment), null, returnType],
+ "f/*<E>*/() {}");
+ expect(declaration.documentationComment, comment);
+ expect(declaration.returnType, returnType);
+ expect(declaration.name, isNotNull);
+ FunctionExpression expression = declaration.functionExpression;
+ expect(expression, isNotNull);
+ expect(expression.body, isNotNull);
+ expect(expression.typeParameters, isNotNull);
+ expect(expression.parameters, isNotNull);
+ expect(declaration.propertyKeyword, isNull);
+ }
+
void test_parseFunctionDeclaration_getter() {
Comment comment = Comment.createDocumentationComment(new List<Token>(0));
TypeName returnType = new TypeName(new SimpleIdentifier(null), null);
@@ -8186,11 +8443,23 @@ void''');
expect(statement.functionDeclaration, isNotNull);
}
+ void test_parseFunctionDeclarationStatement_typeParameterComments() {
+ enableGenericMethodComments = true;
+ FunctionDeclarationStatement statement = parse4(
+ "parseFunctionDeclarationStatement",
+ "/*=E*/ f/*<E>*/(/*=E*/ p) => p * 2;");
+ expect(statement.functionDeclaration, isNotNull);
+ expect(statement.functionDeclaration.functionExpression.typeParameters,
+ isNotNull);
+ }
+
void test_parseFunctionDeclarationStatement_typeParameters() {
enableGenericMethods = true;
FunctionDeclarationStatement statement =
parse4("parseFunctionDeclarationStatement", "E f<E>(E p) => p * 2;");
expect(statement.functionDeclaration, isNotNull);
+ expect(statement.functionDeclaration.functionExpression.typeParameters,
+ isNotNull);
}
void test_parseFunctionExpression_body_inExpression() {
@@ -8202,6 +8471,16 @@ void''');
expect((expression.body as ExpressionFunctionBody).semicolon, isNull);
}
+ void test_parseFunctionExpression_typeParameterComments() {
+ enableGenericMethodComments = true;
+ FunctionExpression expression =
+ parse4("parseFunctionExpression", "/*<E>*/(/*=E*/ i) => i++");
+ expect(expression.body, isNotNull);
+ expect(expression.typeParameters, isNotNull);
+ expect(expression.parameters, isNotNull);
+ expect((expression.body as ExpressionFunctionBody).semicolon, isNull);
+ }
+
void test_parseFunctionExpression_typeParameters() {
enableGenericMethods = true;
FunctionExpression expression =
@@ -8951,6 +9230,16 @@ void''');
expect(parameter.parameters, isNotNull);
}
+ void test_parseNormalFormalParameter_function_noType_typeParameterComments() {
+ enableGenericMethodComments = true;
+ FunctionTypedFormalParameter parameter =
+ parse4("parseNormalFormalParameter", "a/*<E>*/())");
+ expect(parameter.returnType, isNull);
+ expect(parameter.identifier, isNotNull);
+ expect(parameter.typeParameters, isNotNull);
+ expect(parameter.parameters, isNotNull);
+ }
+
void test_parseNormalFormalParameter_function_noType_typeParameters() {
enableGenericMethods = true;
FunctionTypedFormalParameter parameter =
@@ -8970,6 +9259,16 @@ void''');
expect(parameter.parameters, isNotNull);
}
+ void test_parseNormalFormalParameter_function_type_typeParameterComments() {
+ enableGenericMethodComments = true;
+ FunctionTypedFormalParameter parameter =
+ parse4("parseNormalFormalParameter", "A a/*<E>*/())");
+ expect(parameter.returnType, isNotNull);
+ expect(parameter.identifier, isNotNull);
+ expect(parameter.typeParameters, isNotNull);
+ expect(parameter.parameters, isNotNull);
+ }
+
void test_parseNormalFormalParameter_function_type_typeParameters() {
enableGenericMethods = true;
FunctionTypedFormalParameter parameter =
@@ -8989,6 +9288,16 @@ void''');
expect(parameter.parameters, isNotNull);
}
+ void test_parseNormalFormalParameter_function_void_typeParameterComments() {
+ enableGenericMethodComments = true;
+ FunctionTypedFormalParameter parameter =
+ parse4("parseNormalFormalParameter", "void a/*<E>*/())");
+ expect(parameter.returnType, isNotNull);
+ expect(parameter.identifier, isNotNull);
+ expect(parameter.typeParameters, isNotNull);
+ expect(parameter.parameters, isNotNull);
+ }
+
void test_parseNormalFormalParameter_function_void_typeParameters() {
enableGenericMethods = true;
FunctionTypedFormalParameter parameter =
@@ -9125,6 +9434,17 @@ void''');
expect(expression.argumentList, isNotNull);
}
+ void test_parsePostfixExpression_none_methodInvocation_question_dot_typeArgumentComments() {
+ enableGenericMethodComments = true;
+ MethodInvocation expression =
+ parse4('parsePostfixExpression', 'a?.m/*<E>*/()');
+ expect(expression.target, isNotNull);
+ expect(expression.operator.type, TokenType.QUESTION_PERIOD);
+ expect(expression.methodName, isNotNull);
+ expect(expression.typeArguments, isNotNull);
+ expect(expression.argumentList, isNotNull);
+ }
+
void test_parsePostfixExpression_none_methodInvocation_question_dot_typeArguments() {
enableGenericMethods = true;
MethodInvocation expression = parse4('parsePostfixExpression', 'a?.m<E>()');
@@ -9135,6 +9455,17 @@ void''');
expect(expression.argumentList, isNotNull);
}
+ void test_parsePostfixExpression_none_methodInvocation_typeArgumentComments() {
+ enableGenericMethodComments = true;
+ MethodInvocation expression =
+ parse4("parsePostfixExpression", "a.m/*<E>*/()");
+ expect(expression.target, isNotNull);
+ expect(expression.operator.type, TokenType.PERIOD);
+ expect(expression.methodName, isNotNull);
+ expect(expression.typeArguments, isNotNull);
+ expect(expression.argumentList, isNotNull);
+ }
+
void test_parsePostfixExpression_none_methodInvocation_typeArguments() {
enableGenericMethods = true;
MethodInvocation expression = parse4("parsePostfixExpression", "a.m<E>()");
@@ -9488,8 +9819,19 @@ void''');
expect(statement.functionDeclaration, isNotNull);
}
+ void test_parseStatement_functionDeclaration_noReturnType_typeParameterComments() {
+ enableGenericMethodComments = true;
+ FunctionDeclarationStatement statement =
+ parse4("parseStatement", "f/*<E>*/(a, b) {};");
+ expect(statement.functionDeclaration, isNotNull);
+ expect(statement.functionDeclaration.functionExpression.typeParameters,
+ isNotNull);
+ }
+
void test_parseStatement_functionDeclaration_noReturnType_typeParameters() {
enableGenericMethods = true;
+ // TODO(jmesserly): is this a bug? it doesn't actually use type parameters,
Jennifer Messerly 2015/11/11 18:28:06 not sure if this existing test was broken or ...
Brian Wilkerson 2015/11/11 21:53:42 The implementation of the test certainly doesn't m
Jennifer Messerly 2015/11/12 00:20:00 Done
+ // and if I add them, it doesnt' work.
FunctionDeclarationStatement statement =
parse4("parseStatement", "f(a, b) {};");
expect(statement.functionDeclaration, isNotNull);
« pkg/analyzer/lib/src/generated/scanner.dart ('K') | « pkg/analyzer/lib/src/generated/scanner.dart ('k') | pkg/analyzer/test/generated/scanner_test.dart » ('j') | pkg/analyzer/test/generated/scanner_test.dart » ('J')

Powered by Google App Engine
This is Rietveld 408576698