| // Copyright (c) 2020, 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. | |
| import 'package:analyzer/src/dart/ast/ast.dart'; | |
| import 'package:test_reflective_loader/test_reflective_loader.dart'; | |
| import '../src/dart/resolution/node_text_expectations.dart'; | |
| import '../src/diagnostics/parser_diagnostics.dart'; | |
| main() { | |
| defineReflectiveSuite(() { | |
| defineReflectiveTests(ClassMemberParserTest); | |
| defineReflectiveTests(UpdateNodeTextExpectations); | |
| }); | |
| } | |
| /// Tests which exercise the parser using a class member. | |
| @reflectiveTest | |
| class ClassMemberParserTest extends ParserDiagnosticsTest { | |
| void parseClassMember_constructor_initializers_49132_helper( | |
| String content, { | |
| bool xIsNullable = false, | |
| bool yIsNullable = false, | |
| bool isVariation = false, | |
| }) { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| $content | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| '''); | |
| } | |
| void test_parse_member_called_late() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| void late() { | |
| new C().late(); | |
| } | |
| } | |
| '''); | |
| var node = parseResult.findNode.unit; | |
| assertParsedNodeText(node, r''' | |
| CompilationUnit | |
| declarations2 | |
| ClassDeclaration | |
| classKeyword: class | |
| namePart: NameWithTypeParameters | |
| typeName: C | |
| body: BlockClassBody | |
| leftBracket: { | |
| members | |
| MethodDeclaration | |
| returnType: NamedType | |
| name: void | |
| name: late | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| statements | |
| ExpressionStatement | |
| expression2: ParsedValueArguments | |
| operand: ParsedNameAccess | |
| operand: ConstructorInvocation | |
| keyword: new | |
| constructorReference: ConstructorReference2 | |
| typeReference: ConstructorTypeReference | |
| name: C | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| operator: . | |
| name: late | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| expression(v1): MethodInvocation | |
| target: InstanceCreationExpression | |
| keyword: new | |
| constructorName: ConstructorName | |
| type: NamedType | |
| name: C | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| operator: . | |
| methodName: SimpleIdentifier | |
| token: late | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| semicolon: ; | |
| rightBracket: } | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseAwaitExpression_asStatement_inAsync() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| m() async { | |
| await x; | |
| } | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| name: m | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| keyword: async | |
| block: Block | |
| leftBracket: { | |
| statements | |
| ExpressionStatement | |
| expression2: AwaitExpression | |
| awaitKeyword: await | |
| expression2: ParsedUnqualifiedName | |
| name: x | |
| expression(v1): SimpleIdentifier | |
| token: x | |
| semicolon: ; | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseAwaitExpression_asStatement_inSync() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| m() { | |
| await x; | |
| } | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| name: m | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| statements | |
| VariableDeclarationStatement | |
| variables: VariableDeclarationList | |
| type: NamedType | |
| name: await | |
| variables | |
| VariableDeclaration | |
| name: x | |
| semicolon: ; | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseAwaitExpression_inSync() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| m() { | |
| return await x + await y; | |
| // ^^^^^ | |
| // [diag.awaitInWrongContext] The await expression can only be used in an async function. | |
| // ^^^^^ | |
| // [diag.awaitInWrongContext] The await expression can only be used in an async function. | |
| } | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| name: m | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| statements | |
| ReturnStatement | |
| returnKeyword: return | |
| expression2: BinaryOperatorInvocation | |
| leftOperand: AwaitExpression | |
| awaitKeyword: await | |
| expression2: ParsedUnqualifiedName | |
| name: x | |
| expression(v1): SimpleIdentifier | |
| token: x | |
| operator: + | |
| rightOperand: AwaitExpression | |
| awaitKeyword: await | |
| expression2: ParsedUnqualifiedName | |
| name: y | |
| expression(v1): SimpleIdentifier | |
| token: y | |
| binaryOperator: add | |
| expression(v1): BinaryExpression | |
| leftOperand: AwaitExpression | |
| awaitKeyword: await | |
| expression: SimpleIdentifier | |
| token: x | |
| operator: + | |
| rightOperand: AwaitExpression | |
| awaitKeyword: await | |
| expression: SimpleIdentifier | |
| token: y | |
| semicolon: ; | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseAwaitExpression_inSync_v1_49116() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| m() { | |
| await returnsFuture(); | |
| // ^^^^^ | |
| // [diag.awaitInWrongContext] The await expression can only be used in an async function. | |
| } | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| name: m | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| statements | |
| ExpressionStatement | |
| expression2: AwaitExpression | |
| awaitKeyword: await | |
| expression2: ParsedValueArguments | |
| operand: ParsedUnqualifiedName | |
| name: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| expression(v1): MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| semicolon: ; | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseAwaitExpression_inSync_v2_49116() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| m() { | |
| if (await returnsFuture()) { | |
| // ^^^^^ | |
| // [diag.awaitInWrongContext] The await expression can only be used in an async function. | |
| } else if (!await returnsFuture()) {} | |
| // ^^^^^ | |
| // [diag.awaitInWrongContext] The await expression can only be used in an async function. | |
| } | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| name: m | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| statements | |
| IfStatement | |
| ifKeyword: if | |
| leftParenthesis: ( | |
| expression2: AwaitExpression | |
| awaitKeyword: await | |
| expression2: ParsedValueArguments | |
| operand: ParsedUnqualifiedName | |
| name: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| expression(v1): MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| rightParenthesis: ) | |
| thenStatement: Block | |
| leftBracket: { | |
| rightBracket: } | |
| elseKeyword: else | |
| elseStatement: IfStatement | |
| ifKeyword: if | |
| leftParenthesis: ( | |
| expression2: LogicalNot | |
| operator: ! | |
| operand: AwaitExpression | |
| awaitKeyword: await | |
| expression2: ParsedValueArguments | |
| operand: ParsedUnqualifiedName | |
| name: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| expression(v1): MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| expression(v1): PrefixExpression | |
| operator: ! | |
| operand: AwaitExpression | |
| awaitKeyword: await | |
| expression: MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| rightParenthesis: ) | |
| thenStatement: Block | |
| leftBracket: { | |
| rightBracket: } | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseAwaitExpression_inSync_v3_49116() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| m() { | |
| print(await returnsFuture()); | |
| // ^^^^^ | |
| // [diag.awaitInWrongContext] The await expression can only be used in an async function. | |
| } | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| name: m | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| statements | |
| ExpressionStatement | |
| expression2: ParsedValueArguments | |
| operand: ParsedUnqualifiedName | |
| name: print | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| arguments2 | |
| AwaitExpression | |
| awaitKeyword: await | |
| expression2: ParsedValueArguments | |
| operand: ParsedUnqualifiedName | |
| name: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| expression(v1): MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| rightParenthesis: ) | |
| expression(v1): MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: print | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| arguments | |
| AwaitExpression | |
| awaitKeyword: await | |
| expression: MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| rightParenthesis: ) | |
| semicolon: ; | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseAwaitExpression_inSync_v4_49116() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| m() { | |
| xor(await returnsFuture(), await returnsFuture(), await returnsFuture()); | |
| // ^^^^^ | |
| // [diag.awaitInWrongContext] The await expression can only be used in an async function. | |
| // ^^^^^ | |
| // [diag.awaitInWrongContext] The await expression can only be used in an async function. | |
| // ^^^^^ | |
| // [diag.awaitInWrongContext] The await expression can only be used in an async function. | |
| } | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| name: m | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| statements | |
| ExpressionStatement | |
| expression2: ParsedValueArguments | |
| operand: ParsedUnqualifiedName | |
| name: xor | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| arguments2 | |
| AwaitExpression | |
| awaitKeyword: await | |
| expression2: ParsedValueArguments | |
| operand: ParsedUnqualifiedName | |
| name: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| expression(v1): MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| AwaitExpression | |
| awaitKeyword: await | |
| expression2: ParsedValueArguments | |
| operand: ParsedUnqualifiedName | |
| name: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| expression(v1): MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| AwaitExpression | |
| awaitKeyword: await | |
| expression2: ParsedValueArguments | |
| operand: ParsedUnqualifiedName | |
| name: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| expression(v1): MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| rightParenthesis: ) | |
| expression(v1): MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: xor | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| arguments | |
| AwaitExpression | |
| awaitKeyword: await | |
| expression: MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| AwaitExpression | |
| awaitKeyword: await | |
| expression: MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| AwaitExpression | |
| awaitKeyword: await | |
| expression: MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| rightParenthesis: ) | |
| semicolon: ; | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseAwaitExpression_inSync_v5_49116() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| m() { | |
| await returnsFuture() ^ await returnsFuture(); | |
| // ^^^^^ | |
| // [diag.awaitInWrongContext] The await expression can only be used in an async function. | |
| // ^^^^^ | |
| // [diag.awaitInWrongContext] The await expression can only be used in an async function. | |
| } | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| name: m | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| statements | |
| ExpressionStatement | |
| expression2: BinaryOperatorInvocation | |
| leftOperand: AwaitExpression | |
| awaitKeyword: await | |
| expression2: ParsedValueArguments | |
| operand: ParsedUnqualifiedName | |
| name: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| expression(v1): MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| operator: ^ | |
| rightOperand: AwaitExpression | |
| awaitKeyword: await | |
| expression2: ParsedValueArguments | |
| operand: ParsedUnqualifiedName | |
| name: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| expression(v1): MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| binaryOperator: bitwiseXor | |
| expression(v1): BinaryExpression | |
| leftOperand: AwaitExpression | |
| awaitKeyword: await | |
| expression: MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| operator: ^ | |
| rightOperand: AwaitExpression | |
| awaitKeyword: await | |
| expression: MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| semicolon: ; | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseAwaitExpression_inSync_v6_49116() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| m() { | |
| print(await returnsFuture() ^ await returnsFuture()); | |
| // ^^^^^ | |
| // [diag.awaitInWrongContext] The await expression can only be used in an async function. | |
| // ^^^^^ | |
| // [diag.awaitInWrongContext] The await expression can only be used in an async function. | |
| } | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| name: m | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| statements | |
| ExpressionStatement | |
| expression2: ParsedValueArguments | |
| operand: ParsedUnqualifiedName | |
| name: print | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| arguments2 | |
| BinaryOperatorInvocation | |
| leftOperand: AwaitExpression | |
| awaitKeyword: await | |
| expression2: ParsedValueArguments | |
| operand: ParsedUnqualifiedName | |
| name: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| expression(v1): MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| operator: ^ | |
| rightOperand: AwaitExpression | |
| awaitKeyword: await | |
| expression2: ParsedValueArguments | |
| operand: ParsedUnqualifiedName | |
| name: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| expression(v1): MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| binaryOperator: bitwiseXor | |
| arguments(v1) | |
| BinaryExpression | |
| leftOperand: AwaitExpression | |
| awaitKeyword: await | |
| expression: MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| operator: ^ | |
| rightOperand: AwaitExpression | |
| awaitKeyword: await | |
| expression: MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| rightParenthesis: ) | |
| expression(v1): MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: print | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| arguments | |
| BinaryExpression | |
| leftOperand: AwaitExpression | |
| awaitKeyword: await | |
| expression: MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| operator: ^ | |
| rightOperand: AwaitExpression | |
| awaitKeyword: await | |
| expression: MethodInvocation | |
| methodName: SimpleIdentifier | |
| token: returnsFuture | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| rightParenthesis: ) | |
| semicolon: ; | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_constructor_initializers_conditional() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| Foo(dynamic a) : x = a is int ? {} : [] { /*body */ | |
| //^^^ | |
| // [diag.invalidConstructorName] The name of a constructor must match the name of the enclosing class. | |
| } | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| ConstructorDeclaration | |
| typeName2: Foo | |
| typeName(v1): SimpleIdentifier | |
| token: Foo | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: a | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: a | |
| rightParenthesis: ) | |
| separator: : | |
| initializers | |
| ConstructorFieldInitializer | |
| fieldName2: x | |
| fieldName(v1): SimpleIdentifier | |
| token: x | |
| equals: = | |
| expression2: ConditionalExpression | |
| condition2: IsExpression | |
| expression2: ParsedUnqualifiedName | |
| name: a | |
| expression(v1): SimpleIdentifier | |
| token: a | |
| isOperator: is | |
| type: NamedType | |
| name: int | |
| question: ? | |
| thenExpression2: SetOrMapLiteral | |
| leftBracket: { | |
| rightBracket: } | |
| isMap: false | |
| colon: : | |
| elseExpression2: ListLiteral | |
| leftBracket: [ | |
| rightBracket: ] | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_constructor_initializers_is_nullable_v1_49132() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| Foo(dynamic a, dynamic b) : x = a is int, y = b is int?; | |
| // ^ | |
| // [diag.missingFunctionBody] A function body must be provided. | |
| // [diag.expectedExecutable] Expected a method, getter, setter or operator declaration. | |
| // ^ | |
| // [diag.missingConstFinalVarOrType] Variables must be declared using the keywords 'const', 'final', 'var' or a type name. | |
| '''); | |
| var node = parseResult.findNode.unit; | |
| assertParsedNodeText(node, r''' | |
| CompilationUnit | |
| declarations2 | |
| FunctionDeclaration | |
| name: Foo | |
| functionExpression: FunctionExpression | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: a | |
| RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: b | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: a | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: b | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { <synthetic> | |
| rightBracket: } <synthetic> | |
| TopLevelVariableDeclaration | |
| variables: VariableDeclarationList | |
| variables | |
| VariableDeclaration | |
| name: x | |
| equals: = | |
| initializer2: IsExpression | |
| expression2: ParsedUnqualifiedName | |
| name: a | |
| expression(v1): SimpleIdentifier | |
| token: a | |
| isOperator: is | |
| type: NamedType | |
| name: int | |
| VariableDeclaration | |
| name: y | |
| equals: = | |
| initializer2: IsExpression | |
| expression2: ParsedUnqualifiedName | |
| name: b | |
| expression(v1): SimpleIdentifier | |
| token: b | |
| isOperator: is | |
| type: NamedType | |
| name: int | |
| question: ? | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_constructor_initializers_is_nullable_v2_49132() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| Foo(dynamic a, dynamic b) : x = a is int?, y = b is int; | |
| // ^ | |
| // [diag.missingFunctionBody] A function body must be provided. | |
| // [diag.expectedExecutable] Expected a method, getter, setter or operator declaration. | |
| // ^ | |
| // [diag.missingConstFinalVarOrType] Variables must be declared using the keywords 'const', 'final', 'var' or a type name. | |
| '''); | |
| var node = parseResult.findNode.unit; | |
| assertParsedNodeText(node, r''' | |
| CompilationUnit | |
| declarations2 | |
| FunctionDeclaration | |
| name: Foo | |
| functionExpression: FunctionExpression | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: a | |
| RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: b | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: a | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: b | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { <synthetic> | |
| rightBracket: } <synthetic> | |
| TopLevelVariableDeclaration | |
| variables: VariableDeclarationList | |
| variables | |
| VariableDeclaration | |
| name: x | |
| equals: = | |
| initializer2: IsExpression | |
| expression2: ParsedUnqualifiedName | |
| name: a | |
| expression(v1): SimpleIdentifier | |
| token: a | |
| isOperator: is | |
| type: NamedType | |
| name: int | |
| question: ? | |
| VariableDeclaration | |
| name: y | |
| equals: = | |
| initializer2: IsExpression | |
| expression2: ParsedUnqualifiedName | |
| name: b | |
| expression(v1): SimpleIdentifier | |
| token: b | |
| isOperator: is | |
| type: NamedType | |
| name: int | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_constructor_initializers_is_nullable_v3_49132() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| Foo(dynamic a, dynamic b) : x = a is int, y = b is int? {} | |
| // ^ | |
| // [diag.missingFunctionBody] A function body must be provided. | |
| // [diag.expectedExecutable] Expected a method, getter, setter or operator declaration. | |
| // ^ | |
| // [diag.missingConstFinalVarOrType] Variables must be declared using the keywords 'const', 'final', 'var' or a type name. | |
| // ^ | |
| // [diag.expectedToken] Expected to find ';'. | |
| // ^ | |
| // [diag.expectedExecutable] Expected a method, getter, setter or operator declaration. | |
| '''); | |
| var node = parseResult.findNode.unit; | |
| assertParsedNodeText(node, r''' | |
| CompilationUnit | |
| declarations2 | |
| FunctionDeclaration | |
| name: Foo | |
| functionExpression: FunctionExpression | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: a | |
| RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: b | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: a | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: b | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { <synthetic> | |
| rightBracket: } <synthetic> | |
| TopLevelVariableDeclaration | |
| variables: VariableDeclarationList | |
| variables | |
| VariableDeclaration | |
| name: x | |
| equals: = | |
| initializer2: IsExpression | |
| expression2: ParsedUnqualifiedName | |
| name: a | |
| expression(v1): SimpleIdentifier | |
| token: a | |
| isOperator: is | |
| type: NamedType | |
| name: int | |
| VariableDeclaration | |
| name: y | |
| equals: = | |
| initializer2: IsExpression | |
| expression2: ParsedUnqualifiedName | |
| name: b | |
| expression(v1): SimpleIdentifier | |
| token: b | |
| isOperator: is | |
| type: NamedType | |
| name: int | |
| question: ? | |
| semicolon: ; <synthetic> | |
| '''); | |
| } | |
| void test_parseClassMember_constructor_initializers_is_nullable_v4_49132() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| Foo(dynamic a, dynamic b) : x = a is int?, y = b is int {} | |
| // ^ | |
| // [diag.missingFunctionBody] A function body must be provided. | |
| // [diag.expectedExecutable] Expected a method, getter, setter or operator declaration. | |
| // ^ | |
| // [diag.missingConstFinalVarOrType] Variables must be declared using the keywords 'const', 'final', 'var' or a type name. | |
| // ^^^ | |
| // [diag.expectedToken] Expected to find ';'. | |
| // ^ | |
| // [diag.expectedExecutable] Expected a method, getter, setter or operator declaration. | |
| '''); | |
| var node = parseResult.findNode.unit; | |
| assertParsedNodeText(node, r''' | |
| CompilationUnit | |
| declarations2 | |
| FunctionDeclaration | |
| name: Foo | |
| functionExpression: FunctionExpression | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: a | |
| RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: b | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: a | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: b | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { <synthetic> | |
| rightBracket: } <synthetic> | |
| TopLevelVariableDeclaration | |
| variables: VariableDeclarationList | |
| variables | |
| VariableDeclaration | |
| name: x | |
| equals: = | |
| initializer2: IsExpression | |
| expression2: ParsedUnqualifiedName | |
| name: a | |
| expression(v1): SimpleIdentifier | |
| token: a | |
| isOperator: is | |
| type: NamedType | |
| name: int | |
| question: ? | |
| VariableDeclaration | |
| name: y | |
| equals: = | |
| initializer2: IsExpression | |
| expression2: ParsedUnqualifiedName | |
| name: b | |
| expression(v1): SimpleIdentifier | |
| token: b | |
| isOperator: is | |
| type: NamedType | |
| name: int | |
| semicolon: ; <synthetic> | |
| '''); | |
| } | |
| void test_parseClassMember_constructor_initializers_nullable_cast_v1_49132() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| Foo(dynamic a, dynamic b) : x = a as int, y = b as int?; | |
| // ^ | |
| // [diag.missingFunctionBody] A function body must be provided. | |
| // [diag.expectedExecutable] Expected a method, getter, setter or operator declaration. | |
| // ^ | |
| // [diag.missingConstFinalVarOrType] Variables must be declared using the keywords 'const', 'final', 'var' or a type name. | |
| '''); | |
| var node = parseResult.findNode.unit; | |
| assertParsedNodeText(node, r''' | |
| CompilationUnit | |
| declarations2 | |
| FunctionDeclaration | |
| name: Foo | |
| functionExpression: FunctionExpression | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: a | |
| RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: b | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: a | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: b | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { <synthetic> | |
| rightBracket: } <synthetic> | |
| TopLevelVariableDeclaration | |
| variables: VariableDeclarationList | |
| variables | |
| VariableDeclaration | |
| name: x | |
| equals: = | |
| initializer2: AsExpression | |
| expression2: ParsedUnqualifiedName | |
| name: a | |
| expression(v1): SimpleIdentifier | |
| token: a | |
| asOperator: as | |
| type: NamedType | |
| name: int | |
| VariableDeclaration | |
| name: y | |
| equals: = | |
| initializer2: AsExpression | |
| expression2: ParsedUnqualifiedName | |
| name: b | |
| expression(v1): SimpleIdentifier | |
| token: b | |
| asOperator: as | |
| type: NamedType | |
| name: int | |
| question: ? | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_constructor_initializers_nullable_cast_v2_49132() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| Foo(dynamic a, dynamic b) : x = a as int?, y = b as int; | |
| // ^ | |
| // [diag.missingFunctionBody] A function body must be provided. | |
| // [diag.expectedExecutable] Expected a method, getter, setter or operator declaration. | |
| // ^ | |
| // [diag.missingConstFinalVarOrType] Variables must be declared using the keywords 'const', 'final', 'var' or a type name. | |
| '''); | |
| var node = parseResult.findNode.unit; | |
| assertParsedNodeText(node, r''' | |
| CompilationUnit | |
| declarations2 | |
| FunctionDeclaration | |
| name: Foo | |
| functionExpression: FunctionExpression | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: a | |
| RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: b | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: a | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: b | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { <synthetic> | |
| rightBracket: } <synthetic> | |
| TopLevelVariableDeclaration | |
| variables: VariableDeclarationList | |
| variables | |
| VariableDeclaration | |
| name: x | |
| equals: = | |
| initializer2: AsExpression | |
| expression2: ParsedUnqualifiedName | |
| name: a | |
| expression(v1): SimpleIdentifier | |
| token: a | |
| asOperator: as | |
| type: NamedType | |
| name: int | |
| question: ? | |
| VariableDeclaration | |
| name: y | |
| equals: = | |
| initializer2: AsExpression | |
| expression2: ParsedUnqualifiedName | |
| name: b | |
| expression(v1): SimpleIdentifier | |
| token: b | |
| asOperator: as | |
| type: NamedType | |
| name: int | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_constructor_initializers_nullable_cast_v3_49132() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| Foo(dynamic a, dynamic b) : x = a as int, y = b as int? {} | |
| // ^ | |
| // [diag.missingFunctionBody] A function body must be provided. | |
| // [diag.expectedExecutable] Expected a method, getter, setter or operator declaration. | |
| // ^ | |
| // [diag.missingConstFinalVarOrType] Variables must be declared using the keywords 'const', 'final', 'var' or a type name. | |
| // ^ | |
| // [diag.expectedToken] Expected to find ';'. | |
| // ^ | |
| // [diag.expectedExecutable] Expected a method, getter, setter or operator declaration. | |
| '''); | |
| var node = parseResult.findNode.unit; | |
| assertParsedNodeText(node, r''' | |
| CompilationUnit | |
| declarations2 | |
| FunctionDeclaration | |
| name: Foo | |
| functionExpression: FunctionExpression | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: a | |
| RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: b | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: a | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: b | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { <synthetic> | |
| rightBracket: } <synthetic> | |
| TopLevelVariableDeclaration | |
| variables: VariableDeclarationList | |
| variables | |
| VariableDeclaration | |
| name: x | |
| equals: = | |
| initializer2: AsExpression | |
| expression2: ParsedUnqualifiedName | |
| name: a | |
| expression(v1): SimpleIdentifier | |
| token: a | |
| asOperator: as | |
| type: NamedType | |
| name: int | |
| VariableDeclaration | |
| name: y | |
| equals: = | |
| initializer2: AsExpression | |
| expression2: ParsedUnqualifiedName | |
| name: b | |
| expression(v1): SimpleIdentifier | |
| token: b | |
| asOperator: as | |
| type: NamedType | |
| name: int | |
| question: ? | |
| semicolon: ; <synthetic> | |
| '''); | |
| } | |
| void test_parseClassMember_constructor_initializers_nullable_cast_v4_49132() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| Foo(dynamic a, dynamic b) : x = a as int?, y = b as int {} | |
| // ^ | |
| // [diag.missingFunctionBody] A function body must be provided. | |
| // [diag.expectedExecutable] Expected a method, getter, setter or operator declaration. | |
| // ^ | |
| // [diag.missingConstFinalVarOrType] Variables must be declared using the keywords 'const', 'final', 'var' or a type name. | |
| // ^^^ | |
| // [diag.expectedToken] Expected to find ';'. | |
| // ^ | |
| // [diag.expectedExecutable] Expected a method, getter, setter or operator declaration. | |
| '''); | |
| var node = parseResult.findNode.unit; | |
| assertParsedNodeText(node, r''' | |
| CompilationUnit | |
| declarations2 | |
| FunctionDeclaration | |
| name: Foo | |
| functionExpression: FunctionExpression | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: a | |
| RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: b | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: a | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: dynamic | |
| name: b | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { <synthetic> | |
| rightBracket: } <synthetic> | |
| TopLevelVariableDeclaration | |
| variables: VariableDeclarationList | |
| variables | |
| VariableDeclaration | |
| name: x | |
| equals: = | |
| initializer2: AsExpression | |
| expression2: ParsedUnqualifiedName | |
| name: a | |
| expression(v1): SimpleIdentifier | |
| token: a | |
| asOperator: as | |
| type: NamedType | |
| name: int | |
| question: ? | |
| VariableDeclaration | |
| name: y | |
| equals: = | |
| initializer2: AsExpression | |
| expression2: ParsedUnqualifiedName | |
| name: b | |
| expression(v1): SimpleIdentifier | |
| token: b | |
| asOperator: as | |
| type: NamedType | |
| name: int | |
| semicolon: ; <synthetic> | |
| '''); | |
| } | |
| void test_parseClassMember_constructor_withDocComment() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| /// Doc | |
| C(); | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| ConstructorDeclaration | |
| documentationComment: Comment | |
| tokens | |
| /// Doc | |
| typeName2: C | |
| typeName(v1): SimpleIdentifier | |
| token: C | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: EmptyFunctionBody | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_constructor_withInitializers() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| C(_, _$, this.__) : _a = _ + _$ {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| ConstructorDeclaration | |
| typeName2: C | |
| typeName(v1): SimpleIdentifier | |
| token: C | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| name: _ | |
| RegularFormalParameter | |
| name: _$ | |
| FieldFormalParameter | |
| thisKeyword: this | |
| period: . | |
| name: __ | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| name: _ | |
| parameter: RegularFormalParameter | |
| name: _$ | |
| parameter: FieldFormalParameter | |
| thisKeyword: this | |
| period: . | |
| name: __ | |
| rightParenthesis: ) | |
| separator: : | |
| initializers | |
| ConstructorFieldInitializer | |
| fieldName2: _a | |
| fieldName(v1): SimpleIdentifier | |
| token: _a | |
| equals: = | |
| expression2: BinaryOperatorInvocation | |
| leftOperand: ParsedUnqualifiedName | |
| name: _ | |
| operator: + | |
| rightOperand: ParsedUnqualifiedName | |
| name: _$ | |
| binaryOperator: add | |
| expression(v1): BinaryExpression | |
| leftOperand: SimpleIdentifier | |
| token: _ | |
| operator: + | |
| rightOperand: SimpleIdentifier | |
| token: _$ | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_field_covariant() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| covariant T f; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| covariantKeyword: covariant | |
| fields: VariableDeclarationList | |
| type: NamedType | |
| name: T | |
| variables | |
| VariableDeclaration | |
| name: f | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_field_generic() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| List<List<N>> _allComponents = new List<List<N>>.empty(); | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| fields: VariableDeclarationList | |
| type: NamedType | |
| name: List | |
| typeArguments: TypeArgumentList | |
| leftBracket: < | |
| arguments | |
| NamedType | |
| name: List | |
| typeArguments: TypeArgumentList | |
| leftBracket: < | |
| arguments | |
| NamedType | |
| name: N | |
| rightBracket: > | |
| rightBracket: > | |
| variables | |
| VariableDeclaration | |
| name: _allComponents | |
| equals: = | |
| initializer2: ConstructorInvocation | |
| keyword: new | |
| constructorReference: ConstructorReference2 | |
| typeReference: ConstructorTypeReference | |
| name: List | |
| typeArguments: TypeArgumentList | |
| leftBracket: < | |
| arguments | |
| NamedType | |
| name: List | |
| typeArguments: TypeArgumentList | |
| leftBracket: < | |
| arguments | |
| NamedType | |
| name: N | |
| rightBracket: > | |
| rightBracket: > | |
| selector: ConstructorSelector | |
| period: . | |
| name2: empty | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| initializer(v1): InstanceCreationExpression | |
| keyword: new | |
| constructorName: ConstructorName | |
| type: NamedType | |
| name: List | |
| typeArguments: TypeArgumentList | |
| leftBracket: < | |
| arguments | |
| NamedType | |
| name: List | |
| typeArguments: TypeArgumentList | |
| leftBracket: < | |
| arguments | |
| NamedType | |
| name: N | |
| rightBracket: > | |
| rightBracket: > | |
| period: . | |
| name: SimpleIdentifier | |
| token: empty | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_field_gftType_gftReturnType() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| Function(int) Function(String) v; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| fields: VariableDeclarationList | |
| type: GenericFunctionType | |
| returnType: GenericFunctionType | |
| functionKeyword: Function | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| name: int | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: int | |
| rightParenthesis: ) | |
| functionKeyword: Function | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| name: String | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: String | |
| rightParenthesis: ) | |
| variables | |
| VariableDeclaration | |
| name: v | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_field_gftType_noReturnType() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| Function(int, String) v; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| fields: VariableDeclarationList | |
| type: GenericFunctionType | |
| functionKeyword: Function | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| name: int | |
| RegularFormalParameter | |
| type: NamedType | |
| name: String | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: int | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: String | |
| rightParenthesis: ) | |
| variables | |
| VariableDeclaration | |
| name: v | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_field_instance_prefixedType() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| p.A f; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| fields: VariableDeclarationList | |
| type: NamedType | |
| importPrefix: ImportPrefixReference | |
| name: p | |
| period: . | |
| name: A | |
| variables | |
| VariableDeclaration | |
| name: f | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_field_namedGet() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| var get; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| fields: VariableDeclarationList | |
| keyword: var | |
| variables | |
| VariableDeclaration | |
| name: get | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_field_namedOperator() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| var operator; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| fields: VariableDeclarationList | |
| keyword: var | |
| variables | |
| VariableDeclaration | |
| name: operator | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_field_namedOperator_withAssignment() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| var operator = (5); | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| fields: VariableDeclarationList | |
| keyword: var | |
| variables | |
| VariableDeclaration | |
| name: operator | |
| equals: = | |
| initializer2: ParenthesizedExpression | |
| leftParenthesis: ( | |
| expression2: IntegerLiteral | |
| literal: 5 | |
| rightParenthesis: ) | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_field_namedSet() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| var set; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| fields: VariableDeclarationList | |
| keyword: var | |
| variables | |
| VariableDeclaration | |
| name: set | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_field_nameKeyword() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| var for; | |
| // ^^^ | |
| // [diag.expectedIdentifierButGotKeyword] 'for' can't be used as an identifier because it's a keyword. | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| fields: VariableDeclarationList | |
| keyword: var | |
| variables | |
| VariableDeclaration | |
| name: for | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_field_nameMissing() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| var ; | |
| // ^ | |
| // [diag.missingIdentifier] Expected an identifier. | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| fields: VariableDeclarationList | |
| keyword: var | |
| variables | |
| VariableDeclaration | |
| name: <empty> <synthetic> | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_field_nameMissing2() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| var ""; | |
| // ^^ | |
| // [diag.missingIdentifier] Expected an identifier. | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| fields: VariableDeclarationList | |
| keyword: var | |
| variables | |
| VariableDeclaration | |
| name: <empty> <synthetic> | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_field_static() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| static A f; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| staticKeyword: static | |
| fields: VariableDeclarationList | |
| type: NamedType | |
| name: A | |
| variables | |
| VariableDeclaration | |
| name: f | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_finalAndCovariantLateWithInitializer() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| covariant late final int f = 0; | |
| //^^^^^^^^^ | |
| // [diag.finalAndCovariantLateWithInitializer] Members marked 'late' with an initializer can't be declared to be both 'final' and 'covariant'. | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| fields: VariableDeclarationList | |
| lateKeyword: late | |
| keyword: final | |
| type: NamedType | |
| name: int | |
| variables | |
| VariableDeclaration | |
| name: f | |
| equals: = | |
| initializer2: IntegerLiteral | |
| literal: 0 | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_getter_functionType() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| int Function(int) get g {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: GenericFunctionType | |
| returnType: NamedType | |
| name: int | |
| functionKeyword: Function | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| name: int | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: int | |
| rightParenthesis: ) | |
| propertyKeyword: get | |
| name: g | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_getter_void() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| void get g {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: NamedType | |
| name: void | |
| propertyKeyword: get | |
| name: g | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_method_external() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| external m(); | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| externalKeyword: external | |
| name: m | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: EmptyFunctionBody | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_method_external_withTypeAndArgs() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| external int m(int a); | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| externalKeyword: external | |
| returnType: NamedType | |
| name: int | |
| name: m | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| name: int | |
| name: a | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: int | |
| name: a | |
| rightParenthesis: ) | |
| body: EmptyFunctionBody | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_method_generic_noReturnType() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| m<T>() {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| name: m | |
| typeParameters: TypeParameterList | |
| leftBracket: < | |
| typeParameters | |
| TypeParameter | |
| name: T | |
| rightBracket: > | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_method_generic_parameterType() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| m<T>(T p) => null; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| name: m | |
| typeParameters: TypeParameterList | |
| leftBracket: < | |
| typeParameters | |
| TypeParameter | |
| name: T | |
| rightBracket: > | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| name: T | |
| name: p | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: T | |
| name: p | |
| rightParenthesis: ) | |
| body: ExpressionFunctionBody | |
| functionDefinition: => | |
| expression2: NullLiteral | |
| literal: null | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_method_generic_returnType() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| T m<T>() {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: NamedType | |
| name: T | |
| name: m | |
| typeParameters: TypeParameterList | |
| leftBracket: < | |
| typeParameters | |
| TypeParameter | |
| name: T | |
| rightBracket: > | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_method_generic_returnType_bound() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| T m<T extends num>() {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: NamedType | |
| name: T | |
| name: m | |
| typeParameters: TypeParameterList | |
| leftBracket: < | |
| typeParameters | |
| TypeParameter | |
| name: T | |
| extendsKeyword: extends | |
| bound: NamedType | |
| name: num | |
| rightBracket: > | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_method_generic_returnType_complex() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| Map<int, T> m<T>() => null; | |
| } | |
| '''); | |
| var node = | |
| (parseResult.findNode.singleClassDeclaration.body as BlockClassBody) | |
| .members | |
| .first; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: NamedType | |
| name: Map | |
| typeArguments: TypeArgumentList | |
| leftBracket: < | |
| arguments | |
| NamedType | |
| name: int | |
| NamedType | |
| name: T | |
| rightBracket: > | |
| name: m | |
| typeParameters: TypeParameterList | |
| leftBracket: < | |
| typeParameters | |
| TypeParameter | |
| name: T | |
| rightBracket: > | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: ExpressionFunctionBody | |
| functionDefinition: => | |
| expression2: NullLiteral | |
| literal: null | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_method_generic_returnType_static() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| static T m<T>() {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| modifierKeyword: static | |
| returnType: NamedType | |
| name: T | |
| name: m | |
| typeParameters: TypeParameterList | |
| leftBracket: < | |
| typeParameters | |
| TypeParameter | |
| name: T | |
| rightBracket: > | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_method_generic_void() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| void m<T>() {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: NamedType | |
| name: void | |
| name: m | |
| typeParameters: TypeParameterList | |
| leftBracket: < | |
| typeParameters | |
| TypeParameter | |
| name: T | |
| rightBracket: > | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_method_get_noType() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| get() {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| name: get | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_method_get_static_namedAsClass() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| static int get C => 0; | |
| // ^ | |
| // [diag.memberWithClassName] A class member can't have the same name as the enclosing class. | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| modifierKeyword: static | |
| returnType: NamedType | |
| name: int | |
| propertyKeyword: get | |
| name: C | |
| body: ExpressionFunctionBody | |
| functionDefinition: => | |
| expression2: IntegerLiteral | |
| literal: 0 | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_method_get_type() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| int get() {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: NamedType | |
| name: int | |
| name: get | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_method_get_void() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| void get() {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: NamedType | |
| name: void | |
| name: get | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_method_gftReturnType_noReturnType() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| Function<A>(core.List<core.int> x) m() => null; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: GenericFunctionType | |
| functionKeyword: Function | |
| typeParameters: TypeParameterList | |
| leftBracket: < | |
| typeParameters | |
| TypeParameter | |
| name: A | |
| rightBracket: > | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| importPrefix: ImportPrefixReference | |
| name: core | |
| period: . | |
| name: List | |
| typeArguments: TypeArgumentList | |
| leftBracket: < | |
| arguments | |
| NamedType | |
| importPrefix: ImportPrefixReference | |
| name: core | |
| period: . | |
| name: int | |
| rightBracket: > | |
| name: x | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| importPrefix: ImportPrefixReference | |
| name: core | |
| period: . | |
| name: List | |
| typeArguments: TypeArgumentList | |
| leftBracket: < | |
| arguments | |
| NamedType | |
| importPrefix: ImportPrefixReference | |
| name: core | |
| period: . | |
| name: int | |
| rightBracket: > | |
| name: x | |
| rightParenthesis: ) | |
| name: m | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: ExpressionFunctionBody | |
| functionDefinition: => | |
| expression2: NullLiteral | |
| literal: null | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_method_gftReturnType_voidReturnType() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| void Function<A>(core.List<core.int> x) m() => null; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: GenericFunctionType | |
| returnType: NamedType | |
| name: void | |
| functionKeyword: Function | |
| typeParameters: TypeParameterList | |
| leftBracket: < | |
| typeParameters | |
| TypeParameter | |
| name: A | |
| rightBracket: > | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| importPrefix: ImportPrefixReference | |
| name: core | |
| period: . | |
| name: List | |
| typeArguments: TypeArgumentList | |
| leftBracket: < | |
| arguments | |
| NamedType | |
| importPrefix: ImportPrefixReference | |
| name: core | |
| period: . | |
| name: int | |
| rightBracket: > | |
| name: x | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| importPrefix: ImportPrefixReference | |
| name: core | |
| period: . | |
| name: List | |
| typeArguments: TypeArgumentList | |
| leftBracket: < | |
| arguments | |
| NamedType | |
| importPrefix: ImportPrefixReference | |
| name: core | |
| period: . | |
| name: int | |
| rightBracket: > | |
| name: x | |
| rightParenthesis: ) | |
| name: m | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: ExpressionFunctionBody | |
| functionDefinition: => | |
| expression2: NullLiteral | |
| literal: null | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_method_operator_noType() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| operator() {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| name: operator | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_method_operator_type() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| int operator() {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: NamedType | |
| name: int | |
| name: operator | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_method_operator_void() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| void operator() {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: NamedType | |
| name: void | |
| name: operator | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_method_returnType_functionType() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| int Function(String) m() {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: GenericFunctionType | |
| returnType: NamedType | |
| name: int | |
| functionKeyword: Function | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| name: String | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: String | |
| rightParenthesis: ) | |
| name: m | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_method_returnType_parameterized() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| p.A m() {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: NamedType | |
| importPrefix: ImportPrefixReference | |
| name: p | |
| period: . | |
| name: A | |
| name: m | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_method_set_noType() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| set() {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| name: set | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_method_set_static_namedAsClass() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| static void set C(_) {} | |
| // ^ | |
| // [diag.memberWithClassName] A class member can't have the same name as the enclosing class. | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| modifierKeyword: static | |
| returnType: NamedType | |
| name: void | |
| propertyKeyword: set | |
| name: C | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| name: _ | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| name: _ | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_method_set_type() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| int set() {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: NamedType | |
| name: int | |
| name: set | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_method_set_void() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| void set() {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: NamedType | |
| name: void | |
| name: set | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_method_static_class() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| static void m() {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.unit; | |
| assertParsedNodeText(node, r''' | |
| CompilationUnit | |
| declarations2 | |
| ClassDeclaration | |
| classKeyword: class | |
| namePart: NameWithTypeParameters | |
| typeName: C | |
| body: BlockClassBody | |
| leftBracket: { | |
| members | |
| MethodDeclaration | |
| modifierKeyword: static | |
| returnType: NamedType | |
| name: void | |
| name: m | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_method_static_mixin() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| mixin C { | |
| static void m() {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.unit; | |
| assertParsedNodeText(node, r''' | |
| CompilationUnit | |
| declarations2 | |
| MixinDeclaration | |
| mixinKeyword: mixin | |
| name: C | |
| body: BlockClassBody | |
| leftBracket: { | |
| members | |
| MethodDeclaration | |
| modifierKeyword: static | |
| returnType: NamedType | |
| name: void | |
| name: m | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_method_trailing_commas() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| void f(int x, int y) {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: NamedType | |
| name: void | |
| name: f | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| name: int | |
| name: x | |
| RegularFormalParameter | |
| type: NamedType | |
| name: int | |
| name: y | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: int | |
| name: x | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: int | |
| name: y | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_operator_functionType() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| int Function() operator +(int Function() f) {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: GenericFunctionType | |
| returnType: NamedType | |
| name: int | |
| functionKeyword: Function | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| operatorKeyword: operator | |
| name: + | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: GenericFunctionType | |
| returnType: NamedType | |
| name: int | |
| functionKeyword: Function | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| name: f | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: GenericFunctionType | |
| returnType: NamedType | |
| name: int | |
| functionKeyword: Function | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| name: f | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_operator_gtgtgt() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| bool operator >>>(other) => false; | |
| } | |
| '''); | |
| var node = parseResult.findNode.unit; | |
| assertParsedNodeText(node, r''' | |
| CompilationUnit | |
| declarations2 | |
| ClassDeclaration | |
| classKeyword: class | |
| namePart: NameWithTypeParameters | |
| typeName: C | |
| body: BlockClassBody | |
| leftBracket: { | |
| members | |
| MethodDeclaration | |
| returnType: NamedType | |
| name: bool | |
| operatorKeyword: operator | |
| name: >>> | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| name: other | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| name: other | |
| rightParenthesis: ) | |
| body: ExpressionFunctionBody | |
| functionDefinition: => | |
| expression2: BooleanLiteral | |
| literal: false | |
| semicolon: ; | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_operator_gtgtgteq() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| foo(int value) { | |
| x >>>= value; | |
| } | |
| } | |
| '''); | |
| var node = parseResult.findNode.unit; | |
| assertParsedNodeText(node, r''' | |
| CompilationUnit | |
| declarations2 | |
| ClassDeclaration | |
| classKeyword: class | |
| namePart: NameWithTypeParameters | |
| typeName: C | |
| body: BlockClassBody | |
| leftBracket: { | |
| members | |
| MethodDeclaration | |
| name: foo | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| name: int | |
| name: value | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: int | |
| name: value | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| statements | |
| ExpressionStatement | |
| expression2: CompoundAssignment | |
| target: ParsedUnqualifiedNameAssignmentTarget | |
| name: x | |
| operator: >>>= | |
| value: ParsedUnqualifiedName | |
| name: value | |
| binaryOperator: unsignedShiftRight | |
| expression(v1): AssignmentExpression | |
| leftHandSide: SimpleIdentifier | |
| token: x | |
| operator: >>>= | |
| rightHandSide: SimpleIdentifier | |
| token: value | |
| semicolon: ; | |
| rightBracket: } | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_operator_index() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| int operator [](int i) {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: NamedType | |
| name: int | |
| operatorKeyword: operator | |
| name: [] | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| name: int | |
| name: i | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: int | |
| name: i | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_operator_indexAssign() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| int operator []=(int i) {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: NamedType | |
| name: int | |
| operatorKeyword: operator | |
| name: []= | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| name: int | |
| name: i | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: int | |
| name: i | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseClassMember_operator_lessThan() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| bool operator <(other) => false; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: NamedType | |
| name: bool | |
| operatorKeyword: operator | |
| name: < | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| name: other | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| name: other | |
| rightParenthesis: ) | |
| body: ExpressionFunctionBody | |
| functionDefinition: => | |
| expression2: BooleanLiteral | |
| literal: false | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_redirectingFactory_const() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| const factory C() = prefix.B.foo; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| ConstructorDeclaration | |
| constKeyword: const | |
| factoryKeyword: factory | |
| typeName2: C | |
| typeName(v1): SimpleIdentifier | |
| token: C | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| separator: = | |
| factoryRedirectionTarget: ConstructorReference2 | |
| typeReference: ConstructorTypeReference | |
| importPrefix: ImportPrefixReference | |
| name: prefix | |
| period: . | |
| name: B | |
| selector: ConstructorSelector | |
| period: . | |
| name2: foo | |
| body: EmptyFunctionBody | |
| semicolon: ; | |
| redirectedConstructor: ConstructorName | |
| type: NamedType | |
| importPrefix: ImportPrefixReference | |
| name: prefix | |
| period: . | |
| name: B | |
| period: . | |
| name: SimpleIdentifier | |
| token: foo | |
| '''); | |
| } | |
| void test_parseClassMember_redirectingFactory_expressionBody() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| factory C() => throw 0; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| ConstructorDeclaration | |
| factoryKeyword: factory | |
| typeName2: C | |
| typeName(v1): SimpleIdentifier | |
| token: C | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: ExpressionFunctionBody | |
| functionDefinition: => | |
| expression2: ThrowExpression | |
| throwKeyword: throw | |
| expression2: IntegerLiteral | |
| literal: 0 | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseClassMember_redirectingFactory_nonConst() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| factory C() = B; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| ConstructorDeclaration | |
| factoryKeyword: factory | |
| typeName2: C | |
| typeName(v1): SimpleIdentifier | |
| token: C | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| separator: = | |
| factoryRedirectionTarget: ConstructorReference2 | |
| typeReference: ConstructorTypeReference | |
| name: B | |
| body: EmptyFunctionBody | |
| semicolon: ; | |
| redirectedConstructor: ConstructorName | |
| type: NamedType | |
| name: B | |
| '''); | |
| } | |
| void test_parseConstructor_assert() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| C(x, y) : _x = x, assert(x < y), _y = y; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| ConstructorDeclaration | |
| typeName2: C | |
| typeName(v1): SimpleIdentifier | |
| token: C | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| name: x | |
| RegularFormalParameter | |
| name: y | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| name: x | |
| parameter: RegularFormalParameter | |
| name: y | |
| rightParenthesis: ) | |
| separator: : | |
| initializers | |
| ConstructorFieldInitializer | |
| fieldName2: _x | |
| fieldName(v1): SimpleIdentifier | |
| token: _x | |
| equals: = | |
| expression2: ParsedUnqualifiedName | |
| name: x | |
| expression(v1): SimpleIdentifier | |
| token: x | |
| AssertInitializer | |
| assertKeyword: assert | |
| leftParenthesis: ( | |
| condition2: BinaryOperatorInvocation | |
| leftOperand: ParsedUnqualifiedName | |
| name: x | |
| operator: < | |
| rightOperand: ParsedUnqualifiedName | |
| name: y | |
| binaryOperator: lessThan | |
| condition(v1): BinaryExpression | |
| leftOperand: SimpleIdentifier | |
| token: x | |
| operator: < | |
| rightOperand: SimpleIdentifier | |
| token: y | |
| rightParenthesis: ) | |
| ConstructorFieldInitializer | |
| fieldName2: _y | |
| fieldName(v1): SimpleIdentifier | |
| token: _y | |
| equals: = | |
| expression2: ParsedUnqualifiedName | |
| name: y | |
| expression(v1): SimpleIdentifier | |
| token: y | |
| body: EmptyFunctionBody | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseConstructor_factory_const_external() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| external const factory C(); | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| ConstructorDeclaration | |
| externalKeyword: external | |
| constKeyword: const | |
| factoryKeyword: factory | |
| typeName2: C | |
| typeName(v1): SimpleIdentifier | |
| token: C | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: EmptyFunctionBody | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseConstructor_factory_named() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| factory C.foo() => throw 0; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| ConstructorDeclaration | |
| factoryKeyword: factory | |
| typeName2: C | |
| typeName(v1): SimpleIdentifier | |
| token: C | |
| period: . | |
| name: foo | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: ExpressionFunctionBody | |
| functionDefinition: => | |
| expression2: ThrowExpression | |
| throwKeyword: throw | |
| expression2: IntegerLiteral | |
| literal: 0 | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseConstructor_initializers_field() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| C(x, y) : _x = x, this._y = y; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| ConstructorDeclaration | |
| typeName2: C | |
| typeName(v1): SimpleIdentifier | |
| token: C | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| name: x | |
| RegularFormalParameter | |
| name: y | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| name: x | |
| parameter: RegularFormalParameter | |
| name: y | |
| rightParenthesis: ) | |
| separator: : | |
| initializers | |
| ConstructorFieldInitializer | |
| fieldName2: _x | |
| fieldName(v1): SimpleIdentifier | |
| token: _x | |
| equals: = | |
| expression2: ParsedUnqualifiedName | |
| name: x | |
| expression(v1): SimpleIdentifier | |
| token: x | |
| ConstructorFieldInitializer | |
| thisKeyword: this | |
| period: . | |
| fieldName2: _y | |
| fieldName(v1): SimpleIdentifier | |
| token: _y | |
| equals: = | |
| expression2: ParsedUnqualifiedName | |
| name: y | |
| expression(v1): SimpleIdentifier | |
| token: y | |
| body: EmptyFunctionBody | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseConstructor_invalidInitializer() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C{ C() : super() * (); } | |
| // ^^^^^^^^^^^^ | |
| // [diag.invalidInitializer] Not a valid initializer. | |
| '''); | |
| var node = parseResult.findNode.unit; | |
| assertParsedNodeText(node, r''' | |
| CompilationUnit | |
| declarations2 | |
| ClassDeclaration | |
| classKeyword: class | |
| namePart: NameWithTypeParameters | |
| typeName: C | |
| body: BlockClassBody | |
| leftBracket: { | |
| members | |
| ConstructorDeclaration | |
| typeName2: C | |
| typeName(v1): SimpleIdentifier | |
| token: C | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| separator: : | |
| body: EmptyFunctionBody | |
| semicolon: ; | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseConstructor_named() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| C.foo(); | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| ConstructorDeclaration | |
| typeName2: C | |
| typeName(v1): SimpleIdentifier | |
| token: C | |
| period: . | |
| name: foo | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: EmptyFunctionBody | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseConstructor_nullSuperArgList_openBrace_37735() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class{const():super.{n | |
| // ^ | |
| // [diag.missingIdentifier] Expected an identifier. | |
| // ^ | |
| // [diag.missingIdentifier] Expected an identifier. | |
| // [diag.invalidConstructorName] The name of a constructor must match the name of the enclosing class. | |
| // ^ | |
| // [diag.missingIdentifier] Expected an identifier. | |
| // [diag.expectedToken] Expected to find '('. | |
| // ^ | |
| // [diag.expectedToken] Expected to find ';'. | |
| // [diag.expectedToken][column 23][length 1] Expected to find '}'. | |
| '''); | |
| var node = parseResult.findNode.unit; | |
| assertParsedNodeText(node, r''' | |
| CompilationUnit | |
| declarations2 | |
| ClassDeclaration | |
| classKeyword: class | |
| namePart: NameWithTypeParameters | |
| typeName: <empty> <synthetic> | |
| body: BlockClassBody | |
| leftBracket: { | |
| members | |
| ConstructorDeclaration | |
| constKeyword: const | |
| typeName2: <empty> <synthetic> | |
| typeName(v1): SimpleIdentifier | |
| token: <empty> <synthetic> | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| separator: : | |
| initializers | |
| SuperConstructorInvocation | |
| superKeyword: super | |
| constructorSelector: ConstructorSelector | |
| period: . | |
| name2: <empty> <synthetic> | |
| argumentList: ArgumentList | |
| leftParenthesis: ( <synthetic> | |
| rightParenthesis: ) <synthetic> | |
| period: . | |
| constructorName: SimpleIdentifier | |
| token: <empty> <synthetic> | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| statements | |
| ExpressionStatement | |
| expression2: ParsedUnqualifiedName | |
| name: n | |
| expression(v1): SimpleIdentifier | |
| token: n | |
| semicolon: ; <synthetic> | |
| rightBracket: } <synthetic> | |
| rightBracket: } <synthetic> | |
| '''); | |
| } | |
| void test_parseConstructor_operator_name() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class A { operator/() : super(); } | |
| // ^^^^^^^^ | |
| // [diag.invalidConstructorName] The name of a constructor must match the name of the enclosing class. | |
| '''); | |
| var node = parseResult.findNode.unit; | |
| assertParsedNodeText(node, r''' | |
| CompilationUnit | |
| declarations2 | |
| ClassDeclaration | |
| classKeyword: class | |
| namePart: NameWithTypeParameters | |
| typeName: A | |
| body: BlockClassBody | |
| leftBracket: { | |
| members | |
| ConstructorDeclaration | |
| typeName2: / | |
| typeName(v1): SimpleIdentifier | |
| token: / | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| separator: : | |
| initializers | |
| SuperConstructorInvocation | |
| superKeyword: super | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: EmptyFunctionBody | |
| semicolon: ; | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseConstructor_superIndexed() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| C() : super()[]; | |
| // ^^^^^ | |
| // [diag.invalidSuperInInitializer] Can only use 'super' in an initializer for calling the superclass constructor (e.g. 'super()' or 'super.namedConstructor()') | |
| // ^ | |
| // [diag.missingIdentifier] Expected an identifier. | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| ConstructorDeclaration | |
| typeName2: C | |
| typeName(v1): SimpleIdentifier | |
| token: C | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| separator: : | |
| initializers | |
| SuperConstructorInvocation | |
| superKeyword: super | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: EmptyFunctionBody | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseConstructor_thisIndexed() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| C() : this()[]; | |
| // ^^^^ | |
| // [diag.invalidThisInInitializer] Can only use 'this' in an initializer for field initialization (e.g. 'this.x = something') and constructor redirection (e.g. 'this()' or 'this.namedConstructor()) | |
| // ^ | |
| // [diag.missingIdentifier] Expected an identifier. | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| ConstructorDeclaration | |
| typeName2: C | |
| typeName(v1): SimpleIdentifier | |
| token: C | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| separator: : | |
| initializers | |
| RedirectingConstructorInvocation | |
| thisKeyword: this | |
| argumentList: ArgumentList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: EmptyFunctionBody | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseConstructor_unnamed() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| C(); | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| ConstructorDeclaration | |
| typeName2: C | |
| typeName(v1): SimpleIdentifier | |
| token: C | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| body: EmptyFunctionBody | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseConstructor_with_pseudo_function_literal() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| C() : a = (b) {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| ConstructorDeclaration | |
| typeName2: C | |
| typeName(v1): SimpleIdentifier | |
| token: C | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| rightParenthesis: ) | |
| separator: : | |
| initializers | |
| ConstructorFieldInitializer | |
| fieldName2: a | |
| fieldName(v1): SimpleIdentifier | |
| token: a | |
| equals: = | |
| expression2: ParenthesizedExpression | |
| leftParenthesis: ( | |
| expression2: ParsedUnqualifiedName | |
| name: b | |
| expression(v1): SimpleIdentifier | |
| token: b | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_parseConstructorFieldInitializer_qualified() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| C() : this.a = b; | |
| } | |
| '''); | |
| var node = | |
| parseResult.findNode.singleConstructorDeclaration.initializers.first; | |
| assertParsedNodeText(node, r''' | |
| ConstructorFieldInitializer | |
| thisKeyword: this | |
| period: . | |
| fieldName2: a | |
| fieldName(v1): SimpleIdentifier | |
| token: a | |
| equals: = | |
| expression2: ParsedUnqualifiedName | |
| name: b | |
| expression(v1): SimpleIdentifier | |
| token: b | |
| '''); | |
| } | |
| void test_parseConstructorFieldInitializer_unqualified() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| C() : a = b; | |
| } | |
| '''); | |
| var node = | |
| parseResult.findNode.singleConstructorDeclaration.initializers.first; | |
| assertParsedNodeText(node, r''' | |
| ConstructorFieldInitializer | |
| fieldName2: a | |
| fieldName(v1): SimpleIdentifier | |
| token: a | |
| equals: = | |
| expression2: ParsedUnqualifiedName | |
| name: b | |
| expression(v1): SimpleIdentifier | |
| token: b | |
| '''); | |
| } | |
| void test_parseField_abstract() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| abstract int i; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| abstractKeyword: abstract | |
| fields: VariableDeclarationList | |
| type: NamedType | |
| name: int | |
| variables | |
| VariableDeclaration | |
| name: i | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseField_abstract_external() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| abstract external int i; | |
| //^^^^^^^^ | |
| // [diag.abstractExternalField] Fields can't be declared both 'abstract' and 'external'. | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| externalKeyword: external | |
| abstractKeyword: abstract | |
| fields: VariableDeclarationList | |
| type: NamedType | |
| name: int | |
| variables | |
| VariableDeclaration | |
| name: i | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseField_abstract_late() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| abstract late int? i; | |
| //^^^^^^^^ | |
| // [diag.abstractLateField] Abstract fields cannot be late. | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| abstractKeyword: abstract | |
| fields: VariableDeclarationList | |
| lateKeyword: late | |
| type: NamedType | |
| name: int | |
| question: ? | |
| variables | |
| VariableDeclaration | |
| name: i | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseField_abstract_late_final() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| abstract late final int? i; | |
| //^^^^^^^^ | |
| // [diag.abstractLateField] Abstract fields cannot be late. | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| abstractKeyword: abstract | |
| fields: VariableDeclarationList | |
| lateKeyword: late | |
| keyword: final | |
| type: NamedType | |
| name: int | |
| question: ? | |
| variables | |
| VariableDeclaration | |
| name: i | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseField_const_late() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| const late T f = 0; | |
| // ^^^^ | |
| // [diag.conflictingModifiers] Members can't be declared to be both 'late' and 'const'. | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| fields: VariableDeclarationList | |
| lateKeyword: late | |
| keyword: const | |
| type: NamedType | |
| name: T | |
| variables | |
| VariableDeclaration | |
| name: f | |
| equals: = | |
| initializer2: IntegerLiteral | |
| literal: 0 | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseField_external() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| external int i; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| externalKeyword: external | |
| fields: VariableDeclarationList | |
| type: NamedType | |
| name: int | |
| variables | |
| VariableDeclaration | |
| name: i | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseField_external_abstract() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| external abstract int i; | |
| // ^^^^^^^^ | |
| // [diag.abstractExternalField] Fields can't be declared both 'abstract' and 'external'. | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| externalKeyword: external | |
| abstractKeyword: abstract | |
| fields: VariableDeclarationList | |
| type: NamedType | |
| name: int | |
| variables | |
| VariableDeclaration | |
| name: i | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseField_external_late() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| external late int? i; | |
| //^^^^^^^^ | |
| // [diag.externalLateField] External fields cannot be late. | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| externalKeyword: external | |
| fields: VariableDeclarationList | |
| lateKeyword: late | |
| type: NamedType | |
| name: int | |
| question: ? | |
| variables | |
| VariableDeclaration | |
| name: i | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseField_external_late_final() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| external late final int? i; | |
| //^^^^^^^^ | |
| // [diag.externalLateField] External fields cannot be late. | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| externalKeyword: external | |
| fields: VariableDeclarationList | |
| lateKeyword: late | |
| keyword: final | |
| type: NamedType | |
| name: int | |
| question: ? | |
| variables | |
| VariableDeclaration | |
| name: i | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseField_external_static() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| external static int? i; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| externalKeyword: external | |
| staticKeyword: static | |
| fields: VariableDeclarationList | |
| type: NamedType | |
| name: int | |
| question: ? | |
| variables | |
| VariableDeclaration | |
| name: i | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseField_final_late() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| final late T f; | |
| // ^^^^ | |
| // [diag.modifierOutOfOrder] The modifier 'late' should be before the modifier 'final'. | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| fields: VariableDeclarationList | |
| lateKeyword: late | |
| keyword: final | |
| type: NamedType | |
| name: T | |
| variables | |
| VariableDeclaration | |
| name: f | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseField_late() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| late T f; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| fields: VariableDeclarationList | |
| lateKeyword: late | |
| type: NamedType | |
| name: T | |
| variables | |
| VariableDeclaration | |
| name: f | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseField_late_const() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| late const T f = 0; | |
| // ^^^^^ | |
| // [diag.conflictingModifiers] Members can't be declared to be both 'const' and 'late'. | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| fields: VariableDeclarationList | |
| lateKeyword: late | |
| keyword: const | |
| type: NamedType | |
| name: T | |
| variables | |
| VariableDeclaration | |
| name: f | |
| equals: = | |
| initializer2: IntegerLiteral | |
| literal: 0 | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseField_late_final() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| late final T f; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| fields: VariableDeclarationList | |
| lateKeyword: late | |
| keyword: final | |
| type: NamedType | |
| name: T | |
| variables | |
| VariableDeclaration | |
| name: f | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseField_late_var() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| late var f; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| fields: VariableDeclarationList | |
| lateKeyword: late | |
| keyword: var | |
| variables | |
| VariableDeclaration | |
| name: f | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseField_non_abstract() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| int i; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| fields: VariableDeclarationList | |
| type: NamedType | |
| name: int | |
| variables | |
| VariableDeclaration | |
| name: i | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseField_non_external() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| int i; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| fields: VariableDeclarationList | |
| type: NamedType | |
| name: int | |
| variables | |
| VariableDeclaration | |
| name: i | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseField_static_abstract() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| static abstract int? i; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| staticKeyword: static | |
| abstractKeyword: abstract | |
| fields: VariableDeclarationList | |
| type: NamedType | |
| name: int | |
| question: ? | |
| variables | |
| VariableDeclaration | |
| name: i | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseField_var_late() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| var late f; | |
| // ^^^^ | |
| // [diag.modifierOutOfOrder] The modifier 'late' should be before the modifier 'var'. | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| fields: VariableDeclarationList | |
| lateKeyword: late | |
| keyword: var | |
| variables | |
| VariableDeclaration | |
| name: f | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseGetter_nonStatic() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| /// Doc | |
| T get a; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| documentationComment: Comment | |
| tokens | |
| /// Doc | |
| returnType: NamedType | |
| name: T | |
| propertyKeyword: get | |
| name: a | |
| body: EmptyFunctionBody | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseGetter_static() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| /// Doc | |
| static T get a => 42; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| documentationComment: Comment | |
| tokens | |
| /// Doc | |
| modifierKeyword: static | |
| returnType: NamedType | |
| name: T | |
| propertyKeyword: get | |
| name: a | |
| body: ExpressionFunctionBody | |
| functionDefinition: => | |
| expression2: IntegerLiteral | |
| literal: 42 | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseInitializedIdentifierList_type() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| /// Doc | |
| static T a = 1, b, c = 3; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| documentationComment: Comment | |
| tokens | |
| /// Doc | |
| staticKeyword: static | |
| fields: VariableDeclarationList | |
| type: NamedType | |
| name: T | |
| variables | |
| VariableDeclaration | |
| name: a | |
| equals: = | |
| initializer2: IntegerLiteral | |
| literal: 1 | |
| VariableDeclaration | |
| name: b | |
| VariableDeclaration | |
| name: c | |
| equals: = | |
| initializer2: IntegerLiteral | |
| literal: 3 | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseInitializedIdentifierList_var() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| /// Doc | |
| static var a = 1, b, c = 3; | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| FieldDeclaration | |
| documentationComment: Comment | |
| tokens | |
| /// Doc | |
| staticKeyword: static | |
| fields: VariableDeclarationList | |
| keyword: var | |
| variables | |
| VariableDeclaration | |
| name: a | |
| equals: = | |
| initializer2: IntegerLiteral | |
| literal: 1 | |
| VariableDeclaration | |
| name: b | |
| VariableDeclaration | |
| name: c | |
| equals: = | |
| initializer2: IntegerLiteral | |
| literal: 3 | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseOperator() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| /// Doc | |
| T operator +(A a); | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| documentationComment: Comment | |
| tokens | |
| /// Doc | |
| returnType: NamedType | |
| name: T | |
| operatorKeyword: operator | |
| name: + | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| type: NamedType | |
| name: A | |
| name: a | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| type: NamedType | |
| name: A | |
| name: a | |
| rightParenthesis: ) | |
| body: EmptyFunctionBody | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseSetter_nonStatic() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| /// Doc | |
| T set a(var x); | |
| // ^^^ | |
| // [diag.extraneousModifier] Can't have modifier 'var' here. | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| documentationComment: Comment | |
| tokens | |
| /// Doc | |
| returnType: NamedType | |
| name: T | |
| propertyKeyword: set | |
| name: a | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| constFinalOrVarKeyword: var | |
| name: x | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| constFinalOrVarKeyword: var | |
| name: x | |
| rightParenthesis: ) | |
| body: EmptyFunctionBody | |
| semicolon: ; | |
| '''); | |
| } | |
| void test_parseSetter_static() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| /// Doc | |
| static T set a(var x) {} | |
| // ^^^ | |
| // [diag.extraneousModifier] Can't have modifier 'var' here. | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| documentationComment: Comment | |
| tokens | |
| /// Doc | |
| modifierKeyword: static | |
| returnType: NamedType | |
| name: T | |
| propertyKeyword: set | |
| name: a | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| constFinalOrVarKeyword: var | |
| name: x | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| constFinalOrVarKeyword: var | |
| name: x | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| void test_simpleFormalParameter_withDocComment() { | |
| var parseResult = parseTestCodeWithDiagnostics(r''' | |
| class C { | |
| int f( | |
| /// Doc | |
| int x, | |
| ) {} | |
| } | |
| '''); | |
| var node = parseResult.findNode.singleClassMember; | |
| assertParsedNodeText(node, r''' | |
| MethodDeclaration | |
| returnType: NamedType | |
| name: int | |
| name: f | |
| parameters: FormalParameterList | |
| leftParenthesis: ( | |
| requiredPositionalFormalParameters | |
| RegularFormalParameter | |
| documentationComment: Comment | |
| tokens | |
| /// Doc | |
| type: NamedType | |
| name: int | |
| name: x | |
| rightParenthesis: ) | |
| parameters(v1): FormalParameterList | |
| leftParenthesis: ( | |
| parameter: RegularFormalParameter | |
| documentationComment: Comment | |
| tokens | |
| /// Doc | |
| type: NamedType | |
| name: int | |
| name: x | |
| rightParenthesis: ) | |
| body: BlockFunctionBody | |
| block: Block | |
| leftBracket: { | |
| rightBracket: } | |
| '''); | |
| } | |
| } |