dart-lang/sdk
1
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity
Files
47236d71e50bf7548e94de28b1767da63e0a8d3d
sdk/pkg/analyzer/test/generated/ast_test.dart
T
brianwilkerson@google.com 25ea0e7ee0 Fix for issue 22245 
R=scheglov@google.com

Review URL: https://codereview.chromium.org//896613003

git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@43404 260f80e4-7a28-3924-810f-c04153c831b5
2015-02-03 15:48:39 +00:00

4106 lines
124 KiB
Dart
Raw Blame History

// Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
// This code was auto-generated, is not intended to be edited, and is subject to
// significant change. Please see the README file for more information.
library engine.ast_test;
import 'package:analyzer/src/generated/ast.dart';
import 'package:analyzer/src/generated/java_core.dart';
import 'package:analyzer/src/generated/java_engine.dart' show Predicate;
import 'package:analyzer/src/generated/java_engine.dart';
import 'package:analyzer/src/generated/scanner.dart';
import 'package:analyzer/src/generated/testing/ast_factory.dart';
import 'package:analyzer/src/generated/testing/token_factory.dart';
import 'package:unittest/unittest.dart';
import '../reflective_tests.dart';
import 'parser_test.dart' show ParserTestCase;
import 'test_support.dart';
main() {
groupSep = ' | ';
runReflectiveTests(BreadthFirstVisitorTest);
runReflectiveTests(ClassDeclarationTest);
runReflectiveTests(ClassTypeAliasTest);
runReflectiveTests(ConstantEvaluatorTest);
runReflectiveTests(ConstructorDeclarationTest);
runReflectiveTests(FieldFormalParameterTest);
runReflectiveTests(IndexExpressionTest);
runReflectiveTests(NodeListTest);
runReflectiveTests(NodeLocatorTest);
runReflectiveTests(SimpleIdentifierTest);
runReflectiveTests(SimpleStringLiteralTest);
runReflectiveTests(StringInterpolationTest);
runReflectiveTests(ToSourceVisitorTest);
runReflectiveTests(VariableDeclarationTest);
}
class AssignmentKind extends Enum<AssignmentKind> {
static const AssignmentKind BINARY = const AssignmentKind('BINARY', 0);
static const AssignmentKind COMPOUND_LEFT =
const AssignmentKind('COMPOUND_LEFT', 1);
static const AssignmentKind COMPOUND_RIGHT =
const AssignmentKind('COMPOUND_RIGHT', 2);
static const AssignmentKind POSTFIX_INC =
const AssignmentKind('POSTFIX_INC', 3);
static const AssignmentKind PREFIX_DEC =
const AssignmentKind('PREFIX_DEC', 4);
static const AssignmentKind PREFIX_INC =
const AssignmentKind('PREFIX_INC', 5);
static const AssignmentKind PREFIX_NOT =
const AssignmentKind('PREFIX_NOT', 6);
static const AssignmentKind SIMPLE_LEFT =
const AssignmentKind('SIMPLE_LEFT', 7);
static const AssignmentKind SIMPLE_RIGHT =
const AssignmentKind('SIMPLE_RIGHT', 8);
static const AssignmentKind NONE = const AssignmentKind('NONE', 9);
static const List<AssignmentKind> values = const [
BINARY,
COMPOUND_LEFT,
COMPOUND_RIGHT,
POSTFIX_INC,
PREFIX_DEC,
PREFIX_INC,
PREFIX_NOT,
SIMPLE_LEFT,
SIMPLE_RIGHT,
NONE];
const AssignmentKind(String name, int ordinal) : super(name, ordinal);
}
class BreadthFirstVisitor_BreadthFirstVisitorTest_testIt extends
BreadthFirstVisitor<Object> {
List<AstNode> nodes;
BreadthFirstVisitor_BreadthFirstVisitorTest_testIt(this.nodes) : super();
@override
Object visitNode(AstNode node) {
nodes.add(node);
return super.visitNode(node);
}
}
@reflectiveTest
class BreadthFirstVisitorTest extends ParserTestCase {
void test_it() {
String source = r'''
class A {
bool get g => true;
}
class B {
int f() {
num q() {
return 3;
}
return q() + 4;
}
}
A f(var p) {
if ((p as A).g) {
return p;
} else {
return null;
}
}''';
CompilationUnit unit = ParserTestCase.parseCompilationUnit(source);
List<AstNode> nodes = new List<AstNode>();
BreadthFirstVisitor<Object> visitor =
new BreadthFirstVisitor_BreadthFirstVisitorTest_testIt(nodes);
visitor.visitAllNodes(unit);
expect(nodes, hasLength(59));
EngineTestCase.assertInstanceOf(
(obj) => obj is CompilationUnit,
CompilationUnit,
nodes[0]);
EngineTestCase.assertInstanceOf(
(obj) => obj is ClassDeclaration,
ClassDeclaration,
nodes[2]);
EngineTestCase.assertInstanceOf(
(obj) => obj is FunctionDeclaration,
FunctionDeclaration,
nodes[3]);
EngineTestCase.assertInstanceOf(
(obj) => obj is FunctionDeclarationStatement,
FunctionDeclarationStatement,
nodes[27]);
EngineTestCase.assertInstanceOf(
(obj) => obj is IntegerLiteral,
IntegerLiteral,
nodes[58]);
//3
}
}
@reflectiveTest
class ClassDeclarationTest extends ParserTestCase {
void test_getConstructor() {
List<ConstructorInitializer> initializers =
new List<ConstructorInitializer>();
ConstructorDeclaration defaultConstructor =
AstFactory.constructorDeclaration(
AstFactory.identifier3("Test"),
null,
AstFactory.formalParameterList(),
initializers);
ConstructorDeclaration aConstructor = AstFactory.constructorDeclaration(
AstFactory.identifier3("Test"),
"a",
AstFactory.formalParameterList(),
initializers);
ConstructorDeclaration bConstructor = AstFactory.constructorDeclaration(
AstFactory.identifier3("Test"),
"b",
AstFactory.formalParameterList(),
initializers);
ClassDeclaration clazz = AstFactory.classDeclaration(
null,
"Test",
null,
null,
null,
null,
[defaultConstructor, aConstructor, bConstructor]);
expect(clazz.getConstructor(null), same(defaultConstructor));
expect(clazz.getConstructor("a"), same(aConstructor));
expect(clazz.getConstructor("b"), same(bConstructor));
expect(clazz.getConstructor("noSuchConstructor"), same(null));
}
void test_getField() {
VariableDeclaration aVar = AstFactory.variableDeclaration("a");
VariableDeclaration bVar = AstFactory.variableDeclaration("b");
VariableDeclaration cVar = AstFactory.variableDeclaration("c");
ClassDeclaration clazz = AstFactory.classDeclaration(
null,
"Test",
null,
null,
null,
null,
[
AstFactory.fieldDeclaration2(false, null, [aVar]),
AstFactory.fieldDeclaration2(false, null, [bVar, cVar])]);
expect(clazz.getField("a"), same(aVar));
expect(clazz.getField("b"), same(bVar));
expect(clazz.getField("c"), same(cVar));
expect(clazz.getField("noSuchField"), same(null));
}
void test_getMethod() {
MethodDeclaration aMethod = AstFactory.methodDeclaration(
null,
null,
null,
null,
AstFactory.identifier3("a"),
AstFactory.formalParameterList());
MethodDeclaration bMethod = AstFactory.methodDeclaration(
null,
null,
null,
null,
AstFactory.identifier3("b"),
AstFactory.formalParameterList());
ClassDeclaration clazz = AstFactory.classDeclaration(
null,
"Test",
null,
null,
null,
null,
[aMethod, bMethod]);
expect(clazz.getMethod("a"), same(aMethod));
expect(clazz.getMethod("b"), same(bMethod));
expect(clazz.getMethod("noSuchMethod"), same(null));
}
void test_isAbstract() {
expect(
AstFactory.classDeclaration(null, "A", null, null, null, null).isAbstract,
isFalse);
expect(
AstFactory.classDeclaration(
Keyword.ABSTRACT,
"B",
null,
null,
null,
null).isAbstract,
isTrue);
}
}
@reflectiveTest
class ClassTypeAliasTest extends ParserTestCase {
void test_isAbstract() {
expect(
AstFactory.classTypeAlias("A", null, null, null, null, null).isAbstract,
isFalse);
expect(
AstFactory.classTypeAlias(
"B",
null,
Keyword.ABSTRACT,
null,
null,
null).isAbstract,
isTrue);
}
}
@reflectiveTest
class ConstantEvaluatorTest extends ParserTestCase {
void fail_constructor() {
Object value = _getConstantValue("?");
expect(value, null);
}
void fail_identifier_class() {
Object value = _getConstantValue("?");
expect(value, null);
}
void fail_identifier_function() {
Object value = _getConstantValue("?");
expect(value, null);
}
void fail_identifier_static() {
Object value = _getConstantValue("?");
expect(value, null);
}
void fail_identifier_staticMethod() {
Object value = _getConstantValue("?");
expect(value, null);
}
void fail_identifier_topLevel() {
Object value = _getConstantValue("?");
expect(value, null);
}
void fail_identifier_typeParameter() {
Object value = _getConstantValue("?");
expect(value, null);
}
void test_binary_bitAnd() {
Object value = _getConstantValue("74 & 42");
EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
expect(value as int, 74 & 42);
}
void test_binary_bitOr() {
Object value = _getConstantValue("74 | 42");
EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
expect(value as int, 74 | 42);
}
void test_binary_bitXor() {
Object value = _getConstantValue("74 ^ 42");
EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
expect(value as int, 74 ^ 42);
}
void test_binary_divide_double() {
Object value = _getConstantValue("3.2 / 2.3");
EngineTestCase.assertInstanceOf((obj) => obj is double, double, value);
expect(value as double, 3.2 / 2.3);
}
void test_binary_divide_integer() {
Object value = _getConstantValue("3 / 2");
EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
expect(value as int, 1);
}
void test_binary_equal_boolean() {
Object value = _getConstantValue("true == false");
expect(value, false);
}
void test_binary_equal_integer() {
Object value = _getConstantValue("2 == 3");
expect(value, false);
}
void test_binary_equal_invalidLeft() {
Object value = _getConstantValue("a == 3");
expect(value, ConstantEvaluator.NOT_A_CONSTANT);
}
void test_binary_equal_invalidRight() {
Object value = _getConstantValue("2 == a");
expect(value, ConstantEvaluator.NOT_A_CONSTANT);
}
void test_binary_equal_string() {
Object value = _getConstantValue("'a' == 'b'");
expect(value, false);
}
void test_binary_greaterThan() {
Object value = _getConstantValue("2 > 3");
expect(value, false);
}
void test_binary_greaterThanOrEqual() {
Object value = _getConstantValue("2 >= 3");
expect(value, false);
}
void test_binary_leftShift() {
Object value = _getConstantValue("16 << 2");
EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
expect(value as int, 64);
}
void test_binary_lessThan() {
Object value = _getConstantValue("2 < 3");
expect(value, true);
}
void test_binary_lessThanOrEqual() {
Object value = _getConstantValue("2 <= 3");
expect(value, true);
}
void test_binary_logicalAnd() {
Object value = _getConstantValue("true && false");
expect(value, false);
}
void test_binary_logicalOr() {
Object value = _getConstantValue("true || false");
expect(value, true);
}
void test_binary_minus_double() {
Object value = _getConstantValue("3.2 - 2.3");
EngineTestCase.assertInstanceOf((obj) => obj is double, double, value);
expect(value as double, 3.2 - 2.3);
}
void test_binary_minus_integer() {
Object value = _getConstantValue("3 - 2");
EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
expect(value as int, 1);
}
void test_binary_notEqual_boolean() {
Object value = _getConstantValue("true != false");
expect(value, true);
}
void test_binary_notEqual_integer() {
Object value = _getConstantValue("2 != 3");
expect(value, true);
}
void test_binary_notEqual_invalidLeft() {
Object value = _getConstantValue("a != 3");
expect(value, ConstantEvaluator.NOT_A_CONSTANT);
}
void test_binary_notEqual_invalidRight() {
Object value = _getConstantValue("2 != a");
expect(value, ConstantEvaluator.NOT_A_CONSTANT);
}
void test_binary_notEqual_string() {
Object value = _getConstantValue("'a' != 'b'");
expect(value, true);
}
void test_binary_plus_double() {
Object value = _getConstantValue("2.3 + 3.2");
EngineTestCase.assertInstanceOf((obj) => obj is double, double, value);
expect(value as double, 2.3 + 3.2);
}
void test_binary_plus_integer() {
Object value = _getConstantValue("2 + 3");
EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
expect(value as int, 5);
}
void test_binary_remainder_double() {
Object value = _getConstantValue("3.2 % 2.3");
EngineTestCase.assertInstanceOf((obj) => obj is double, double, value);
expect(value as double, 3.2 % 2.3);
}
void test_binary_remainder_integer() {
Object value = _getConstantValue("8 % 3");
EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
expect(value as int, 2);
}
void test_binary_rightShift() {
Object value = _getConstantValue("64 >> 2");
EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
expect(value as int, 16);
}
void test_binary_times_double() {
Object value = _getConstantValue("2.3 * 3.2");
EngineTestCase.assertInstanceOf((obj) => obj is double, double, value);
expect(value as double, 2.3 * 3.2);
}
void test_binary_times_integer() {
Object value = _getConstantValue("2 * 3");
EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
expect(value as int, 6);
}
void test_binary_truncatingDivide_double() {
Object value = _getConstantValue("3.2 ~/ 2.3");
EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
expect(value as int, 1);
}
void test_binary_truncatingDivide_integer() {
Object value = _getConstantValue("10 ~/ 3");
EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
expect(value as int, 3);
}
void test_literal_boolean_false() {
Object value = _getConstantValue("false");
expect(value, false);
}
void test_literal_boolean_true() {
Object value = _getConstantValue("true");
expect(value, true);
}
void test_literal_list() {
Object value = _getConstantValue("['a', 'b', 'c']");
EngineTestCase.assertInstanceOf((obj) => obj is List, List, value);
List list = value as List;
expect(list.length, 3);
expect(list[0], "a");
expect(list[1], "b");
expect(list[2], "c");
}
void test_literal_map() {
Object value = _getConstantValue("{'a' : 'm', 'b' : 'n', 'c' : 'o'}");
EngineTestCase.assertInstanceOf((obj) => obj is Map, Map, value);
Map map = value as Map;
expect(map.length, 3);
expect(map["a"], "m");
expect(map["b"], "n");
expect(map["c"], "o");
}
void test_literal_null() {
Object value = _getConstantValue("null");
expect(value, null);
}
void test_literal_number_double() {
Object value = _getConstantValue("3.45");
EngineTestCase.assertInstanceOf((obj) => obj is double, double, value);
expect(value as double, 3.45);
}
void test_literal_number_integer() {
Object value = _getConstantValue("42");
EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
expect(value as int, 42);
}
void test_literal_string_adjacent() {
Object value = _getConstantValue("'abc' 'def'");
expect(value, "abcdef");
}
void test_literal_string_interpolation_invalid() {
Object value = _getConstantValue("'a\${f()}c'");
expect(value, ConstantEvaluator.NOT_A_CONSTANT);
}
void test_literal_string_interpolation_valid() {
Object value = _getConstantValue("'a\${3}c'");
expect(value, "a3c");
}
void test_literal_string_simple() {
Object value = _getConstantValue("'abc'");
expect(value, "abc");
}
void test_parenthesizedExpression() {
Object value = _getConstantValue("('a')");
expect(value, "a");
}
void test_unary_bitNot() {
Object value = _getConstantValue("~42");
EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
expect(value as int, ~42);
}
void test_unary_logicalNot() {
Object value = _getConstantValue("!true");
expect(value, false);
}
void test_unary_negated_double() {
Object value = _getConstantValue("-42.3");
EngineTestCase.assertInstanceOf((obj) => obj is double, double, value);
expect(value as double, -42.3);
}
void test_unary_negated_integer() {
Object value = _getConstantValue("-42");
EngineTestCase.assertInstanceOf((obj) => obj is int, int, value);
expect(value as int, -42);
}
Object _getConstantValue(String source) =>
ParserTestCase.parseExpression(source).accept(new ConstantEvaluator());
}
@reflectiveTest
class ConstructorDeclarationTest extends EngineTestCase {
void test_firstTokenAfterCommentAndMetadata_all_inverted() {
Token externalKeyword = TokenFactory.tokenFromKeyword(Keyword.EXTERNAL);
externalKeyword.offset = 14;
ConstructorDeclaration declaration = AstFactory.constructorDeclaration2(
Keyword.CONST,
Keyword.FACTORY,
AstFactory.identifier3('int'),
null,
null,
null,
null);
declaration.externalKeyword = externalKeyword;
declaration.constKeyword.offset = 8;
Token factoryKeyword = declaration.factoryKeyword;
factoryKeyword.offset = 0;
expect(declaration.firstTokenAfterCommentAndMetadata, factoryKeyword);
}
void test_firstTokenAfterCommentAndMetadata_all_normal() {
Token token = TokenFactory.tokenFromKeyword(Keyword.EXTERNAL);
token.offset = 0;
ConstructorDeclaration declaration = AstFactory.constructorDeclaration2(
Keyword.CONST,
Keyword.FACTORY,
AstFactory.identifier3('int'),
null,
null,
null,
null);
declaration.externalKeyword = token;
declaration.constKeyword.offset = 9;
declaration.factoryKeyword.offset = 15;
expect(declaration.firstTokenAfterCommentAndMetadata, token);
}
void test_firstTokenAfterCommentAndMetadata_constOnly() {
ConstructorDeclaration declaration = AstFactory.constructorDeclaration2(
Keyword.CONST,
null,
AstFactory.identifier3('int'),
null,
null,
null,
null);
expect(
declaration.firstTokenAfterCommentAndMetadata,
declaration.constKeyword);
}
void test_firstTokenAfterCommentAndMetadata_externalOnly() {
Token externalKeyword = TokenFactory.tokenFromKeyword(Keyword.EXTERNAL);
ConstructorDeclaration declaration = AstFactory.constructorDeclaration2(
null,
null,
AstFactory.identifier3('int'),
null,
null,
null,
null);
declaration.externalKeyword = externalKeyword;
expect(declaration.firstTokenAfterCommentAndMetadata, externalKeyword);
}
void test_firstTokenAfterCommentAndMetadata_factoryOnly() {
ConstructorDeclaration declaration = AstFactory.constructorDeclaration2(
null,
Keyword.FACTORY,
AstFactory.identifier3('int'),
null,
null,
null,
null);
expect(
declaration.firstTokenAfterCommentAndMetadata,
declaration.factoryKeyword);
}
}
@reflectiveTest
class FieldFormalParameterTest extends EngineTestCase {
void test_endToken_noParameters() {
FieldFormalParameter parameter = AstFactory.fieldFormalParameter2('field');
expect(parameter.endToken, parameter.identifier.endToken);
}
void test_endToken_parameters() {
FieldFormalParameter parameter = AstFactory.fieldFormalParameter(null, null, 'field', AstFactory.formalParameterList([]));
expect(parameter.endToken, parameter.parameters.endToken);
}
}
@reflectiveTest
class IndexExpressionTest extends EngineTestCase {
void test_inGetterContext_assignment_compound_left() {
IndexExpression expression = AstFactory.indexExpression(
AstFactory.identifier3("a"),
AstFactory.identifier3("b"));
// a[b] += c
AstFactory.assignmentExpression(
expression,
TokenType.PLUS_EQ,
AstFactory.identifier3("c"));
expect(expression.inGetterContext(), isTrue);
}
void test_inGetterContext_assignment_simple_left() {
IndexExpression expression = AstFactory.indexExpression(
AstFactory.identifier3("a"),
AstFactory.identifier3("b"));
// a[b] = c
AstFactory.assignmentExpression(
expression,
TokenType.EQ,
AstFactory.identifier3("c"));
expect(expression.inGetterContext(), isFalse);
}
void test_inGetterContext_nonAssignment() {
IndexExpression expression = AstFactory.indexExpression(
AstFactory.identifier3("a"),
AstFactory.identifier3("b"));
// a[b] + c
AstFactory.binaryExpression(
expression,
TokenType.PLUS,
AstFactory.identifier3("c"));
expect(expression.inGetterContext(), isTrue);
}
void test_inSetterContext_assignment_compound_left() {
IndexExpression expression = AstFactory.indexExpression(
AstFactory.identifier3("a"),
AstFactory.identifier3("b"));
// a[b] += c
AstFactory.assignmentExpression(
expression,
TokenType.PLUS_EQ,
AstFactory.identifier3("c"));
expect(expression.inSetterContext(), isTrue);
}
void test_inSetterContext_assignment_compound_right() {
IndexExpression expression = AstFactory.indexExpression(
AstFactory.identifier3("a"),
AstFactory.identifier3("b"));
// c += a[b]
AstFactory.assignmentExpression(
AstFactory.identifier3("c"),
TokenType.PLUS_EQ,
expression);
expect(expression.inSetterContext(), isFalse);
}
void test_inSetterContext_assignment_simple_left() {
IndexExpression expression = AstFactory.indexExpression(
AstFactory.identifier3("a"),
AstFactory.identifier3("b"));
// a[b] = c
AstFactory.assignmentExpression(
expression,
TokenType.EQ,
AstFactory.identifier3("c"));
expect(expression.inSetterContext(), isTrue);
}
void test_inSetterContext_assignment_simple_right() {
IndexExpression expression = AstFactory.indexExpression(
AstFactory.identifier3("a"),
AstFactory.identifier3("b"));
// c = a[b]
AstFactory.assignmentExpression(
AstFactory.identifier3("c"),
TokenType.EQ,
expression);
expect(expression.inSetterContext(), isFalse);
}
void test_inSetterContext_nonAssignment() {
IndexExpression expression = AstFactory.indexExpression(
AstFactory.identifier3("a"),
AstFactory.identifier3("b"));
AstFactory.binaryExpression(
expression,
TokenType.PLUS,
AstFactory.identifier3("c"));
// a[b] + cc
expect(expression.inSetterContext(), isFalse);
}
void test_inSetterContext_postfix() {
IndexExpression expression = AstFactory.indexExpression(
AstFactory.identifier3("a"),
AstFactory.identifier3("b"));
AstFactory.postfixExpression(expression, TokenType.PLUS_PLUS);
// a[b]++
expect(expression.inSetterContext(), isTrue);
}
void test_inSetterContext_prefix_bang() {
IndexExpression expression = AstFactory.indexExpression(
AstFactory.identifier3("a"),
AstFactory.identifier3("b"));
// !a[b]
AstFactory.prefixExpression(TokenType.BANG, expression);
expect(expression.inSetterContext(), isFalse);
}
void test_inSetterContext_prefix_minusMinus() {
IndexExpression expression = AstFactory.indexExpression(
AstFactory.identifier3("a"),
AstFactory.identifier3("b"));
// --a[b]
AstFactory.prefixExpression(TokenType.MINUS_MINUS, expression);
expect(expression.inSetterContext(), isTrue);
}
void test_inSetterContext_prefix_plusPlus() {
IndexExpression expression = AstFactory.indexExpression(
AstFactory.identifier3("a"),
AstFactory.identifier3("b"));
// ++a[b]
AstFactory.prefixExpression(TokenType.PLUS_PLUS, expression);
expect(expression.inSetterContext(), isTrue);
}
}
@reflectiveTest
class NodeListTest extends EngineTestCase {
void test_add() {
AstNode parent = AstFactory.argumentList();
AstNode firstNode = AstFactory.booleanLiteral(true);
AstNode secondNode = AstFactory.booleanLiteral(false);
NodeList<AstNode> list = new NodeList<AstNode>(parent);
list.insert(0, secondNode);
list.insert(0, firstNode);
expect(list, hasLength(2));
expect(list[0], same(firstNode));
expect(list[1], same(secondNode));
expect(firstNode.parent, same(parent));
expect(secondNode.parent, same(parent));
AstNode thirdNode = AstFactory.booleanLiteral(false);
list.insert(1, thirdNode);
expect(list, hasLength(3));
expect(list[0], same(firstNode));
expect(list[1], same(thirdNode));
expect(list[2], same(secondNode));
expect(firstNode.parent, same(parent));
expect(secondNode.parent, same(parent));
expect(thirdNode.parent, same(parent));
}
void test_add_negative() {
NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList());
try {
list.insert(-1, AstFactory.booleanLiteral(true));
fail("Expected IndexOutOfBoundsException");
} on RangeError catch (exception) {
// Expected
}
}
void test_add_tooBig() {
NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList());
try {
list.insert(1, AstFactory.booleanLiteral(true));
fail("Expected IndexOutOfBoundsException");
} on RangeError catch (exception) {
// Expected
}
}
void test_addAll() {
AstNode parent = AstFactory.argumentList();
List<AstNode> firstNodes = new List<AstNode>();
AstNode firstNode = AstFactory.booleanLiteral(true);
AstNode secondNode = AstFactory.booleanLiteral(false);
firstNodes.add(firstNode);
firstNodes.add(secondNode);
NodeList<AstNode> list = new NodeList<AstNode>(parent);
list.addAll(firstNodes);
expect(list, hasLength(2));
expect(list[0], same(firstNode));
expect(list[1], same(secondNode));
expect(firstNode.parent, same(parent));
expect(secondNode.parent, same(parent));
List<AstNode> secondNodes = new List<AstNode>();
AstNode thirdNode = AstFactory.booleanLiteral(true);
AstNode fourthNode = AstFactory.booleanLiteral(false);
secondNodes.add(thirdNode);
secondNodes.add(fourthNode);
list.addAll(secondNodes);
expect(list, hasLength(4));
expect(list[0], same(firstNode));
expect(list[1], same(secondNode));
expect(list[2], same(thirdNode));
expect(list[3], same(fourthNode));
expect(firstNode.parent, same(parent));
expect(secondNode.parent, same(parent));
expect(thirdNode.parent, same(parent));
expect(fourthNode.parent, same(parent));
}
void test_creation() {
AstNode owner = AstFactory.argumentList();
NodeList<AstNode> list = new NodeList<AstNode>(owner);
expect(list, isNotNull);
expect(list, hasLength(0));
expect(list.owner, same(owner));
}
void test_get_negative() {
NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList());
try {
list[-1];
fail("Expected IndexOutOfBoundsException");
} on RangeError catch (exception) {
// Expected
}
}
void test_get_tooBig() {
NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList());
try {
list[1];
fail("Expected IndexOutOfBoundsException");
} on RangeError catch (exception) {
// Expected
}
}
void test_getBeginToken_empty() {
NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList());
expect(list.beginToken, isNull);
}
void test_getBeginToken_nonEmpty() {
NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList());
AstNode node =
AstFactory.parenthesizedExpression(AstFactory.booleanLiteral(true));
list.add(node);
expect(list.beginToken, same(node.beginToken));
}
void test_getEndToken_empty() {
NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList());
expect(list.endToken, isNull);
}
void test_getEndToken_nonEmpty() {
NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList());
AstNode node =
AstFactory.parenthesizedExpression(AstFactory.booleanLiteral(true));
list.add(node);
expect(list.endToken, same(node.endToken));
}
void test_indexOf() {
List<AstNode> nodes = new List<AstNode>();
AstNode firstNode = AstFactory.booleanLiteral(true);
AstNode secondNode = AstFactory.booleanLiteral(false);
AstNode thirdNode = AstFactory.booleanLiteral(true);
AstNode fourthNode = AstFactory.booleanLiteral(false);
nodes.add(firstNode);
nodes.add(secondNode);
nodes.add(thirdNode);
NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList());
list.addAll(nodes);
expect(list, hasLength(3));
expect(list.indexOf(firstNode), 0);
expect(list.indexOf(secondNode), 1);
expect(list.indexOf(thirdNode), 2);
expect(list.indexOf(fourthNode), -1);
expect(list.indexOf(null), -1);
}
void test_remove() {
List<AstNode> nodes = new List<AstNode>();
AstNode firstNode = AstFactory.booleanLiteral(true);
AstNode secondNode = AstFactory.booleanLiteral(false);
AstNode thirdNode = AstFactory.booleanLiteral(true);
nodes.add(firstNode);
nodes.add(secondNode);
nodes.add(thirdNode);
NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList());
list.addAll(nodes);
expect(list, hasLength(3));
expect(list.removeAt(1), same(secondNode));
expect(list, hasLength(2));
expect(list[0], same(firstNode));
expect(list[1], same(thirdNode));
}
void test_remove_negative() {
NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList());
try {
list.removeAt(-1);
fail("Expected IndexOutOfBoundsException");
} on RangeError catch (exception) {
// Expected
}
}
void test_remove_tooBig() {
NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList());
try {
list.removeAt(1);
fail("Expected IndexOutOfBoundsException");
} on RangeError catch (exception) {
// Expected
}
}
void test_set() {
List<AstNode> nodes = new List<AstNode>();
AstNode firstNode = AstFactory.booleanLiteral(true);
AstNode secondNode = AstFactory.booleanLiteral(false);
AstNode thirdNode = AstFactory.booleanLiteral(true);
nodes.add(firstNode);
nodes.add(secondNode);
nodes.add(thirdNode);
NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList());
list.addAll(nodes);
expect(list, hasLength(3));
AstNode fourthNode = AstFactory.integer(0);
expect(javaListSet(list, 1, fourthNode), same(secondNode));
expect(list, hasLength(3));
expect(list[0], same(firstNode));
expect(list[1], same(fourthNode));
expect(list[2], same(thirdNode));
}
void test_set_negative() {
AstNode node = AstFactory.booleanLiteral(true);
NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList());
try {
javaListSet(list, -1, node);
fail("Expected IndexOutOfBoundsException");
} on RangeError catch (exception) {
// Expected
}
}
void test_set_tooBig() {
AstNode node = AstFactory.booleanLiteral(true);
NodeList<AstNode> list = new NodeList<AstNode>(AstFactory.argumentList());
try {
javaListSet(list, 1, node);
fail("Expected IndexOutOfBoundsException");
} on RangeError catch (exception) {
// Expected
}
}
}
@reflectiveTest
class NodeLocatorTest extends ParserTestCase {
void test_range() {
CompilationUnit unit =
ParserTestCase.parseCompilationUnit("library myLib;");
_assertLocate(
unit,
4,
10,
(node) => node is LibraryDirective,
LibraryDirective);
}
void test_searchWithin_null() {
NodeLocator locator = new NodeLocator.con2(0, 0);
expect(locator.searchWithin(null), isNull);
}
void test_searchWithin_offset() {
CompilationUnit unit =
ParserTestCase.parseCompilationUnit("library myLib;");
_assertLocate(
unit,
10,
10,
(node) => node is SimpleIdentifier,
SimpleIdentifier);
}
void test_searchWithin_offsetAfterNode() {
CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
class A {}
class B {}''');
NodeLocator locator = new NodeLocator.con2(1024, 1024);
AstNode node = locator.searchWithin(unit.declarations[0]);
expect(node, isNull);
}
void test_searchWithin_offsetBeforeNode() {
CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
class A {}
class B {}''');
NodeLocator locator = new NodeLocator.con2(0, 0);
AstNode node = locator.searchWithin(unit.declarations[1]);
expect(node, isNull);
}
void _assertLocate(CompilationUnit unit, int start, int end,
Predicate<AstNode> predicate, Type expectedClass) {
NodeLocator locator = new NodeLocator.con2(start, end);
AstNode node = locator.searchWithin(unit);
expect(node, isNotNull);
expect(locator.foundNode, same(node));
expect(node.offset <= start, isTrue, reason: "Node starts after range");
expect(
node.offset + node.length > end,
isTrue,
reason: "Node ends before range");
EngineTestCase.assertInstanceOf(predicate, expectedClass, node);
}
}
@reflectiveTest
class SimpleIdentifierTest extends ParserTestCase {
void test_inDeclarationContext_catch_exception() {
SimpleIdentifier identifier =
AstFactory.catchClause("e").exceptionParameter;
expect(identifier.inDeclarationContext(), isTrue);
}
void test_inDeclarationContext_catch_stack() {
SimpleIdentifier identifier =
AstFactory.catchClause2("e", "s").stackTraceParameter;
expect(identifier.inDeclarationContext(), isTrue);
}
void test_inDeclarationContext_classDeclaration() {
SimpleIdentifier identifier =
AstFactory.classDeclaration(null, "C", null, null, null, null).name;
expect(identifier.inDeclarationContext(), isTrue);
}
void test_inDeclarationContext_classTypeAlias() {
SimpleIdentifier identifier =
AstFactory.classTypeAlias("C", null, null, null, null, null).name;
expect(identifier.inDeclarationContext(), isTrue);
}
void test_inDeclarationContext_constructorDeclaration() {
SimpleIdentifier identifier = AstFactory.constructorDeclaration(
AstFactory.identifier3("C"),
"c",
null,
null).name;
expect(identifier.inDeclarationContext(), isTrue);
}
void test_inDeclarationContext_declaredIdentifier() {
DeclaredIdentifier declaredIdentifier = AstFactory.declaredIdentifier3("v");
SimpleIdentifier identifier = declaredIdentifier.identifier;
expect(identifier.inDeclarationContext(), isTrue);
}
void test_inDeclarationContext_enumConstantDeclaration() {
EnumDeclaration enumDeclaration =
AstFactory.enumDeclaration2('MyEnum', ['CONST']);
SimpleIdentifier identifier = enumDeclaration.constants[0].name;
expect(identifier.inDeclarationContext(), isTrue);
}
void test_inDeclarationContext_enumDeclaration() {
EnumDeclaration enumDeclaration =
AstFactory.enumDeclaration2('MyEnum', ['A', 'B', 'C']);
SimpleIdentifier identifier = enumDeclaration.name;
expect(identifier.inDeclarationContext(), isTrue);
}
void test_inDeclarationContext_fieldFormalParameter() {
SimpleIdentifier identifier =
AstFactory.fieldFormalParameter2("p").identifier;
expect(identifier.inDeclarationContext(), isFalse);
}
void test_inDeclarationContext_functionDeclaration() {
SimpleIdentifier identifier =
AstFactory.functionDeclaration(null, null, "f", null).name;
expect(identifier.inDeclarationContext(), isTrue);
}
void test_inDeclarationContext_functionTypeAlias() {
SimpleIdentifier identifier =
AstFactory.typeAlias(null, "F", null, null).name;
expect(identifier.inDeclarationContext(), isTrue);
}
void test_inDeclarationContext_label_false() {
SimpleIdentifier identifier =
AstFactory.namedExpression2("l", AstFactory.integer(0)).name.label;
expect(identifier.inDeclarationContext(), isFalse);
}
void test_inDeclarationContext_label_true() {
Label label = AstFactory.label2("l");
SimpleIdentifier identifier = label.label;
AstFactory.labeledStatement([label], AstFactory.emptyStatement());
expect(identifier.inDeclarationContext(), isTrue);
}
void test_inDeclarationContext_methodDeclaration() {
SimpleIdentifier identifier = AstFactory.identifier3("m");
AstFactory.methodDeclaration2(
null,
null,
null,
null,
identifier,
null,
null);
expect(identifier.inDeclarationContext(), isTrue);
}
void test_inDeclarationContext_prefix() {
SimpleIdentifier identifier =
AstFactory.importDirective3("uri", "pref").prefix;
expect(identifier.inDeclarationContext(), isTrue);
}
void test_inDeclarationContext_simpleFormalParameter() {
SimpleIdentifier identifier =
AstFactory.simpleFormalParameter3("p").identifier;
expect(identifier.inDeclarationContext(), isTrue);
}
void test_inDeclarationContext_typeParameter_bound() {
TypeName bound = AstFactory.typeName4("A");
SimpleIdentifier identifier = bound.name as SimpleIdentifier;
AstFactory.typeParameter2("E", bound);
expect(identifier.inDeclarationContext(), isFalse);
}
void test_inDeclarationContext_typeParameter_name() {
SimpleIdentifier identifier = AstFactory.typeParameter("E").name;
expect(identifier.inDeclarationContext(), isTrue);
}
void test_inDeclarationContext_variableDeclaration() {
SimpleIdentifier identifier = AstFactory.variableDeclaration("v").name;
expect(identifier.inDeclarationContext(), isTrue);
}
void test_inGetterContext() {
for (WrapperKind wrapper in WrapperKind.values) {
for (AssignmentKind assignment in AssignmentKind.values) {
SimpleIdentifier identifier = _createIdentifier(wrapper, assignment);
if (assignment == AssignmentKind.SIMPLE_LEFT &&
wrapper != WrapperKind.PREFIXED_LEFT &&
wrapper != WrapperKind.PROPERTY_LEFT) {
if (identifier.inGetterContext()) {
fail("Expected ${_topMostNode(identifier).toSource()} to be false");
}
} else {
if (!identifier.inGetterContext()) {
fail("Expected ${_topMostNode(identifier).toSource()} to be true");
}
}
}
}
}
void test_inGetterContext_forEachLoop() {
SimpleIdentifier identifier = AstFactory.identifier3("a");
Expression iterator = AstFactory.listLiteral();
Statement body = AstFactory.block();
AstFactory.forEachStatement2(identifier, iterator, body);
expect(identifier.inGetterContext(), isFalse);
}
void test_inReferenceContext() {
SimpleIdentifier identifier = AstFactory.identifier3("id");
AstFactory.namedExpression(
AstFactory.label(identifier),
AstFactory.identifier3("_"));
expect(identifier.inGetterContext(), isFalse);
expect(identifier.inSetterContext(), isFalse);
}
void test_inSetterContext() {
for (WrapperKind wrapper in WrapperKind.values) {
for (AssignmentKind assignment in AssignmentKind.values) {
SimpleIdentifier identifier = _createIdentifier(wrapper, assignment);
if (wrapper == WrapperKind.PREFIXED_LEFT ||
wrapper == WrapperKind.PROPERTY_LEFT ||
assignment == AssignmentKind.BINARY ||
assignment == AssignmentKind.COMPOUND_RIGHT ||
assignment == AssignmentKind.PREFIX_NOT ||
assignment == AssignmentKind.SIMPLE_RIGHT ||
assignment == AssignmentKind.NONE) {
if (identifier.inSetterContext()) {
fail("Expected ${_topMostNode(identifier).toSource()} to be false");
}
} else {
if (!identifier.inSetterContext()) {
fail("Expected ${_topMostNode(identifier).toSource()} to be true");
}
}
}
}
}
void test_inSetterContext_forEachLoop() {
SimpleIdentifier identifier = AstFactory.identifier3("a");
Expression iterator = AstFactory.listLiteral();
Statement body = AstFactory.block();
AstFactory.forEachStatement2(identifier, iterator, body);
expect(identifier.inSetterContext(), isTrue);
}
void test_isQualified_inMethodInvocation_noTarget() {
MethodInvocation invocation =
AstFactory.methodInvocation2("test", [AstFactory.identifier3("arg0")]);
SimpleIdentifier identifier = invocation.methodName;
expect(identifier.isQualified, isFalse);
}
void test_isQualified_inMethodInvocation_withTarget() {
MethodInvocation invocation = AstFactory.methodInvocation(
AstFactory.identifier3("target"),
"test",
[AstFactory.identifier3("arg0")]);
SimpleIdentifier identifier = invocation.methodName;
expect(identifier.isQualified, isTrue);
}
void test_isQualified_inPrefixedIdentifier_name() {
SimpleIdentifier identifier = AstFactory.identifier3("test");
AstFactory.identifier4("prefix", identifier);
expect(identifier.isQualified, isTrue);
}
void test_isQualified_inPrefixedIdentifier_prefix() {
SimpleIdentifier identifier = AstFactory.identifier3("test");
AstFactory.identifier(identifier, AstFactory.identifier3("name"));
expect(identifier.isQualified, isFalse);
}
void test_isQualified_inPropertyAccess_name() {
SimpleIdentifier identifier = AstFactory.identifier3("test");
AstFactory.propertyAccess(AstFactory.identifier3("target"), identifier);
expect(identifier.isQualified, isTrue);
}
void test_isQualified_inPropertyAccess_target() {
SimpleIdentifier identifier = AstFactory.identifier3("test");
AstFactory.propertyAccess(identifier, AstFactory.identifier3("name"));
expect(identifier.isQualified, isFalse);
}
void test_isQualified_inReturnStatement() {
SimpleIdentifier identifier = AstFactory.identifier3("test");
AstFactory.returnStatement2(identifier);
expect(identifier.isQualified, isFalse);
}
SimpleIdentifier _createIdentifier(WrapperKind wrapper,
AssignmentKind assignment) {
SimpleIdentifier identifier = AstFactory.identifier3("a");
Expression expression = identifier;
while (true) {
if (wrapper == WrapperKind.PREFIXED_LEFT) {
expression =
AstFactory.identifier(identifier, AstFactory.identifier3("_"));
} else if (wrapper == WrapperKind.PREFIXED_RIGHT) {
expression =
AstFactory.identifier(AstFactory.identifier3("_"), identifier);
} else if (wrapper == WrapperKind.PROPERTY_LEFT) {
expression = AstFactory.propertyAccess2(expression, "_");
} else if (wrapper == WrapperKind.PROPERTY_RIGHT) {
expression =
AstFactory.propertyAccess(AstFactory.identifier3("_"), identifier);
} else if (wrapper == WrapperKind.NONE) {
}
break;
}
while (true) {
if (assignment == AssignmentKind.BINARY) {
AstFactory.binaryExpression(
expression,
TokenType.PLUS,
AstFactory.identifier3("_"));
} else if (assignment == AssignmentKind.COMPOUND_LEFT) {
AstFactory.assignmentExpression(
expression,
TokenType.PLUS_EQ,
AstFactory.identifier3("_"));
} else if (assignment == AssignmentKind.COMPOUND_RIGHT) {
AstFactory.assignmentExpression(
AstFactory.identifier3("_"),
TokenType.PLUS_EQ,
expression);
} else if (assignment == AssignmentKind.POSTFIX_INC) {
AstFactory.postfixExpression(expression, TokenType.PLUS_PLUS);
} else if (assignment == AssignmentKind.PREFIX_DEC) {
AstFactory.prefixExpression(TokenType.MINUS_MINUS, expression);
} else if (assignment == AssignmentKind.PREFIX_INC) {
AstFactory.prefixExpression(TokenType.PLUS_PLUS, expression);
} else if (assignment == AssignmentKind.PREFIX_NOT) {
AstFactory.prefixExpression(TokenType.BANG, expression);
} else if (assignment == AssignmentKind.SIMPLE_LEFT) {
AstFactory.assignmentExpression(
expression,
TokenType.EQ,
AstFactory.identifier3("_"));
} else if (assignment == AssignmentKind.SIMPLE_RIGHT) {
AstFactory.assignmentExpression(
AstFactory.identifier3("_"),
TokenType.EQ,
expression);
} else if (assignment == AssignmentKind.NONE) {
}
break;
}
return identifier;
}
/**
* Return the top-most node in the AST structure containing the given identifier.
*
* @param identifier the identifier in the AST structure being traversed
* @return the root of the AST structure containing the identifier
*/
AstNode _topMostNode(SimpleIdentifier identifier) {
AstNode child = identifier;
AstNode parent = identifier.parent;
while (parent != null) {
child = parent;
parent = parent.parent;
}
return child;
}
}
@reflectiveTest
class SimpleStringLiteralTest extends ParserTestCase {
void test_contentsEnd() {
expect(
new SimpleStringLiteral(TokenFactory.tokenFromString("'X'"), "X").contentsEnd,
2);
expect(
new SimpleStringLiteral(TokenFactory.tokenFromString("\"X\""), "X").contentsEnd,
2);
expect(
new SimpleStringLiteral(
TokenFactory.tokenFromString("\"\"\"X\"\"\""),
"X").contentsEnd,
4);
expect(
new SimpleStringLiteral(
TokenFactory.tokenFromString("'''X'''"),
"X").contentsEnd,
4);
expect(
new SimpleStringLiteral(TokenFactory.tokenFromString("r'X'"), "X").contentsEnd,
3);
expect(
new SimpleStringLiteral(
TokenFactory.tokenFromString("r\"X\""),
"X").contentsEnd,
3);
expect(
new SimpleStringLiteral(
TokenFactory.tokenFromString("r\"\"\"X\"\"\""),
"X").contentsEnd,
5);
expect(
new SimpleStringLiteral(
TokenFactory.tokenFromString("r'''X'''"),
"X").contentsEnd,
5);
}
void test_contentsOffset() {
expect(
new SimpleStringLiteral(
TokenFactory.tokenFromString("'X'"),
"X").contentsOffset,
1);
expect(
new SimpleStringLiteral(
TokenFactory.tokenFromString("\"X\""),
"X").contentsOffset,
1);
expect(
new SimpleStringLiteral(
TokenFactory.tokenFromString("\"\"\"X\"\"\""),
"X").contentsOffset,
3);
expect(
new SimpleStringLiteral(
TokenFactory.tokenFromString("'''X'''"),
"X").contentsOffset,
3);
expect(
new SimpleStringLiteral(
TokenFactory.tokenFromString("r'X'"),
"X").contentsOffset,
2);
expect(
new SimpleStringLiteral(
TokenFactory.tokenFromString("r\"X\""),
"X").contentsOffset,
2);
expect(
new SimpleStringLiteral(
TokenFactory.tokenFromString("r\"\"\"X\"\"\""),
"X").contentsOffset,
4);
expect(
new SimpleStringLiteral(
TokenFactory.tokenFromString("r'''X'''"),
"X").contentsOffset,
4);
}
void test_isMultiline() {
expect(
new SimpleStringLiteral(TokenFactory.tokenFromString("'X'"), "X").isMultiline,
isFalse);
expect(
new SimpleStringLiteral(TokenFactory.tokenFromString("r'X'"), "X").isMultiline,
isFalse);
expect(
new SimpleStringLiteral(TokenFactory.tokenFromString("\"X\""), "X").isMultiline,
isFalse);
expect(
new SimpleStringLiteral(
TokenFactory.tokenFromString("r\"X\""),
"X").isMultiline,
isFalse);
expect(
new SimpleStringLiteral(
TokenFactory.tokenFromString("'''X'''"),
"X").isMultiline,
isTrue);
expect(
new SimpleStringLiteral(
TokenFactory.tokenFromString("r'''X'''"),
"X").isMultiline,
isTrue);
expect(
new SimpleStringLiteral(
TokenFactory.tokenFromString("\"\"\"X\"\"\""),
"X").isMultiline,
isTrue);
expect(
new SimpleStringLiteral(
TokenFactory.tokenFromString("r\"\"\"X\"\"\""),
"X").isMultiline,
isTrue);
}
void test_isRaw() {
expect(
new SimpleStringLiteral(TokenFactory.tokenFromString("'X'"), "X").isRaw,
isFalse);
expect(
new SimpleStringLiteral(TokenFactory.tokenFromString("\"X\""), "X").isRaw,
isFalse);
expect(
new SimpleStringLiteral(
TokenFactory.tokenFromString("\"\"\"X\"\"\""),
"X").isRaw,
isFalse);
expect(
new SimpleStringLiteral(TokenFactory.tokenFromString("'''X'''"), "X").isRaw,
isFalse);
expect(
new SimpleStringLiteral(TokenFactory.tokenFromString("r'X'"), "X").isRaw,
isTrue);
expect(
new SimpleStringLiteral(TokenFactory.tokenFromString("r\"X\""), "X").isRaw,
isTrue);
expect(
new SimpleStringLiteral(
TokenFactory.tokenFromString("r\"\"\"X\"\"\""),
"X").isRaw,
isTrue);
expect(
new SimpleStringLiteral(TokenFactory.tokenFromString("r'''X'''"), "X").isRaw,
isTrue);
}
void test_isSingleQuoted() {
// '
{
var token = TokenFactory.tokenFromString("'X'");
var node = new SimpleStringLiteral(token, null);
expect(node.isSingleQuoted, isTrue);
}
// '''
{
var token = TokenFactory.tokenFromString("'''X'''");
var node = new SimpleStringLiteral(token, null);
expect(node.isSingleQuoted, isTrue);
}
// "
{
var token = TokenFactory.tokenFromString('"X"');
var node = new SimpleStringLiteral(token, null);
expect(node.isSingleQuoted, isFalse);
}
// """
{
var token = TokenFactory.tokenFromString('"""X"""');
var node = new SimpleStringLiteral(token, null);
expect(node.isSingleQuoted, isFalse);
}
}
void test_isSingleQuoted_raw() {
// r'
{
var token = TokenFactory.tokenFromString("r'X'");
var node = new SimpleStringLiteral(token, null);
expect(node.isSingleQuoted, isTrue);
}
// r'''
{
var token = TokenFactory.tokenFromString("r'''X'''");
var node = new SimpleStringLiteral(token, null);
expect(node.isSingleQuoted, isTrue);
}
// r"
{
var token = TokenFactory.tokenFromString('r"X"');
var node = new SimpleStringLiteral(token, null);
expect(node.isSingleQuoted, isFalse);
}
// r"""
{
var token = TokenFactory.tokenFromString('r"""X"""');
var node = new SimpleStringLiteral(token, null);
expect(node.isSingleQuoted, isFalse);
}
}
void test_simple() {
Token token = TokenFactory.tokenFromString("'value'");
SimpleStringLiteral stringLiteral = new SimpleStringLiteral(token, "value");
expect(stringLiteral.literal, same(token));
expect(stringLiteral.beginToken, same(token));
expect(stringLiteral.endToken, same(token));
expect(stringLiteral.value, "value");
}
}
@reflectiveTest
class StringInterpolationTest extends ParserTestCase {
void test_contentsOffsetEnd() {
AstFactory.interpolationExpression(AstFactory.identifier3('bb'));
// 'a${bb}ccc'
{
var ae = AstFactory.interpolationString("'a", "a");
var cToken = new StringToken(TokenType.STRING, "ccc'", 10);
var cElement = new InterpolationString(cToken, 'ccc');
StringInterpolation node = AstFactory.string([ae, ae, cElement]);
expect(node.contentsOffset, 1);
expect(node.contentsEnd, 10 + 4 - 1);
}
// '''a${bb}ccc'''
{
var ae = AstFactory.interpolationString("'''a", "a");
var cToken = new StringToken(TokenType.STRING, "ccc'''", 10);
var cElement = new InterpolationString(cToken, 'ccc');
StringInterpolation node = AstFactory.string([ae, ae, cElement]);
expect(node.contentsOffset, 3);
expect(node.contentsEnd, 10 + 4 - 1);
}
// """a${bb}ccc"""
{
var ae = AstFactory.interpolationString('"""a', "a");
var cToken = new StringToken(TokenType.STRING, 'ccc"""', 10);
var cElement = new InterpolationString(cToken, 'ccc');
StringInterpolation node = AstFactory.string([ae, ae, cElement]);
expect(node.contentsOffset, 3);
expect(node.contentsEnd, 10 + 4 - 1);
}
// r'a${bb}ccc'
{
var ae = AstFactory.interpolationString("r'a", "a");
var cToken = new StringToken(TokenType.STRING, "ccc'", 10);
var cElement = new InterpolationString(cToken, 'ccc');
StringInterpolation node = AstFactory.string([ae, ae, cElement]);
expect(node.contentsOffset, 2);
expect(node.contentsEnd, 10 + 4 - 1);
}
// r'''a${bb}ccc'''
{
var ae = AstFactory.interpolationString("r'''a", "a");
var cToken = new StringToken(TokenType.STRING, "ccc'''", 10);
var cElement = new InterpolationString(cToken, 'ccc');
StringInterpolation node = AstFactory.string([ae, ae, cElement]);
expect(node.contentsOffset, 4);
expect(node.contentsEnd, 10 + 4 - 1);
}
// r"""a${bb}ccc"""
{
var ae = AstFactory.interpolationString('r"""a', "a");
var cToken = new StringToken(TokenType.STRING, 'ccc"""', 10);
var cElement = new InterpolationString(cToken, 'ccc');
StringInterpolation node = AstFactory.string([ae, ae, cElement]);
expect(node.contentsOffset, 4);
expect(node.contentsEnd, 10 + 4 - 1);
}
}
void test_isMultiline() {
var b = AstFactory.interpolationExpression(AstFactory.identifier3('bb'));
// '
{
var a = AstFactory.interpolationString("'a", "a");
var c = AstFactory.interpolationString("ccc'", "ccc");
StringInterpolation node = AstFactory.string([a, b, c]);
expect(node.isMultiline, isFalse);
}
// '''
{
var a = AstFactory.interpolationString("'''a", "a");
var c = AstFactory.interpolationString("ccc'''", "ccc");
StringInterpolation node = AstFactory.string([a, b, c]);
expect(node.isMultiline, isTrue);
}
// "
{
var a = AstFactory.interpolationString('"a', "a");
var c = AstFactory.interpolationString('ccc"', "ccc");
StringInterpolation node = AstFactory.string([a, b, c]);
expect(node.isMultiline, isFalse);
}
// """
{
var a = AstFactory.interpolationString('"""a', "a");
var c = AstFactory.interpolationString('ccc"""', "ccc");
StringInterpolation node = AstFactory.string([a, b, c]);
expect(node.isMultiline, isTrue);
}
}
void test_isRaw() {
StringInterpolation node = AstFactory.string();
expect(node.isRaw, isFalse);
}
void test_isSingleQuoted() {
var b = AstFactory.interpolationExpression(AstFactory.identifier3('bb'));
// "
{
var a = AstFactory.interpolationString('"a', "a");
var c = AstFactory.interpolationString('ccc"', "ccc");
StringInterpolation node = AstFactory.string([a, b, c]);
expect(node.isSingleQuoted, isFalse);
}
// """
{
var a = AstFactory.interpolationString('"""a', "a");
var c = AstFactory.interpolationString('ccc"""', "ccc");
StringInterpolation node = AstFactory.string([a, b, c]);
expect(node.isSingleQuoted, isFalse);
}
// '
{
var a = AstFactory.interpolationString("'a", "a");
var c = AstFactory.interpolationString("ccc'", "ccc");
StringInterpolation node = AstFactory.string([a, b, c]);
expect(node.isSingleQuoted, isTrue);
}
// '''
{
var a = AstFactory.interpolationString("'''a", "a");
var c = AstFactory.interpolationString("ccc'''", "ccc");
StringInterpolation node = AstFactory.string([a, b, c]);
expect(node.isSingleQuoted, isTrue);
}
}
}
@reflectiveTest
class ToSourceVisitorTest extends EngineTestCase {
void test_visitAdjacentStrings() {
_assertSource(
"'a' 'b'",
AstFactory.adjacentStrings([AstFactory.string2("a"), AstFactory.string2("b")]));
}
void test_visitAnnotation_constant() {
_assertSource("@A", AstFactory.annotation(AstFactory.identifier3("A")));
}
void test_visitAnnotation_constructor() {
_assertSource(
"@A.c()",
AstFactory.annotation2(
AstFactory.identifier3("A"),
AstFactory.identifier3("c"),
AstFactory.argumentList()));
}
void test_visitArgumentList() {
_assertSource(
"(a, b)",
AstFactory.argumentList(
[AstFactory.identifier3("a"), AstFactory.identifier3("b")]));
}
void test_visitAsExpression() {
_assertSource(
"e as T",
AstFactory.asExpression(
AstFactory.identifier3("e"),
AstFactory.typeName4("T")));
}
void test_visitAssertStatement() {
_assertSource(
"assert (a);",
AstFactory.assertStatement(AstFactory.identifier3("a")));
}
void test_visitAssignmentExpression() {
_assertSource(
"a = b",
AstFactory.assignmentExpression(
AstFactory.identifier3("a"),
TokenType.EQ,
AstFactory.identifier3("b")));
}
void test_visitAwaitExpression() {
_assertSource(
"await e;",
AstFactory.awaitExpression(AstFactory.identifier3("e")));
}
void test_visitBinaryExpression() {
_assertSource(
"a + b",
AstFactory.binaryExpression(
AstFactory.identifier3("a"),
TokenType.PLUS,
AstFactory.identifier3("b")));
}
void test_visitBlock_empty() {
_assertSource("{}", AstFactory.block());
}
void test_visitBlock_nonEmpty() {
_assertSource(
"{break; break;}",
AstFactory.block([AstFactory.breakStatement(), AstFactory.breakStatement()]));
}
void test_visitBlockFunctionBody_async() {
_assertSource("async {}", AstFactory.asyncBlockFunctionBody());
}
void test_visitBlockFunctionBody_async_star() {
_assertSource("async* {}", AstFactory.asyncGeneratorBlockFunctionBody());
}
void test_visitBlockFunctionBody_simple() {
_assertSource("{}", AstFactory.blockFunctionBody2());
}
void test_visitBlockFunctionBody_sync() {
_assertSource("sync {}", AstFactory.syncBlockFunctionBody());
}
void test_visitBlockFunctionBody_sync_star() {
_assertSource("sync* {}", AstFactory.syncGeneratorBlockFunctionBody());
}
void test_visitBooleanLiteral_false() {
_assertSource("false", AstFactory.booleanLiteral(false));
}
void test_visitBooleanLiteral_true() {
_assertSource("true", AstFactory.booleanLiteral(true));
}
void test_visitBreakStatement_label() {
_assertSource("break l;", AstFactory.breakStatement2("l"));
}
void test_visitBreakStatement_noLabel() {
_assertSource("break;", AstFactory.breakStatement());
}
void test_visitCascadeExpression_field() {
_assertSource(
"a..b..c",
AstFactory.cascadeExpression(
AstFactory.identifier3("a"),
[
AstFactory.cascadedPropertyAccess("b"),
AstFactory.cascadedPropertyAccess("c")]));
}
void test_visitCascadeExpression_index() {
_assertSource(
"a..[0]..[1]",
AstFactory.cascadeExpression(
AstFactory.identifier3("a"),
[
AstFactory.cascadedIndexExpression(AstFactory.integer(0)),
AstFactory.cascadedIndexExpression(AstFactory.integer(1))]));
}
void test_visitCascadeExpression_method() {
_assertSource(
"a..b()..c()",
AstFactory.cascadeExpression(
AstFactory.identifier3("a"),
[
AstFactory.cascadedMethodInvocation("b"),
AstFactory.cascadedMethodInvocation("c")]));
}
void test_visitCatchClause_catch_noStack() {
_assertSource("catch (e) {}", AstFactory.catchClause("e"));
}
void test_visitCatchClause_catch_stack() {
_assertSource("catch (e, s) {}", AstFactory.catchClause2("e", "s"));
}
void test_visitCatchClause_on() {
_assertSource(
"on E {}",
AstFactory.catchClause3(AstFactory.typeName4("E")));
}
void test_visitCatchClause_on_catch() {
_assertSource(
"on E catch (e) {}",
AstFactory.catchClause4(AstFactory.typeName4("E"), "e"));
}
void test_visitClassDeclaration_abstract() {
_assertSource(
"abstract class C {}",
AstFactory.classDeclaration(Keyword.ABSTRACT, "C", null, null, null, null));
}
void test_visitClassDeclaration_empty() {
_assertSource(
"class C {}",
AstFactory.classDeclaration(null, "C", null, null, null, null));
}
void test_visitClassDeclaration_extends() {
_assertSource(
"class C extends A {}",
AstFactory.classDeclaration(
null,
"C",
null,
AstFactory.extendsClause(AstFactory.typeName4("A")),
null,
null));
}
void test_visitClassDeclaration_extends_implements() {
_assertSource(
"class C extends A implements B {}",
AstFactory.classDeclaration(
null,
"C",
null,
AstFactory.extendsClause(AstFactory.typeName4("A")),
null,
AstFactory.implementsClause([AstFactory.typeName4("B")])));
}
void test_visitClassDeclaration_extends_with() {
_assertSource(
"class C extends A with M {}",
AstFactory.classDeclaration(
null,
"C",
null,
AstFactory.extendsClause(AstFactory.typeName4("A")),
AstFactory.withClause([AstFactory.typeName4("M")]),
null));
}
void test_visitClassDeclaration_extends_with_implements() {
_assertSource(
"class C extends A with M implements B {}",
AstFactory.classDeclaration(
null,
"C",
null,
AstFactory.extendsClause(AstFactory.typeName4("A")),
AstFactory.withClause([AstFactory.typeName4("M")]),
AstFactory.implementsClause([AstFactory.typeName4("B")])));
}
void test_visitClassDeclaration_implements() {
_assertSource(
"class C implements B {}",
AstFactory.classDeclaration(
null,
"C",
null,
null,
null,
AstFactory.implementsClause([AstFactory.typeName4("B")])));
}
void test_visitClassDeclaration_multipleMember() {
_assertSource(
"class C {var a; var b;}",
AstFactory.classDeclaration(
null,
"C",
null,
null,
null,
null,
[
AstFactory.fieldDeclaration2(
false,
Keyword.VAR,
[AstFactory.variableDeclaration("a")]),
AstFactory.fieldDeclaration2(
false,
Keyword.VAR,
[AstFactory.variableDeclaration("b")])]));
}
void test_visitClassDeclaration_parameters() {
_assertSource(
"class C<E> {}",
AstFactory.classDeclaration(
null,
"C",
AstFactory.typeParameterList(["E"]),
null,
null,
null));
}
void test_visitClassDeclaration_parameters_extends() {
_assertSource(
"class C<E> extends A {}",
AstFactory.classDeclaration(
null,
"C",
AstFactory.typeParameterList(["E"]),
AstFactory.extendsClause(AstFactory.typeName4("A")),
null,
null));
}
void test_visitClassDeclaration_parameters_extends_implements() {
_assertSource(
"class C<E> extends A implements B {}",
AstFactory.classDeclaration(
null,
"C",
AstFactory.typeParameterList(["E"]),
AstFactory.extendsClause(AstFactory.typeName4("A")),
null,
AstFactory.implementsClause([AstFactory.typeName4("B")])));
}
void test_visitClassDeclaration_parameters_extends_with() {
_assertSource(
"class C<E> extends A with M {}",
AstFactory.classDeclaration(
null,
"C",
AstFactory.typeParameterList(["E"]),
AstFactory.extendsClause(AstFactory.typeName4("A")),
AstFactory.withClause([AstFactory.typeName4("M")]),
null));
}
void test_visitClassDeclaration_parameters_extends_with_implements() {
_assertSource(
"class C<E> extends A with M implements B {}",
AstFactory.classDeclaration(
null,
"C",
AstFactory.typeParameterList(["E"]),
AstFactory.extendsClause(AstFactory.typeName4("A")),
AstFactory.withClause([AstFactory.typeName4("M")]),
AstFactory.implementsClause([AstFactory.typeName4("B")])));
}
void test_visitClassDeclaration_parameters_implements() {
_assertSource(
"class C<E> implements B {}",
AstFactory.classDeclaration(
null,
"C",
AstFactory.typeParameterList(["E"]),
null,
null,
AstFactory.implementsClause([AstFactory.typeName4("B")])));
}
void test_visitClassDeclaration_singleMember() {
_assertSource(
"class C {var a;}",
AstFactory.classDeclaration(
null,
"C",
null,
null,
null,
null,
[
AstFactory.fieldDeclaration2(
false,
Keyword.VAR,
[AstFactory.variableDeclaration("a")])]));
}
void test_visitClassDeclaration_withMetadata() {
ClassDeclaration declaration =
AstFactory.classDeclaration(null, "C", null, null, null, null);
declaration.metadata =
[AstFactory.annotation(AstFactory.identifier3("deprecated"))];
_assertSource("@deprecated class C {}", declaration);
}
void test_visitClassTypeAlias_abstract() {
_assertSource(
"abstract class C = S with M1;",
AstFactory.classTypeAlias(
"C",
null,
Keyword.ABSTRACT,
AstFactory.typeName4("S"),
AstFactory.withClause([AstFactory.typeName4("M1")]),
null));
}
void test_visitClassTypeAlias_abstract_implements() {
_assertSource(
"abstract class C = S with M1 implements I;",
AstFactory.classTypeAlias(
"C",
null,
Keyword.ABSTRACT,
AstFactory.typeName4("S"),
AstFactory.withClause([AstFactory.typeName4("M1")]),
AstFactory.implementsClause([AstFactory.typeName4("I")])));
}
void test_visitClassTypeAlias_generic() {
_assertSource(
"class C<E> = S<E> with M1<E>;",
AstFactory.classTypeAlias(
"C",
AstFactory.typeParameterList(["E"]),
null,
AstFactory.typeName4("S", [AstFactory.typeName4("E")]),
AstFactory.withClause(
[AstFactory.typeName4("M1", [AstFactory.typeName4("E")])]),
null));
}
void test_visitClassTypeAlias_implements() {
_assertSource(
"class C = S with M1 implements I;",
AstFactory.classTypeAlias(
"C",
null,
null,
AstFactory.typeName4("S"),
AstFactory.withClause([AstFactory.typeName4("M1")]),
AstFactory.implementsClause([AstFactory.typeName4("I")])));
}
void test_visitClassTypeAlias_minimal() {
_assertSource(
"class C = S with M1;",
AstFactory.classTypeAlias(
"C",
null,
null,
AstFactory.typeName4("S"),
AstFactory.withClause([AstFactory.typeName4("M1")]),
null));
}
void test_visitClassTypeAlias_parameters_abstract() {
_assertSource(
"abstract class C<E> = S with M1;",
AstFactory.classTypeAlias(
"C",
AstFactory.typeParameterList(["E"]),
Keyword.ABSTRACT,
AstFactory.typeName4("S"),
AstFactory.withClause([AstFactory.typeName4("M1")]),
null));
}
void test_visitClassTypeAlias_parameters_abstract_implements() {
_assertSource(
"abstract class C<E> = S with M1 implements I;",
AstFactory.classTypeAlias(
"C",
AstFactory.typeParameterList(["E"]),
Keyword.ABSTRACT,
AstFactory.typeName4("S"),
AstFactory.withClause([AstFactory.typeName4("M1")]),
AstFactory.implementsClause([AstFactory.typeName4("I")])));
}
void test_visitClassTypeAlias_parameters_implements() {
_assertSource(
"class C<E> = S with M1 implements I;",
AstFactory.classTypeAlias(
"C",
AstFactory.typeParameterList(["E"]),
null,
AstFactory.typeName4("S"),
AstFactory.withClause([AstFactory.typeName4("M1")]),
AstFactory.implementsClause([AstFactory.typeName4("I")])));
}
void test_visitClassTypeAlias_withMetadata() {
ClassTypeAlias declaration = AstFactory.classTypeAlias(
"C",
null,
null,
AstFactory.typeName4("S"),
AstFactory.withClause([AstFactory.typeName4("M1")]),
null);
declaration.metadata =
[AstFactory.annotation(AstFactory.identifier3("deprecated"))];
_assertSource("@deprecated class C = S with M1;", declaration);
}
void test_visitComment() {
_assertSource(
"",
Comment.createBlockComment(
<Token>[TokenFactory.tokenFromString("/* comment */")]));
}
void test_visitCommentReference() {
_assertSource("", new CommentReference(null, AstFactory.identifier3("a")));
}
void test_visitCompilationUnit_declaration() {
_assertSource(
"var a;",
AstFactory.compilationUnit2(
[
AstFactory.topLevelVariableDeclaration2(
Keyword.VAR,
[AstFactory.variableDeclaration("a")])]));
}
void test_visitCompilationUnit_directive() {
_assertSource(
"library l;",
AstFactory.compilationUnit3([AstFactory.libraryDirective2("l")]));
}
void test_visitCompilationUnit_directive_declaration() {
_assertSource(
"library l; var a;",
AstFactory.compilationUnit4(
[AstFactory.libraryDirective2("l")],
[
AstFactory.topLevelVariableDeclaration2(
Keyword.VAR,
[AstFactory.variableDeclaration("a")])]));
}
void test_visitCompilationUnit_empty() {
_assertSource("", AstFactory.compilationUnit());
}
void test_visitCompilationUnit_script() {
_assertSource(
"!#/bin/dartvm",
AstFactory.compilationUnit5("!#/bin/dartvm"));
}
void test_visitCompilationUnit_script_declaration() {
_assertSource(
"!#/bin/dartvm var a;",
AstFactory.compilationUnit6(
"!#/bin/dartvm",
[
AstFactory.topLevelVariableDeclaration2(
Keyword.VAR,
[AstFactory.variableDeclaration("a")])]));
}
void test_visitCompilationUnit_script_directive() {
_assertSource(
"!#/bin/dartvm library l;",
AstFactory.compilationUnit7(
"!#/bin/dartvm",
[AstFactory.libraryDirective2("l")]));
}
void test_visitCompilationUnit_script_directives_declarations() {
_assertSource(
"!#/bin/dartvm library l; var a;",
AstFactory.compilationUnit8(
"!#/bin/dartvm",
[AstFactory.libraryDirective2("l")],
[
AstFactory.topLevelVariableDeclaration2(
Keyword.VAR,
[AstFactory.variableDeclaration("a")])]));
}
void test_visitConditionalExpression() {
_assertSource(
"a ? b : c",
AstFactory.conditionalExpression(
AstFactory.identifier3("a"),
AstFactory.identifier3("b"),
AstFactory.identifier3("c")));
}
void test_visitConstructorDeclaration_const() {
_assertSource(
"const C() {}",
AstFactory.constructorDeclaration2(
Keyword.CONST,
null,
AstFactory.identifier3("C"),
null,
AstFactory.formalParameterList(),
null,
AstFactory.blockFunctionBody2()));
}
void test_visitConstructorDeclaration_external() {
_assertSource(
"external C();",
AstFactory.constructorDeclaration(
AstFactory.identifier3("C"),
null,
AstFactory.formalParameterList(),
null));
}
void test_visitConstructorDeclaration_minimal() {
_assertSource(
"C() {}",
AstFactory.constructorDeclaration2(
null,
null,
AstFactory.identifier3("C"),
null,
AstFactory.formalParameterList(),
null,
AstFactory.blockFunctionBody2()));
}
void test_visitConstructorDeclaration_multipleInitializers() {
_assertSource(
"C() : a = b, c = d {}",
AstFactory.constructorDeclaration2(
null,
null,
AstFactory.identifier3("C"),
null,
AstFactory.formalParameterList(),
[
AstFactory.constructorFieldInitializer(false, "a", AstFactory.identifier3("b")),
AstFactory.constructorFieldInitializer(
false,
"c",
AstFactory.identifier3("d"))],
AstFactory.blockFunctionBody2()));
}
void test_visitConstructorDeclaration_multipleParameters() {
_assertSource(
"C(var a, var b) {}",
AstFactory.constructorDeclaration2(
null,
null,
AstFactory.identifier3("C"),
null,
AstFactory.formalParameterList(
[
AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
AstFactory.simpleFormalParameter(Keyword.VAR, "b")]),
null,
AstFactory.blockFunctionBody2()));
}
void test_visitConstructorDeclaration_named() {
_assertSource(
"C.m() {}",
AstFactory.constructorDeclaration2(
null,
null,
AstFactory.identifier3("C"),
"m",
AstFactory.formalParameterList(),
null,
AstFactory.blockFunctionBody2()));
}
void test_visitConstructorDeclaration_singleInitializer() {
_assertSource(
"C() : a = b {}",
AstFactory.constructorDeclaration2(
null,
null,
AstFactory.identifier3("C"),
null,
AstFactory.formalParameterList(),
[
AstFactory.constructorFieldInitializer(
false,
"a",
AstFactory.identifier3("b"))],
AstFactory.blockFunctionBody2()));
}
void test_visitConstructorDeclaration_withMetadata() {
ConstructorDeclaration declaration = AstFactory.constructorDeclaration2(
null,
null,
AstFactory.identifier3("C"),
null,
AstFactory.formalParameterList(),
null,
AstFactory.blockFunctionBody2());
declaration.metadata =
[AstFactory.annotation(AstFactory.identifier3("deprecated"))];
_assertSource("@deprecated C() {}", declaration);
}
void test_visitConstructorFieldInitializer_withoutThis() {
_assertSource(
"a = b",
AstFactory.constructorFieldInitializer(
false,
"a",
AstFactory.identifier3("b")));
}
void test_visitConstructorFieldInitializer_withThis() {
_assertSource(
"this.a = b",
AstFactory.constructorFieldInitializer(true, "a", AstFactory.identifier3("b")));
}
void test_visitConstructorName_named_prefix() {
_assertSource(
"p.C.n",
AstFactory.constructorName(AstFactory.typeName4("p.C.n"), null));
}
void test_visitConstructorName_unnamed_noPrefix() {
_assertSource(
"C",
AstFactory.constructorName(AstFactory.typeName4("C"), null));
}
void test_visitConstructorName_unnamed_prefix() {
_assertSource(
"p.C",
AstFactory.constructorName(
AstFactory.typeName3(AstFactory.identifier5("p", "C")),
null));
}
void test_visitContinueStatement_label() {
_assertSource("continue l;", AstFactory.continueStatement("l"));
}
void test_visitContinueStatement_noLabel() {
_assertSource("continue;", AstFactory.continueStatement());
}
void test_visitDefaultFormalParameter_named_noValue() {
_assertSource(
"p",
AstFactory.namedFormalParameter(AstFactory.simpleFormalParameter3("p"), null));
}
void test_visitDefaultFormalParameter_named_value() {
_assertSource(
"p : 0",
AstFactory.namedFormalParameter(
AstFactory.simpleFormalParameter3("p"),
AstFactory.integer(0)));
}
void test_visitDefaultFormalParameter_positional_noValue() {
_assertSource(
"p",
AstFactory.positionalFormalParameter(
AstFactory.simpleFormalParameter3("p"),
null));
}
void test_visitDefaultFormalParameter_positional_value() {
_assertSource(
"p = 0",
AstFactory.positionalFormalParameter(
AstFactory.simpleFormalParameter3("p"),
AstFactory.integer(0)));
}
void test_visitDoStatement() {
_assertSource(
"do {} while (c);",
AstFactory.doStatement(AstFactory.block(), AstFactory.identifier3("c")));
}
void test_visitDoubleLiteral() {
_assertSource("4.2", AstFactory.doubleLiteral(4.2));
}
void test_visitEmptyFunctionBody() {
_assertSource(";", AstFactory.emptyFunctionBody());
}
void test_visitEmptyStatement() {
_assertSource(";", AstFactory.emptyStatement());
}
void test_visitEnumDeclaration_multiple() {
_assertSource(
"enum E {ONE, TWO}",
AstFactory.enumDeclaration2("E", ["ONE", "TWO"]));
}
void test_visitEnumDeclaration_single() {
_assertSource("enum E {ONE}", AstFactory.enumDeclaration2("E", ["ONE"]));
}
void test_visitExportDirective_combinator() {
_assertSource(
"export 'a.dart' show A;",
AstFactory.exportDirective2(
"a.dart",
[AstFactory.showCombinator([AstFactory.identifier3("A")])]));
}
void test_visitExportDirective_combinators() {
_assertSource(
"export 'a.dart' show A hide B;",
AstFactory.exportDirective2(
"a.dart",
[
AstFactory.showCombinator([AstFactory.identifier3("A")]),
AstFactory.hideCombinator([AstFactory.identifier3("B")])]));
}
void test_visitExportDirective_minimal() {
_assertSource("export 'a.dart';", AstFactory.exportDirective2("a.dart"));
}
void test_visitExportDirective_withMetadata() {
ExportDirective directive = AstFactory.exportDirective2("a.dart");
directive.metadata =
[AstFactory.annotation(AstFactory.identifier3("deprecated"))];
_assertSource("@deprecated export 'a.dart';", directive);
}
void test_visitExpressionFunctionBody_async() {
_assertSource(
"async => a;",
AstFactory.asyncExpressionFunctionBody(AstFactory.identifier3("a")));
}
void test_visitExpressionFunctionBody_simple() {
_assertSource(
"=> a;",
AstFactory.expressionFunctionBody(AstFactory.identifier3("a")));
}
void test_visitExpressionStatement() {
_assertSource(
"a;",
AstFactory.expressionStatement(AstFactory.identifier3("a")));
}
void test_visitExtendsClause() {
_assertSource(
"extends C",
AstFactory.extendsClause(AstFactory.typeName4("C")));
}
void test_visitFieldDeclaration_instance() {
_assertSource(
"var a;",
AstFactory.fieldDeclaration2(
false,
Keyword.VAR,
[AstFactory.variableDeclaration("a")]));
}
void test_visitFieldDeclaration_static() {
_assertSource(
"static var a;",
AstFactory.fieldDeclaration2(
true,
Keyword.VAR,
[AstFactory.variableDeclaration("a")]));
}
void test_visitFieldDeclaration_withMetadata() {
FieldDeclaration declaration = AstFactory.fieldDeclaration2(
false,
Keyword.VAR,
[AstFactory.variableDeclaration("a")]);
declaration.metadata =
[AstFactory.annotation(AstFactory.identifier3("deprecated"))];
_assertSource("@deprecated var a;", declaration);
}
void test_visitFieldFormalParameter_functionTyped() {
_assertSource(
"A this.a(b)",
AstFactory.fieldFormalParameter(
null,
AstFactory.typeName4("A"),
"a",
AstFactory.formalParameterList([AstFactory.simpleFormalParameter3("b")])));
}
void test_visitFieldFormalParameter_keyword() {
_assertSource(
"var this.a",
AstFactory.fieldFormalParameter(Keyword.VAR, null, "a"));
}
void test_visitFieldFormalParameter_keywordAndType() {
_assertSource(
"final A this.a",
AstFactory.fieldFormalParameter(Keyword.FINAL, AstFactory.typeName4("A"), "a"));
}
void test_visitFieldFormalParameter_type() {
_assertSource(
"A this.a",
AstFactory.fieldFormalParameter(null, AstFactory.typeName4("A"), "a"));
}
void test_visitForEachStatement_declared() {
_assertSource(
"for (a in b) {}",
AstFactory.forEachStatement(
AstFactory.declaredIdentifier3("a"),
AstFactory.identifier3("b"),
AstFactory.block()));
}
void test_visitForEachStatement_variable() {
_assertSource(
"for (a in b) {}",
new ForEachStatement.con2(
null,
TokenFactory.tokenFromKeyword(Keyword.FOR),
TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
AstFactory.identifier3("a"),
TokenFactory.tokenFromKeyword(Keyword.IN),
AstFactory.identifier3("b"),
TokenFactory.tokenFromType(TokenType.CLOSE_PAREN),
AstFactory.block()));
}
void test_visitForEachStatement_variable_await() {
_assertSource(
"await for (a in b) {}",
new ForEachStatement.con2(
TokenFactory.tokenFromString("await"),
TokenFactory.tokenFromKeyword(Keyword.FOR),
TokenFactory.tokenFromType(TokenType.OPEN_PAREN),
AstFactory.identifier3("a"),
TokenFactory.tokenFromKeyword(Keyword.IN),
AstFactory.identifier3("b"),
TokenFactory.tokenFromType(TokenType.CLOSE_PAREN),
AstFactory.block()));
}
void test_visitFormalParameterList_empty() {
_assertSource("()", AstFactory.formalParameterList());
}
void test_visitFormalParameterList_n() {
_assertSource(
"({a : 0})",
AstFactory.formalParameterList(
[
AstFactory.namedFormalParameter(
AstFactory.simpleFormalParameter3("a"),
AstFactory.integer(0))]));
}
void test_visitFormalParameterList_nn() {
_assertSource(
"({a : 0, b : 1})",
AstFactory.formalParameterList(
[
AstFactory.namedFormalParameter(
AstFactory.simpleFormalParameter3("a"),
AstFactory.integer(0)),
AstFactory.namedFormalParameter(
AstFactory.simpleFormalParameter3("b"),
AstFactory.integer(1))]));
}
void test_visitFormalParameterList_p() {
_assertSource(
"([a = 0])",
AstFactory.formalParameterList(
[
AstFactory.positionalFormalParameter(
AstFactory.simpleFormalParameter3("a"),
AstFactory.integer(0))]));
}
void test_visitFormalParameterList_pp() {
_assertSource(
"([a = 0, b = 1])",
AstFactory.formalParameterList(
[
AstFactory.positionalFormalParameter(
AstFactory.simpleFormalParameter3("a"),
AstFactory.integer(0)),
AstFactory.positionalFormalParameter(
AstFactory.simpleFormalParameter3("b"),
AstFactory.integer(1))]));
}
void test_visitFormalParameterList_r() {
_assertSource(
"(a)",
AstFactory.formalParameterList([AstFactory.simpleFormalParameter3("a")]));
}
void test_visitFormalParameterList_rn() {
_assertSource(
"(a, {b : 1})",
AstFactory.formalParameterList(
[
AstFactory.simpleFormalParameter3("a"),
AstFactory.namedFormalParameter(
AstFactory.simpleFormalParameter3("b"),
AstFactory.integer(1))]));
}
void test_visitFormalParameterList_rnn() {
_assertSource(
"(a, {b : 1, c : 2})",
AstFactory.formalParameterList(
[
AstFactory.simpleFormalParameter3("a"),
AstFactory.namedFormalParameter(
AstFactory.simpleFormalParameter3("b"),
AstFactory.integer(1)),
AstFactory.namedFormalParameter(
AstFactory.simpleFormalParameter3("c"),
AstFactory.integer(2))]));
}
void test_visitFormalParameterList_rp() {
_assertSource(
"(a, [b = 1])",
AstFactory.formalParameterList(
[
AstFactory.simpleFormalParameter3("a"),
AstFactory.positionalFormalParameter(
AstFactory.simpleFormalParameter3("b"),
AstFactory.integer(1))]));
}
void test_visitFormalParameterList_rpp() {
_assertSource(
"(a, [b = 1, c = 2])",
AstFactory.formalParameterList(
[
AstFactory.simpleFormalParameter3("a"),
AstFactory.positionalFormalParameter(
AstFactory.simpleFormalParameter3("b"),
AstFactory.integer(1)),
AstFactory.positionalFormalParameter(
AstFactory.simpleFormalParameter3("c"),
AstFactory.integer(2))]));
}
void test_visitFormalParameterList_rr() {
_assertSource(
"(a, b)",
AstFactory.formalParameterList(
[
AstFactory.simpleFormalParameter3("a"),
AstFactory.simpleFormalParameter3("b")]));
}
void test_visitFormalParameterList_rrn() {
_assertSource(
"(a, b, {c : 3})",
AstFactory.formalParameterList(
[
AstFactory.simpleFormalParameter3("a"),
AstFactory.simpleFormalParameter3("b"),
AstFactory.namedFormalParameter(
AstFactory.simpleFormalParameter3("c"),
AstFactory.integer(3))]));
}
void test_visitFormalParameterList_rrnn() {
_assertSource(
"(a, b, {c : 3, d : 4})",
AstFactory.formalParameterList(
[
AstFactory.simpleFormalParameter3("a"),
AstFactory.simpleFormalParameter3("b"),
AstFactory.namedFormalParameter(
AstFactory.simpleFormalParameter3("c"),
AstFactory.integer(3)),
AstFactory.namedFormalParameter(
AstFactory.simpleFormalParameter3("d"),
AstFactory.integer(4))]));
}
void test_visitFormalParameterList_rrp() {
_assertSource(
"(a, b, [c = 3])",
AstFactory.formalParameterList(
[
AstFactory.simpleFormalParameter3("a"),
AstFactory.simpleFormalParameter3("b"),
AstFactory.positionalFormalParameter(
AstFactory.simpleFormalParameter3("c"),
AstFactory.integer(3))]));
}
void test_visitFormalParameterList_rrpp() {
_assertSource(
"(a, b, [c = 3, d = 4])",
AstFactory.formalParameterList(
[
AstFactory.simpleFormalParameter3("a"),
AstFactory.simpleFormalParameter3("b"),
AstFactory.positionalFormalParameter(
AstFactory.simpleFormalParameter3("c"),
AstFactory.integer(3)),
AstFactory.positionalFormalParameter(
AstFactory.simpleFormalParameter3("d"),
AstFactory.integer(4))]));
}
void test_visitForStatement_c() {
_assertSource(
"for (; c;) {}",
AstFactory.forStatement(
null,
AstFactory.identifier3("c"),
null,
AstFactory.block()));
}
void test_visitForStatement_cu() {
_assertSource(
"for (; c; u) {}",
AstFactory.forStatement(
null,
AstFactory.identifier3("c"),
[AstFactory.identifier3("u")],
AstFactory.block()));
}
void test_visitForStatement_e() {
_assertSource(
"for (e;;) {}",
AstFactory.forStatement(
AstFactory.identifier3("e"),
null,
null,
AstFactory.block()));
}
void test_visitForStatement_ec() {
_assertSource(
"for (e; c;) {}",
AstFactory.forStatement(
AstFactory.identifier3("e"),
AstFactory.identifier3("c"),
null,
AstFactory.block()));
}
void test_visitForStatement_ecu() {
_assertSource(
"for (e; c; u) {}",
AstFactory.forStatement(
AstFactory.identifier3("e"),
AstFactory.identifier3("c"),
[AstFactory.identifier3("u")],
AstFactory.block()));
}
void test_visitForStatement_eu() {
_assertSource(
"for (e;; u) {}",
AstFactory.forStatement(
AstFactory.identifier3("e"),
null,
[AstFactory.identifier3("u")],
AstFactory.block()));
}
void test_visitForStatement_i() {
_assertSource(
"for (var i;;) {}",
AstFactory.forStatement2(
AstFactory.variableDeclarationList2(
Keyword.VAR,
[AstFactory.variableDeclaration("i")]),
null,
null,
AstFactory.block()));
}
void test_visitForStatement_ic() {
_assertSource(
"for (var i; c;) {}",
AstFactory.forStatement2(
AstFactory.variableDeclarationList2(
Keyword.VAR,
[AstFactory.variableDeclaration("i")]),
AstFactory.identifier3("c"),
null,
AstFactory.block()));
}
void test_visitForStatement_icu() {
_assertSource(
"for (var i; c; u) {}",
AstFactory.forStatement2(
AstFactory.variableDeclarationList2(
Keyword.VAR,
[AstFactory.variableDeclaration("i")]),
AstFactory.identifier3("c"),
[AstFactory.identifier3("u")],
AstFactory.block()));
}
void test_visitForStatement_iu() {
_assertSource(
"for (var i;; u) {}",
AstFactory.forStatement2(
AstFactory.variableDeclarationList2(
Keyword.VAR,
[AstFactory.variableDeclaration("i")]),
null,
[AstFactory.identifier3("u")],
AstFactory.block()));
}
void test_visitForStatement_u() {
_assertSource(
"for (;; u) {}",
AstFactory.forStatement(
null,
null,
[AstFactory.identifier3("u")],
AstFactory.block()));
}
void test_visitFunctionDeclaration_getter() {
_assertSource(
"get f() {}",
AstFactory.functionDeclaration(
null,
Keyword.GET,
"f",
AstFactory.functionExpression()));
}
void test_visitFunctionDeclaration_local_blockBody() {
FunctionDeclaration f = AstFactory.functionDeclaration(
null,
null,
"f",
AstFactory.functionExpression());
FunctionDeclarationStatement fStatement =
new FunctionDeclarationStatement(f);
_assertSource(
"main() {f() {} 42;}",
AstFactory.functionDeclaration(
null,
null,
"main",
AstFactory.functionExpression2(
AstFactory.formalParameterList(),
AstFactory.blockFunctionBody2(
[fStatement, AstFactory.expressionStatement(AstFactory.integer(42))]))));
}
void test_visitFunctionDeclaration_local_expressionBody() {
FunctionDeclaration f = AstFactory.functionDeclaration(
null,
null,
"f",
AstFactory.functionExpression2(
AstFactory.formalParameterList(),
AstFactory.expressionFunctionBody(AstFactory.integer(1))));
FunctionDeclarationStatement fStatement =
new FunctionDeclarationStatement(f);
_assertSource(
"main() {f() => 1; 2;}",
AstFactory.functionDeclaration(
null,
null,
"main",
AstFactory.functionExpression2(
AstFactory.formalParameterList(),
AstFactory.blockFunctionBody2(
[fStatement, AstFactory.expressionStatement(AstFactory.integer(2))]))));
}
void test_visitFunctionDeclaration_normal() {
_assertSource(
"f() {}",
AstFactory.functionDeclaration(
null,
null,
"f",
AstFactory.functionExpression()));
}
void test_visitFunctionDeclaration_setter() {
_assertSource(
"set f() {}",
AstFactory.functionDeclaration(
null,
Keyword.SET,
"f",
AstFactory.functionExpression()));
}
void test_visitFunctionDeclaration_withMetadata() {
FunctionDeclaration declaration = AstFactory.functionDeclaration(
null,
null,
"f",
AstFactory.functionExpression());
declaration.metadata =
[AstFactory.annotation(AstFactory.identifier3("deprecated"))];
_assertSource("@deprecated f() {}", declaration);
}
void test_visitFunctionDeclarationStatement() {
_assertSource(
"f() {}",
AstFactory.functionDeclarationStatement(
null,
null,
"f",
AstFactory.functionExpression()));
}
void test_visitFunctionExpression() {
_assertSource("() {}", AstFactory.functionExpression());
}
void test_visitFunctionExpressionInvocation() {
_assertSource(
"f()",
AstFactory.functionExpressionInvocation(AstFactory.identifier3("f")));
}
void test_visitFunctionTypeAlias_generic() {
_assertSource(
"typedef A F<B>();",
AstFactory.typeAlias(
AstFactory.typeName4("A"),
"F",
AstFactory.typeParameterList(["B"]),
AstFactory.formalParameterList()));
}
void test_visitFunctionTypeAlias_nonGeneric() {
_assertSource(
"typedef A F();",
AstFactory.typeAlias(
AstFactory.typeName4("A"),
"F",
null,
AstFactory.formalParameterList()));
}
void test_visitFunctionTypeAlias_withMetadata() {
FunctionTypeAlias declaration = AstFactory.typeAlias(
AstFactory.typeName4("A"),
"F",
null,
AstFactory.formalParameterList());
declaration.metadata =
[AstFactory.annotation(AstFactory.identifier3("deprecated"))];
_assertSource("@deprecated typedef A F();", declaration);
}
void test_visitFunctionTypedFormalParameter_noType() {
_assertSource("f()", AstFactory.functionTypedFormalParameter(null, "f"));
}
void test_visitFunctionTypedFormalParameter_type() {
_assertSource(
"T f()",
AstFactory.functionTypedFormalParameter(AstFactory.typeName4("T"), "f"));
}
void test_visitIfStatement_withElse() {
_assertSource(
"if (c) {} else {}",
AstFactory.ifStatement2(
AstFactory.identifier3("c"),
AstFactory.block(),
AstFactory.block()));
}
void test_visitIfStatement_withoutElse() {
_assertSource(
"if (c) {}",
AstFactory.ifStatement(AstFactory.identifier3("c"), AstFactory.block()));
}
void test_visitImplementsClause_multiple() {
_assertSource(
"implements A, B",
AstFactory.implementsClause(
[AstFactory.typeName4("A"), AstFactory.typeName4("B")]));
}
void test_visitImplementsClause_single() {
_assertSource(
"implements A",
AstFactory.implementsClause([AstFactory.typeName4("A")]));
}
void test_visitImportDirective_combinator() {
_assertSource(
"import 'a.dart' show A;",
AstFactory.importDirective3(
"a.dart",
null,
[AstFactory.showCombinator([AstFactory.identifier3("A")])]));
}
void test_visitImportDirective_combinators() {
_assertSource(
"import 'a.dart' show A hide B;",
AstFactory.importDirective3(
"a.dart",
null,
[
AstFactory.showCombinator([AstFactory.identifier3("A")]),
AstFactory.hideCombinator([AstFactory.identifier3("B")])]));
}
void test_visitImportDirective_deferred() {
_assertSource(
"import 'a.dart' deferred as p;",
AstFactory.importDirective2("a.dart", true, "p"));
}
void test_visitImportDirective_minimal() {
_assertSource(
"import 'a.dart';",
AstFactory.importDirective3("a.dart", null));
}
void test_visitImportDirective_prefix() {
_assertSource(
"import 'a.dart' as p;",
AstFactory.importDirective3("a.dart", "p"));
}
void test_visitImportDirective_prefix_combinator() {
_assertSource(
"import 'a.dart' as p show A;",
AstFactory.importDirective3(
"a.dart",
"p",
[AstFactory.showCombinator([AstFactory.identifier3("A")])]));
}
void test_visitImportDirective_prefix_combinators() {
_assertSource(
"import 'a.dart' as p show A hide B;",
AstFactory.importDirective3(
"a.dart",
"p",
[
AstFactory.showCombinator([AstFactory.identifier3("A")]),
AstFactory.hideCombinator([AstFactory.identifier3("B")])]));
}
void test_visitImportDirective_withMetadata() {
ImportDirective directive = AstFactory.importDirective3("a.dart", null);
directive.metadata =
[AstFactory.annotation(AstFactory.identifier3("deprecated"))];
_assertSource("@deprecated import 'a.dart';", directive);
}
void test_visitImportHideCombinator_multiple() {
_assertSource(
"hide a, b",
AstFactory.hideCombinator(
[AstFactory.identifier3("a"), AstFactory.identifier3("b")]));
}
void test_visitImportHideCombinator_single() {
_assertSource(
"hide a",
AstFactory.hideCombinator([AstFactory.identifier3("a")]));
}
void test_visitImportShowCombinator_multiple() {
_assertSource(
"show a, b",
AstFactory.showCombinator(
[AstFactory.identifier3("a"), AstFactory.identifier3("b")]));
}
void test_visitImportShowCombinator_single() {
_assertSource(
"show a",
AstFactory.showCombinator([AstFactory.identifier3("a")]));
}
void test_visitIndexExpression() {
_assertSource(
"a[i]",
AstFactory.indexExpression(
AstFactory.identifier3("a"),
AstFactory.identifier3("i")));
}
void test_visitInstanceCreationExpression_const() {
_assertSource(
"const C()",
AstFactory.instanceCreationExpression2(
Keyword.CONST,
AstFactory.typeName4("C")));
}
void test_visitInstanceCreationExpression_named() {
_assertSource(
"new C.c()",
AstFactory.instanceCreationExpression3(
Keyword.NEW,
AstFactory.typeName4("C"),
"c"));
}
void test_visitInstanceCreationExpression_unnamed() {
_assertSource(
"new C()",
AstFactory.instanceCreationExpression2(Keyword.NEW, AstFactory.typeName4("C")));
}
void test_visitIntegerLiteral() {
_assertSource("42", AstFactory.integer(42));
}
void test_visitInterpolationExpression_expression() {
_assertSource(
"\${a}",
AstFactory.interpolationExpression(AstFactory.identifier3("a")));
}
void test_visitInterpolationExpression_identifier() {
_assertSource("\$a", AstFactory.interpolationExpression2("a"));
}
void test_visitInterpolationString() {
_assertSource("'x", AstFactory.interpolationString("'x", "x"));
}
void test_visitIsExpression_negated() {
_assertSource(
"a is! C",
AstFactory.isExpression(
AstFactory.identifier3("a"),
true,
AstFactory.typeName4("C")));
}
void test_visitIsExpression_normal() {
_assertSource(
"a is C",
AstFactory.isExpression(
AstFactory.identifier3("a"),
false,
AstFactory.typeName4("C")));
}
void test_visitLabel() {
_assertSource("a:", AstFactory.label2("a"));
}
void test_visitLabeledStatement_multiple() {
_assertSource(
"a: b: return;",
AstFactory.labeledStatement(
[AstFactory.label2("a"), AstFactory.label2("b")],
AstFactory.returnStatement()));
}
void test_visitLabeledStatement_single() {
_assertSource(
"a: return;",
AstFactory.labeledStatement(
[AstFactory.label2("a")],
AstFactory.returnStatement()));
}
void test_visitLibraryDirective() {
_assertSource("library l;", AstFactory.libraryDirective2("l"));
}
void test_visitLibraryDirective_withMetadata() {
LibraryDirective directive = AstFactory.libraryDirective2("l");
directive.metadata =
[AstFactory.annotation(AstFactory.identifier3("deprecated"))];
_assertSource("@deprecated library l;", directive);
}
void test_visitLibraryIdentifier_multiple() {
_assertSource(
"a.b.c",
AstFactory.libraryIdentifier(
[
AstFactory.identifier3("a"),
AstFactory.identifier3("b"),
AstFactory.identifier3("c")]));
}
void test_visitLibraryIdentifier_single() {
_assertSource(
"a",
AstFactory.libraryIdentifier([AstFactory.identifier3("a")]));
}
void test_visitListLiteral_const() {
_assertSource("const []", AstFactory.listLiteral2(Keyword.CONST, null));
}
void test_visitListLiteral_empty() {
_assertSource("[]", AstFactory.listLiteral());
}
void test_visitListLiteral_nonEmpty() {
_assertSource(
"[a, b, c]",
AstFactory.listLiteral(
[
AstFactory.identifier3("a"),
AstFactory.identifier3("b"),
AstFactory.identifier3("c")]));
}
void test_visitMapLiteral_const() {
_assertSource("const {}", AstFactory.mapLiteral(Keyword.CONST, null));
}
void test_visitMapLiteral_empty() {
_assertSource("{}", AstFactory.mapLiteral2());
}
void test_visitMapLiteral_nonEmpty() {
_assertSource(
"{'a' : a, 'b' : b, 'c' : c}",
AstFactory.mapLiteral2(
[
AstFactory.mapLiteralEntry("a", AstFactory.identifier3("a")),
AstFactory.mapLiteralEntry("b", AstFactory.identifier3("b")),
AstFactory.mapLiteralEntry("c", AstFactory.identifier3("c"))]));
}
void test_visitMapLiteralEntry() {
_assertSource(
"'a' : b",
AstFactory.mapLiteralEntry("a", AstFactory.identifier3("b")));
}
void test_visitMethodDeclaration_external() {
_assertSource(
"external m();",
AstFactory.methodDeclaration(
null,
null,
null,
null,
AstFactory.identifier3("m"),
AstFactory.formalParameterList()));
}
void test_visitMethodDeclaration_external_returnType() {
_assertSource(
"external T m();",
AstFactory.methodDeclaration(
null,
AstFactory.typeName4("T"),
null,
null,
AstFactory.identifier3("m"),
AstFactory.formalParameterList()));
}
void test_visitMethodDeclaration_getter() {
_assertSource(
"get m {}",
AstFactory.methodDeclaration2(
null,
null,
Keyword.GET,
null,
AstFactory.identifier3("m"),
null,
AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_getter_returnType() {
_assertSource(
"T get m {}",
AstFactory.methodDeclaration2(
null,
AstFactory.typeName4("T"),
Keyword.GET,
null,
AstFactory.identifier3("m"),
null,
AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_getter_seturnType() {
_assertSource(
"T set m(var v) {}",
AstFactory.methodDeclaration2(
null,
AstFactory.typeName4("T"),
Keyword.SET,
null,
AstFactory.identifier3("m"),
AstFactory.formalParameterList(
[AstFactory.simpleFormalParameter(Keyword.VAR, "v")]),
AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_minimal() {
_assertSource(
"m() {}",
AstFactory.methodDeclaration2(
null,
null,
null,
null,
AstFactory.identifier3("m"),
AstFactory.formalParameterList(),
AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_multipleParameters() {
_assertSource(
"m(var a, var b) {}",
AstFactory.methodDeclaration2(
null,
null,
null,
null,
AstFactory.identifier3("m"),
AstFactory.formalParameterList(
[
AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
AstFactory.simpleFormalParameter(Keyword.VAR, "b")]),
AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_operator() {
_assertSource(
"operator +() {}",
AstFactory.methodDeclaration2(
null,
null,
null,
Keyword.OPERATOR,
AstFactory.identifier3("+"),
AstFactory.formalParameterList(),
AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_operator_returnType() {
_assertSource(
"T operator +() {}",
AstFactory.methodDeclaration2(
null,
AstFactory.typeName4("T"),
null,
Keyword.OPERATOR,
AstFactory.identifier3("+"),
AstFactory.formalParameterList(),
AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_returnType() {
_assertSource(
"T m() {}",
AstFactory.methodDeclaration2(
null,
AstFactory.typeName4("T"),
null,
null,
AstFactory.identifier3("m"),
AstFactory.formalParameterList(),
AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_setter() {
_assertSource(
"set m(var v) {}",
AstFactory.methodDeclaration2(
null,
null,
Keyword.SET,
null,
AstFactory.identifier3("m"),
AstFactory.formalParameterList(
[AstFactory.simpleFormalParameter(Keyword.VAR, "v")]),
AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_static() {
_assertSource(
"static m() {}",
AstFactory.methodDeclaration2(
Keyword.STATIC,
null,
null,
null,
AstFactory.identifier3("m"),
AstFactory.formalParameterList(),
AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_static_returnType() {
_assertSource(
"static T m() {}",
AstFactory.methodDeclaration2(
Keyword.STATIC,
AstFactory.typeName4("T"),
null,
null,
AstFactory.identifier3("m"),
AstFactory.formalParameterList(),
AstFactory.blockFunctionBody2()));
}
void test_visitMethodDeclaration_withMetadata() {
MethodDeclaration declaration = AstFactory.methodDeclaration2(
null,
null,
null,
null,
AstFactory.identifier3("m"),
AstFactory.formalParameterList(),
AstFactory.blockFunctionBody2());
declaration.metadata =
[AstFactory.annotation(AstFactory.identifier3("deprecated"))];
_assertSource("@deprecated m() {}", declaration);
}
void test_visitMethodInvocation_noTarget() {
_assertSource("m()", AstFactory.methodInvocation2("m"));
}
void test_visitMethodInvocation_target() {
_assertSource(
"t.m()",
AstFactory.methodInvocation(AstFactory.identifier3("t"), "m"));
}
void test_visitNamedExpression() {
_assertSource(
"a: b",
AstFactory.namedExpression2("a", AstFactory.identifier3("b")));
}
void test_visitNamedFormalParameter() {
_assertSource(
"var a : 0",
AstFactory.namedFormalParameter(
AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
AstFactory.integer(0)));
}
void test_visitNativeClause() {
_assertSource("native 'code'", AstFactory.nativeClause("code"));
}
void test_visitNativeFunctionBody() {
_assertSource("native 'str';", AstFactory.nativeFunctionBody("str"));
}
void test_visitNullLiteral() {
_assertSource("null", AstFactory.nullLiteral());
}
void test_visitParenthesizedExpression() {
_assertSource(
"(a)",
AstFactory.parenthesizedExpression(AstFactory.identifier3("a")));
}
void test_visitPartDirective() {
_assertSource("part 'a.dart';", AstFactory.partDirective2("a.dart"));
}
void test_visitPartDirective_withMetadata() {
PartDirective directive = AstFactory.partDirective2("a.dart");
directive.metadata =
[AstFactory.annotation(AstFactory.identifier3("deprecated"))];
_assertSource("@deprecated part 'a.dart';", directive);
}
void test_visitPartOfDirective() {
_assertSource(
"part of l;",
AstFactory.partOfDirective(AstFactory.libraryIdentifier2(["l"])));
}
void test_visitPartOfDirective_withMetadata() {
PartOfDirective directive =
AstFactory.partOfDirective(AstFactory.libraryIdentifier2(["l"]));
directive.metadata =
[AstFactory.annotation(AstFactory.identifier3("deprecated"))];
_assertSource("@deprecated part of l;", directive);
}
void test_visitPositionalFormalParameter() {
_assertSource(
"var a = 0",
AstFactory.positionalFormalParameter(
AstFactory.simpleFormalParameter(Keyword.VAR, "a"),
AstFactory.integer(0)));
}
void test_visitPostfixExpression() {
_assertSource(
"a++",
AstFactory.postfixExpression(AstFactory.identifier3("a"), TokenType.PLUS_PLUS));
}
void test_visitPrefixedIdentifier() {
_assertSource("a.b", AstFactory.identifier5("a", "b"));
}
void test_visitPrefixExpression() {
_assertSource(
"-a",
AstFactory.prefixExpression(TokenType.MINUS, AstFactory.identifier3("a")));
}
void test_visitPropertyAccess() {
_assertSource(
"a.b",
AstFactory.propertyAccess2(AstFactory.identifier3("a"), "b"));
}
void test_visitRedirectingConstructorInvocation_named() {
_assertSource(
"this.c()",
AstFactory.redirectingConstructorInvocation2("c"));
}
void test_visitRedirectingConstructorInvocation_unnamed() {
_assertSource("this()", AstFactory.redirectingConstructorInvocation());
}
void test_visitRethrowExpression() {
_assertSource("rethrow", AstFactory.rethrowExpression());
}
void test_visitReturnStatement_expression() {
_assertSource(
"return a;",
AstFactory.returnStatement2(AstFactory.identifier3("a")));
}
void test_visitReturnStatement_noExpression() {
_assertSource("return;", AstFactory.returnStatement());
}
void test_visitScriptTag() {
String scriptTag = "!#/bin/dart.exe";
_assertSource(scriptTag, AstFactory.scriptTag(scriptTag));
}
void test_visitSimpleFormalParameter_keyword() {
_assertSource("var a", AstFactory.simpleFormalParameter(Keyword.VAR, "a"));
}
void test_visitSimpleFormalParameter_keyword_type() {
_assertSource(
"final A a",
AstFactory.simpleFormalParameter2(
Keyword.FINAL,
AstFactory.typeName4("A"),
"a"));
}
void test_visitSimpleFormalParameter_type() {
_assertSource(
"A a",
AstFactory.simpleFormalParameter4(AstFactory.typeName4("A"), "a"));
}
void test_visitSimpleIdentifier() {
_assertSource("a", AstFactory.identifier3("a"));
}
void test_visitSimpleStringLiteral() {
_assertSource("'a'", AstFactory.string2("a"));
}
void test_visitStringInterpolation() {
_assertSource(
"'a\${e}b'",
AstFactory.string(
[
AstFactory.interpolationString("'a", "a"),
AstFactory.interpolationExpression(AstFactory.identifier3("e")),
AstFactory.interpolationString("b'", "b")]));
}
void test_visitSuperConstructorInvocation() {
_assertSource("super()", AstFactory.superConstructorInvocation());
}
void test_visitSuperConstructorInvocation_named() {
_assertSource("super.c()", AstFactory.superConstructorInvocation2("c"));
}
void test_visitSuperExpression() {
_assertSource("super", AstFactory.superExpression());
}
void test_visitSwitchCase_multipleLabels() {
_assertSource(
"l1: l2: case a: {}",
AstFactory.switchCase2(
[AstFactory.label2("l1"), AstFactory.label2("l2")],
AstFactory.identifier3("a"),
[AstFactory.block()]));
}
void test_visitSwitchCase_multipleStatements() {
_assertSource(
"case a: {} {}",
AstFactory.switchCase(
AstFactory.identifier3("a"),
[AstFactory.block(), AstFactory.block()]));
}
void test_visitSwitchCase_noLabels() {
_assertSource(
"case a: {}",
AstFactory.switchCase(AstFactory.identifier3("a"), [AstFactory.block()]));
}
void test_visitSwitchCase_singleLabel() {
_assertSource(
"l1: case a: {}",
AstFactory.switchCase2(
[AstFactory.label2("l1")],
AstFactory.identifier3("a"),
[AstFactory.block()]));
}
void test_visitSwitchDefault_multipleLabels() {
_assertSource(
"l1: l2: default: {}",
AstFactory.switchDefault(
[AstFactory.label2("l1"), AstFactory.label2("l2")],
[AstFactory.block()]));
}
void test_visitSwitchDefault_multipleStatements() {
_assertSource(
"default: {} {}",
AstFactory.switchDefault2([AstFactory.block(), AstFactory.block()]));
}
void test_visitSwitchDefault_noLabels() {
_assertSource(
"default: {}",
AstFactory.switchDefault2([AstFactory.block()]));
}
void test_visitSwitchDefault_singleLabel() {
_assertSource(
"l1: default: {}",
AstFactory.switchDefault([AstFactory.label2("l1")], [AstFactory.block()]));
}
void test_visitSwitchStatement() {
_assertSource(
"switch (a) {case 'b': {} default: {}}",
AstFactory.switchStatement(
AstFactory.identifier3("a"),
[
AstFactory.switchCase(AstFactory.string2("b"), [AstFactory.block()]),
AstFactory.switchDefault2([AstFactory.block()])]));
}
void test_visitSymbolLiteral_multiple() {
_assertSource("#a.b.c", AstFactory.symbolLiteral(["a", "b", "c"]));
}
void test_visitSymbolLiteral_single() {
_assertSource("#a", AstFactory.symbolLiteral(["a"]));
}
void test_visitThisExpression() {
_assertSource("this", AstFactory.thisExpression());
}
void test_visitThrowStatement() {
_assertSource(
"throw e",
AstFactory.throwExpression2(AstFactory.identifier3("e")));
}
void test_visitTopLevelVariableDeclaration_multiple() {
_assertSource(
"var a;",
AstFactory.topLevelVariableDeclaration2(
Keyword.VAR,
[AstFactory.variableDeclaration("a")]));
}
void test_visitTopLevelVariableDeclaration_single() {
_assertSource(
"var a, b;",
AstFactory.topLevelVariableDeclaration2(
Keyword.VAR,
[AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]));
}
void test_visitTryStatement_catch() {
_assertSource(
"try {} on E {}",
AstFactory.tryStatement2(
AstFactory.block(),
[AstFactory.catchClause3(AstFactory.typeName4("E"))]));
}
void test_visitTryStatement_catches() {
_assertSource(
"try {} on E {} on F {}",
AstFactory.tryStatement2(
AstFactory.block(),
[
AstFactory.catchClause3(AstFactory.typeName4("E")),
AstFactory.catchClause3(AstFactory.typeName4("F"))]));
}
void test_visitTryStatement_catchFinally() {
_assertSource(
"try {} on E {} finally {}",
AstFactory.tryStatement3(
AstFactory.block(),
[AstFactory.catchClause3(AstFactory.typeName4("E"))],
AstFactory.block()));
}
void test_visitTryStatement_finally() {
_assertSource(
"try {} finally {}",
AstFactory.tryStatement(AstFactory.block(), AstFactory.block()));
}
void test_visitTypeArgumentList_multiple() {
_assertSource(
"<E, F>",
AstFactory.typeArgumentList(
[AstFactory.typeName4("E"), AstFactory.typeName4("F")]));
}
void test_visitTypeArgumentList_single() {
_assertSource(
"<E>",
AstFactory.typeArgumentList([AstFactory.typeName4("E")]));
}
void test_visitTypeName_multipleArgs() {
_assertSource(
"C<D, E>",
AstFactory.typeName4(
"C",
[AstFactory.typeName4("D"), AstFactory.typeName4("E")]));
}
void test_visitTypeName_nestedArg() {
_assertSource(
"C<D<E>>",
AstFactory.typeName4(
"C",
[AstFactory.typeName4("D", [AstFactory.typeName4("E")])]));
}
void test_visitTypeName_noArgs() {
_assertSource("C", AstFactory.typeName4("C"));
}
void test_visitTypeName_singleArg() {
_assertSource(
"C<D>",
AstFactory.typeName4("C", [AstFactory.typeName4("D")]));
}
void test_visitTypeParameter_withExtends() {
_assertSource(
"E extends C",
AstFactory.typeParameter2("E", AstFactory.typeName4("C")));
}
void test_visitTypeParameter_withMetadata() {
TypeParameter parameter = AstFactory.typeParameter("E");
parameter.metadata =
[AstFactory.annotation(AstFactory.identifier3("deprecated"))];
_assertSource("@deprecated E", parameter);
}
void test_visitTypeParameter_withoutExtends() {
_assertSource("E", AstFactory.typeParameter("E"));
}
void test_visitTypeParameterList_multiple() {
_assertSource("<E, F>", AstFactory.typeParameterList(["E", "F"]));
}
void test_visitTypeParameterList_single() {
_assertSource("<E>", AstFactory.typeParameterList(["E"]));
}
void test_visitVariableDeclaration_initialized() {
_assertSource(
"a = b",
AstFactory.variableDeclaration2("a", AstFactory.identifier3("b")));
}
void test_visitVariableDeclaration_uninitialized() {
_assertSource("a", AstFactory.variableDeclaration("a"));
}
void test_visitVariableDeclaration_withMetadata() {
VariableDeclaration declaration = AstFactory.variableDeclaration("a");
declaration.metadata =
[AstFactory.annotation(AstFactory.identifier3("deprecated"))];
_assertSource("@deprecated a", declaration);
}
void test_visitVariableDeclarationList_const_type() {
_assertSource(
"const C a, b",
AstFactory.variableDeclarationList(
Keyword.CONST,
AstFactory.typeName4("C"),
[AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]));
}
void test_visitVariableDeclarationList_final_noType() {
_assertSource(
"final a, b",
AstFactory.variableDeclarationList2(
Keyword.FINAL,
[AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]));
}
void test_visitVariableDeclarationList_final_withMetadata() {
VariableDeclarationList declarationList =
AstFactory.variableDeclarationList2(
Keyword.FINAL,
[AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]);
declarationList.metadata =
[AstFactory.annotation(AstFactory.identifier3("deprecated"))];
_assertSource("@deprecated final a, b", declarationList);
}
void test_visitVariableDeclarationList_type() {
_assertSource(
"C a, b",
AstFactory.variableDeclarationList(
null,
AstFactory.typeName4("C"),
[AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]));
}
void test_visitVariableDeclarationList_var() {
_assertSource(
"var a, b",
AstFactory.variableDeclarationList2(
Keyword.VAR,
[AstFactory.variableDeclaration("a"), AstFactory.variableDeclaration("b")]));
}
void test_visitVariableDeclarationStatement() {
_assertSource(
"C c;",
AstFactory.variableDeclarationStatement(
null,
AstFactory.typeName4("C"),
[AstFactory.variableDeclaration("c")]));
}
void test_visitWhileStatement() {
_assertSource(
"while (c) {}",
AstFactory.whileStatement(AstFactory.identifier3("c"), AstFactory.block()));
}
void test_visitWithClause_multiple() {
_assertSource(
"with A, B, C",
AstFactory.withClause(
[
AstFactory.typeName4("A"),
AstFactory.typeName4("B"),
AstFactory.typeName4("C")]));
}
void test_visitWithClause_single() {
_assertSource("with A", AstFactory.withClause([AstFactory.typeName4("A")]));
}
void test_visitYieldStatement() {
_assertSource(
"yield e;",
AstFactory.yieldStatement(AstFactory.identifier3("e")));
}
void test_visitYieldStatement_each() {
_assertSource(
"yield* e;",
AstFactory.yieldEachStatement(AstFactory.identifier3("e")));
}
/**
* Assert that a `ToSourceVisitor` will produce the expected source when visiting the given
* node.
*
* @param expectedSource the source string that the visitor is expected to produce
* @param node the AST node being visited to produce the actual source
* @throws AFE if the visitor does not produce the expected source for the given node
*/
void _assertSource(String expectedSource, AstNode node) {
PrintStringWriter writer = new PrintStringWriter();
node.accept(new ToSourceVisitor(writer));
expect(writer.toString(), expectedSource);
}
}
@reflectiveTest
class VariableDeclarationTest extends ParserTestCase {
void test_getDocumentationComment_onGrandParent() {
VariableDeclaration varDecl = AstFactory.variableDeclaration("a");
TopLevelVariableDeclaration decl =
AstFactory.topLevelVariableDeclaration2(Keyword.VAR, [varDecl]);
Comment comment = Comment.createDocumentationComment(new List<Token>(0));
expect(varDecl.documentationComment, isNull);
decl.documentationComment = comment;
expect(varDecl.documentationComment, isNotNull);
expect(decl.documentationComment, isNotNull);
}
void test_getDocumentationComment_onNode() {
VariableDeclaration decl = AstFactory.variableDeclaration("a");
Comment comment = Comment.createDocumentationComment(new List<Token>(0));
decl.documentationComment = comment;
expect(decl.documentationComment, isNotNull);
}
}
class WrapperKind extends Enum<WrapperKind> {
static const WrapperKind PREFIXED_LEFT =
const WrapperKind('PREFIXED_LEFT', 0);
static const WrapperKind PREFIXED_RIGHT =
const WrapperKind('PREFIXED_RIGHT', 1);
static const WrapperKind PROPERTY_LEFT =
const WrapperKind('PROPERTY_LEFT', 2);
static const WrapperKind PROPERTY_RIGHT =
const WrapperKind('PROPERTY_RIGHT', 3);
static const WrapperKind NONE = const WrapperKind('NONE', 4);
static const List<WrapperKind> values = const [
PREFIXED_LEFT,
PREFIXED_RIGHT,
PROPERTY_LEFT,
PROPERTY_RIGHT,
NONE];
const WrapperKind(String name, int ordinal) : super(name, ordinal);
}
Reference in New Issue View Git Blame Copy Permalink