pkg/analyzer/test/generated/parser_test.dart - Issue 2342383002: Initial support for the NNBD proposal

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

Issue 2342383002: Initial support for the NNBD proposal (Closed)

Patch Set: Created 4 years, 3 months 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

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 7b58debec8136a8cd5a2e59322d93c608b6d9f4d..e81c5bb698b3c94f378682ffb5be8ccb281f0a28 100644

--- a/pkg/analyzer/test/generated/parser_test.dart

+++ b/pkg/analyzer/test/generated/parser_test.dart

@@ -346,6 +346,20 @@ class ComplexParserTest extends ParserTestCase {

BinaryExpression, expression.condition);

}

+ void test_conditionalExpression_precedence_nullableType() {

+ enableNnbd = true;

+ Expression expression = parseExpression('x is String ? (x + y) : z');

+ expect(expression, isNotNull);

+ expect(expression, new isInstanceOf<ConditionalExpression>());

+ ConditionalExpression conditional = expression;

+ Expression condition = conditional.condition;

+ expect(condition, new isInstanceOf<IsExpression>());

+ Expression thenExpression = conditional.thenExpression;

+ expect(thenExpression, new isInstanceOf<ParenthesizedExpression>());

+ Expression elseExpression = conditional.elseExpression;

+ expect(elseExpression, new isInstanceOf<SimpleIdentifier>());

+ }

void test_constructor_initializer_withParenthesizedExpression() {

CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''

class C {

@@ -2418,6 +2432,12 @@ class ParserTestCase extends EngineTestCase {

bool enableLazyAssignmentOperators = false;

/**

+ * A flag indicating whether the parser is to parse the non-nullable modifier

+ * in type names.

+ */

+ bool enableNnbd = 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

@@ -2473,6 +2493,7 @@ class ParserTestCase extends EngineTestCase {

parser.parseGenericMethods = enableGenericMethods;

parser.parseGenericMethodComments = enableGenericMethodComments;

parser.parseFunctionBodies = parseFunctionBodies;

+ parser.enableNnbd = enableNnbd;

Object result =

invokeParserMethodImpl(parser, methodName, objects, tokenStream);

@@ -2603,6 +2624,7 @@ class ParserTestCase extends EngineTestCase {

parser.parseFunctionBodies = parseFunctionBodies;

parser.parseGenericMethods = enableGenericMethods;

parser.parseGenericMethodComments = enableGenericMethodComments;

+ parser.enableNnbd = enableNnbd;

CompilationUnit unit = parser.parseCompilationUnit(token);

expect(unit, isNotNull);

listener.assertErrorsWithCodes(errorCodes);

@@ -2629,6 +2651,7 @@ class ParserTestCase extends EngineTestCase {

Parser parser = createParser(listener);

parser.parseGenericMethods = enableGenericMethods;

parser.parseGenericMethodComments = enableGenericMethodComments;

+ parser.enableNnbd = enableNnbd;

Expression expression = parser.parseExpression(token);

expect(expression, isNotNull);

listener.assertErrorsWithCodes(errorCodes);

@@ -9096,6 +9119,17 @@ void''');

expect(parameter.parameters, isNotNull);

}

+ void test_parseNormalFormalParameter_function_noType_nullable() {

+ enableNnbd = true;

+ FunctionTypedFormalParameter parameter =

+ parse4("parseNormalFormalParameter", "a()?)");

+ expect(parameter.returnType, isNull);

+ expect(parameter.identifier, isNotNull);

+ expect(parameter.typeParameters, isNull);

+ expect(parameter.parameters, isNotNull);

+ expect(parameter.question, isNotNull);

+ }

void test_parseNormalFormalParameter_function_noType_typeParameterComments() {

enableGenericMethodComments = true;

FunctionTypedFormalParameter parameter =

@@ -9114,6 +9148,21 @@ void''');

expect(parameter.identifier, isNotNull);

expect(parameter.typeParameters, isNotNull);

expect(parameter.parameters, isNotNull);

+ expect(parameter.question, isNull);

+ }

+ void

+ test_parseNormalFormalParameter_function_noType_typeParameters_nullable() {

+ enableGenericMethods = true;

+ enableNnbd = true;

+ FunctionTypedFormalParameter parameter =

+ parse4("parseNormalFormalParameter", "a<E>()?)");

+ expect(parameter.returnType, isNull);

+ expect(parameter.identifier, isNotNull);

+ expect(parameter.typeParameters, isNotNull);

+ expect(parameter.parameters, isNotNull);

+ expect(parameter.question, isNotNull);

}

void test_parseNormalFormalParameter_function_type() {

@@ -9123,6 +9172,18 @@ void''');

expect(parameter.identifier, isNotNull);

expect(parameter.typeParameters, isNull);

expect(parameter.parameters, isNotNull);

+ expect(parameter.question, isNull);

+ }

+ void test_parseNormalFormalParameter_function_type_nullable() {

+ enableNnbd = true;

+ FunctionTypedFormalParameter parameter =

+ parse4("parseNormalFormalParameter", "A a()?)");

+ expect(parameter.returnType, isNotNull);

+ expect(parameter.identifier, isNotNull);

+ expect(parameter.typeParameters, isNull);

+ expect(parameter.parameters, isNotNull);

+ expect(parameter.question, isNotNull);

}

void test_parseNormalFormalParameter_function_type_typeParameterComments() {

@@ -9133,6 +9194,7 @@ void''');

expect(parameter.identifier, isNotNull);

expect(parameter.typeParameters, isNotNull);

expect(parameter.parameters, isNotNull);

+ expect(parameter.question, isNull);

}

void test_parseNormalFormalParameter_function_type_typeParameters() {

@@ -9143,6 +9205,19 @@ void''');

expect(parameter.identifier, isNotNull);

expect(parameter.typeParameters, isNotNull);

expect(parameter.parameters, isNotNull);

+ expect(parameter.question, isNull);

+ }

+ void test_parseNormalFormalParameter_function_type_typeParameters_nullable() {

+ enableGenericMethods = true;

+ enableNnbd = true;

+ FunctionTypedFormalParameter parameter =

+ parse4("parseNormalFormalParameter", "A a<E>()?)");

+ expect(parameter.returnType, isNotNull);

+ expect(parameter.identifier, isNotNull);

+ expect(parameter.typeParameters, isNotNull);

+ expect(parameter.parameters, isNotNull);

+ expect(parameter.question, isNotNull);

}

void test_parseNormalFormalParameter_function_void() {

@@ -9152,6 +9227,18 @@ void''');

expect(parameter.identifier, isNotNull);

expect(parameter.typeParameters, isNull);

expect(parameter.parameters, isNotNull);

+ expect(parameter.question, isNull);

+ }

+ void test_parseNormalFormalParameter_function_void_nullable() {

+ enableNnbd = true;

+ FunctionTypedFormalParameter parameter =

+ parse4("parseNormalFormalParameter", "void a()?)");

+ expect(parameter.returnType, isNotNull);

+ expect(parameter.identifier, isNotNull);

+ expect(parameter.typeParameters, isNull);

+ expect(parameter.parameters, isNotNull);

+ expect(parameter.question, isNotNull);

}

void test_parseNormalFormalParameter_function_void_typeParameterComments() {

@@ -9162,6 +9249,7 @@ void''');

expect(parameter.identifier, isNotNull);

expect(parameter.typeParameters, isNotNull);

expect(parameter.parameters, isNotNull);

+ expect(parameter.question, isNull);

}

void test_parseNormalFormalParameter_function_void_typeParameters() {

@@ -9172,6 +9260,19 @@ void''');

expect(parameter.identifier, isNotNull);

expect(parameter.typeParameters, isNotNull);

expect(parameter.parameters, isNotNull);

+ expect(parameter.question, isNull);

+ }

+ void test_parseNormalFormalParameter_function_void_typeParameters_nullable() {

+ enableGenericMethods = true;

+ enableNnbd = true;

+ FunctionTypedFormalParameter parameter =

+ parse4("parseNormalFormalParameter", "void a<E>()?)");

+ expect(parameter.returnType, isNotNull);

+ expect(parameter.identifier, isNotNull);

+ expect(parameter.typeParameters, isNotNull);

+ expect(parameter.parameters, isNotNull);

+ expect(parameter.question, isNotNull);

}

void test_parseNormalFormalParameter_simple_const_noType() {

@@ -10374,12 +10475,26 @@ void''');

expect(typeName.typeArguments, isNotNull);

}

+ void test_parseTypeName_parameterized_nullable() {

+ enableNnbd = true;

+ TypeName typeName = parse4("parseTypeName", "List<int>?");

+ expect(typeName.name, isNotNull);

+ expect(typeName.typeArguments, isNotNull);

scheglov 2016/09/16 15:29:38 Should we check for "question"?

Brian Wilkerson 2016/09/16 15:47:35 Done

+ }

void test_parseTypeName_simple() {

TypeName typeName = parse4("parseTypeName", "int");

expect(typeName.name, isNotNull);

expect(typeName.typeArguments, isNull);

}

+ void test_parseTypeName_simple_nullable() {

+ enableNnbd = true;

+ TypeName typeName = parse4("parseTypeName", "String?");

+ expect(typeName.name, isNotNull);

+ expect(typeName.typeArguments, isNull);

scheglov 2016/09/16 15:29:39 Should we check for "question"? Do we need a test

Brian Wilkerson 2016/09/16 15:47:35 Done

+ }

void test_parseTypeParameter_bounded() {

TypeParameter parameter = parse4("parseTypeParameter", "A extends B");

expect(parameter.bound, isNotNull);

« pkg/analyzer/lib/src/generated/parser.dart ('K') | « pkg/analyzer/lib/src/generated/parser.dart ('k') | no next file » | no next file with comments »