| // Copyright (c) 2012, 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. |
| package com.google.dart.compiler.parser; |
| |
| import com.google.common.base.Joiner; |
| import com.google.dart.compiler.CompilerTestCase; |
| import com.google.dart.compiler.ast.DartClass; |
| import com.google.dart.compiler.ast.DartIdentifier; |
| import com.google.dart.compiler.ast.DartMethodDefinition; |
| import com.google.dart.compiler.ast.DartNode; |
| import com.google.dart.compiler.ast.DartUnit; |
| |
| import static com.google.dart.compiler.common.ErrorExpectation.assertErrors; |
| import static com.google.dart.compiler.common.ErrorExpectation.errEx; |
| |
| import java.util.List; |
| import java.util.Set; |
| |
| /** |
| * Negative Parser/Syntax tests. |
| */ |
| public class NegativeParserTest extends CompilerTestCase { |
| public void test_deprecatedGetterSyntax() { |
| parseExpectErrors("get foo() {}", errEx(ParserErrorCode.DEPRECATED_GETTER, 1, 5, 3)); |
| } |
| |
| public void test_deprecatedStrictEQ() { |
| parseExpectErrors(makeCode( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "main() {", |
| " 1 === 2;", |
| "}", |
| ""), errEx(ParserErrorCode.DEPRECATED_STRICT_EQ, 3, 5, 3)); |
| } |
| |
| public void test_deprecatedStrictNE() { |
| parseExpectErrors(makeCode( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "main() {", |
| " 1 !== 2;", |
| "}", |
| ""), errEx(ParserErrorCode.DEPRECATED_STRICT_NE, 3, 5, 3)); |
| } |
| |
| public void test_deprecatedAbstract() { |
| parseExpectWarnings(makeCode( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "abstract class A {", |
| " abstract m();", |
| "}", |
| ""), errEx(ParserErrorCode.DEPRECATED_ABSTRACT_METHOD, 3, 3, 8)); |
| } |
| |
| public void testFieldInitializerInRedirectionConstructor1() { |
| parseExpectErrors( |
| "class A { A(x) { } A.foo() : this(5), y = 5; var y; }", |
| errEx(ParserErrorCode.REDIRECTING_CONSTRUCTOR_OTHER, 1, 39, 5), |
| errEx(ParserErrorCode.REDIRECTING_CONSTRUCTOR_ITSELF, 1, 30, 7)); |
| } |
| |
| public void test_deprecatedFunctionLiteral() { |
| parseExpectWarnings( |
| makeCode( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "main() {", |
| " var x = f() => 42;", |
| " var y = int g() => 87;", |
| "}", |
| ""), |
| errEx(ParserErrorCode.DEPRECATED_FUNCTION_LITERAL, 3, 11, 1), |
| errEx(ParserErrorCode.DEPRECATED_FUNCTION_LITERAL, 4, 11, 3)); |
| } |
| |
| public void testFieldInitializerInRedirectionConstructor2() { |
| parseExpectErrors( |
| "class A { A(x) { } A.foo() : y = 5, this(5); var y; }", |
| errEx(ParserErrorCode.REDIRECTING_CONSTRUCTOR_OTHER, 1, 30, 5), |
| errEx(ParserErrorCode.REDIRECTING_CONSTRUCTOR_ITSELF, 1, 37, 7)); |
| } |
| |
| public void testFieldInitializerInRedirectionConstructor3() { |
| parseExpectErrors( |
| "class A { A.foo(x) { } A() : y = 5, this.foo(5); var y; }", |
| errEx(ParserErrorCode.REDIRECTING_CONSTRUCTOR_OTHER, 1, 30, 5), |
| errEx(ParserErrorCode.REDIRECTING_CONSTRUCTOR_ITSELF, 1, 37, 11)); |
| } |
| |
| public void testFieldInitializerInRedirectionConstructor4() { |
| parseExpectErrors( |
| "class A { A(x) { } A.foo(this.y, this.z) : this(5); var y; var z;}", |
| errEx(ParserErrorCode.REDIRECTING_CONSTRUCTOR_PARAM, 1, 26, 6), |
| errEx(ParserErrorCode.REDIRECTING_CONSTRUCTOR_PARAM, 1, 34, 6), |
| errEx(ParserErrorCode.REDIRECTING_CONSTRUCTOR_ITSELF, 1, 44, 7)); |
| } |
| |
| public void testFieldInitializerInRedirectionConstructor5() { |
| parseExpectErrors( |
| "class A { A(x) { } A.foo(this.y) : this(5), z = 7; var y; var z;}", |
| errEx(ParserErrorCode.REDIRECTING_CONSTRUCTOR_PARAM, 1, 26, 6), |
| errEx(ParserErrorCode.REDIRECTING_CONSTRUCTOR_OTHER, 1, 45, 5), |
| errEx(ParserErrorCode.REDIRECTING_CONSTRUCTOR_ITSELF, 1, 36, 7)); |
| } |
| |
| public void testSuperInRedirectionConstructor1() { |
| parseExpectErrors( |
| "class A { A(x) { } A.foo() : this(5), super(); var y; }", |
| errEx(ParserErrorCode.REDIRECTING_CONSTRUCTOR_OTHER, 1, 39, 7), |
| errEx(ParserErrorCode.REDIRECTING_CONSTRUCTOR_ITSELF, 1, 30, 7)); |
| } |
| |
| public void testSuperInRedirectionConstructor2() { |
| parseExpectErrors( |
| "class A { A(x) { } A.foo() : super(), this(5); var y; }", |
| errEx(ParserErrorCode.REDIRECTING_CONSTRUCTOR_OTHER, 1, 30, 7), |
| errEx(ParserErrorCode.REDIRECTING_CONSTRUCTOR_ITSELF, 1, 39, 7)); |
| } |
| |
| public void testMultipleRedirectionConstructors() { |
| parseExpectErrors( |
| "class A { A(x) { } A.foo() : this(1), this(2); }", |
| errEx(ParserErrorCode.REDIRECTING_CONSTRUCTOR_MULTIPLE, 1, 30, 7), |
| errEx(ParserErrorCode.REDIRECTING_CONSTRUCTOR_MULTIPLE, 1, 39, 7)); |
| } |
| |
| /** |
| * May be parsing errors, but not exceptions. |
| * <p> |
| * http://code.google.com/p/dart/issues/detail?id=4040 |
| */ |
| public void test_incompleteArguments() { |
| parseSource(makeCode( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "main() {", |
| " f(a: 0,", |
| "}", |
| "")); |
| } |
| |
| public void testSuperMultipleInvocationsTest() { |
| String source = |
| makeCode( |
| "class A {", |
| " int a;", |
| " A(this.a);", |
| " A.foo(int x, int y);", |
| "}", |
| "", |
| "class B extends A {", |
| " int b1;", |
| " int b2;", |
| " B(int x) : this.b1 = x, super(x), this.b2 = x, super.foo(x, x);", |
| "}"); |
| parseExpectErrors( |
| source, |
| errEx(ParserErrorCode.SUPER_CONSTRUCTOR_MULTIPLE, 10, 29, 8), |
| errEx(ParserErrorCode.SUPER_CONSTRUCTOR_MULTIPLE, 10, 52, 15)); |
| } |
| |
| public void testIncompleteClassDeclaration_noLBrace() { |
| String sourceCode = |
| makeCode( |
| "class Baz", |
| "class Foo<T> implements Bar<T> {", |
| " Foo(T head, Bar<T> tail);", |
| "}"); |
| DartUnit unit = |
| parseSourceUnitErrors( |
| sourceCode, |
| ParserErrorCode.EXPECTED_CLASS_DECLARATION_LBRACE.getMessage(), |
| 2, |
| 1); |
| // check structure of AST, top level Baz and Foo expected |
| assertEquals(2, unit.getTopLevelNodes().size()); |
| assertEquals( |
| makeCode( |
| "// unit Test.dart", |
| "class Baz {", |
| "}", |
| "", |
| "class Foo<T> implements Bar<T> {", |
| "", |
| " Foo(T head, Bar<T> tail) ;", |
| "}", |
| ""), |
| unit.toSource()); |
| } |
| |
| /** |
| * Language specification requires that factory should be declared in class. However declaring |
| * factory on top level should not cause exceptions in compiler. To ensure this we parse top level |
| * factory into normal {@link DartMethodDefinition}. |
| * <p> |
| * http://code.google.com/p/dart/issues/detail?id=345 |
| */ |
| public void test_badTopLevelFactory() { |
| DartUnit unit = |
| parseSourceUnitErrors( |
| "factory foo() {}", |
| ParserErrorCode.FACTORY_CANNOT_BE_TOP_LEVEL.getMessage(), |
| 1, |
| 1); |
| DartMethodDefinition factory = (DartMethodDefinition) unit.getTopLevelNodes().get(0); |
| assertNotNull(factory); |
| // this factory has name, which is allowed for normal method |
| assertEquals(true, factory.getName() instanceof DartIdentifier); |
| assertEquals("foo", ((DartIdentifier) factory.getName()).getName()); |
| } |
| |
| public void test_defaultParameterValue_inClosureTypedef() { |
| parseExpectErrors( |
| "typedef void f(int a, [int b = 12345, inc c]);", |
| errEx(ParserErrorCode.DEFAULT_VALUE_CAN_NOT_BE_SPECIFIED_IN_TYPEDEF, 1, 32, 5)); |
| } |
| |
| public void test_defaultParameterValue_inClosure() { |
| parseExpectErrors( |
| "class A {void f(void cb(int a, [int b = 12345, int c])) {}}", |
| errEx(ParserErrorCode.DEFAULT_VALUE_CAN_NOT_BE_SPECIFIED_IN_CLOSURE, 1, 41, 5)); |
| } |
| |
| public void test_optionalPositionalParameterValue_inSetter() { |
| parseExpectErrors( |
| "class A { set f([int b]); }", |
| errEx(ParserErrorCode.OPTIONAL_POSITIONAL_PARAMETER_NOT_ALLOWED, 1, 18, 5)); |
| } |
| |
| public void test_namedParameterValue_inSetter() { |
| parseExpectErrors( |
| "class A { set f({int b}); }", |
| errEx(ParserErrorCode.NAMED_PARAMETER_NOT_ALLOWED, 1, 18, 5)); |
| } |
| |
| public void test_missingEndOfOptionalParameters() { |
| parseExpectErrors( |
| "class A {void m(var p1, [var p2 = const []) {} }", |
| errEx(ParserErrorCode.MISSING_OPTIONAL_PARAMETER_END, 1, 43, 1)); |
| } |
| |
| public void test_optionalPositionalParameterValue_inOperator() { |
| parseExpectErrors( |
| "class A { operator []=(int a, [int b]); }", |
| errEx(ParserErrorCode.OPTIONAL_POSITIONAL_PARAMETER_NOT_ALLOWED, 1, 32, 5)); |
| } |
| |
| public void test_namedParameterValue_inOperator() { |
| parseExpectErrors( |
| "class A { operator []=(int a, {int b}); }", |
| errEx(ParserErrorCode.NAMED_PARAMETER_NOT_ALLOWED, 1, 32, 5)); |
| } |
| |
| /** |
| * If keyword "extends" is mistyped in type parameters declaration, we should report about this |
| * and then recover correctly. |
| * <p> |
| * http://code.google.com/p/dart/issues/detail?id=341 |
| */ |
| public void test_parseTypeParameter_expectedExtends_mistypedExtends() throws Exception { |
| DartParserRunner parserRunner = |
| parseSource(Joiner.on("\n").join( |
| "class A {", |
| "}", |
| "class B<X ex> {", |
| "}", |
| "class C<X extneds A> {", |
| "}", |
| "class D<X extneds A, Y extends A> {", |
| "}")); |
| // check expected errors |
| assertErrors( |
| parserRunner.getErrors(), |
| errEx(ParserErrorCode.EXPECTED_EXTENDS, 3, 11, 2), |
| errEx(ParserErrorCode.EXPECTED_EXTENDS, 5, 11, 7), |
| errEx(ParserErrorCode.EXPECTED_EXTENDS, 7, 11, 7)); |
| // check structure of AST |
| DartUnit dartUnit = parserRunner.getDartUnit(); |
| String expected = |
| Joiner.on("\n").join( |
| "// unit " + getName(), |
| "class A {", |
| "}", |
| "", |
| "class B<X> {", |
| "}", |
| "", |
| "class C<X extends A> {", |
| "}", |
| "", |
| "class D<X extends A, Y extends A> {", |
| "}"); |
| String actual = dartUnit.toSource().trim(); |
| if (!expected.equals(actual)) { |
| System.err.println("Expected:\n" + expected); |
| System.err.println("\nActual:\n" + actual); |
| } |
| assertEquals(expected, actual); |
| } |
| |
| /** |
| * Type parameters declaration is not finished. |
| * <p> |
| * http://code.google.com/p/dart/issues/detail?id=341 |
| */ |
| public void test_parseTypeParameter_unfinishedTypeParameters() throws Exception { |
| DartParserRunner parserRunner = |
| parseSource(Joiner.on("\n").join( |
| "class ClassWithLongEnoughName {", |
| "}", |
| "class B<X {", |
| "}", |
| "class C {", |
| "}")); |
| // check expected errors |
| assertErrors( |
| parserRunner.getErrors(), |
| errEx(ParserErrorCode.EXPECTED_EXTENDS, 3, 11, 1), |
| errEx(ParserErrorCode.EXPECTED_TOKEN, 4, 1, 1), |
| errEx(ParserErrorCode.EXPECTED_CLASS_DECLARATION_LBRACE, 5, 1, 5)); |
| // check structure of AST |
| DartUnit dartUnit = parserRunner.getDartUnit(); |
| assertEquals( |
| Joiner.on("\n").join( |
| "// unit " + getName(), |
| "class ClassWithLongEnoughName {", |
| "}", |
| "", |
| "class B<X> {", |
| "}", |
| "", |
| "class C {", |
| "}"), |
| dartUnit.toSource().trim()); |
| } |
| |
| /** |
| * Type parameters declaration is not finished, next top level element beginning encountered. May |
| * be use just types new class declaration before existing one. |
| * <p> |
| * http://code.google.com/p/dart/issues/detail?id=341 |
| */ |
| public void test_parseTypeParameter_nextTopLevelInTheMiddle() throws Exception { |
| DartParserRunner parserRunner = |
| parseSource(Joiner.on("\n").join( |
| "class ClassWithLongEnoughName {", |
| "}", |
| "class B<X", |
| "class C {", |
| "}")); |
| // check expected errors |
| assertErrors(parserRunner.getErrors(), |
| errEx(ParserErrorCode.EXPECTED_TOKEN, 4, 1, 5)); |
| |
| // check structure of AST |
| DartUnit dartUnit = parserRunner.getDartUnit(); |
| assertEquals( |
| Joiner.on("\n").join( |
| "// unit " + getName(), |
| "class ClassWithLongEnoughName {", |
| "}", |
| "", |
| "class B<X> {", |
| "}", |
| "", |
| "class C {", |
| "}"), |
| dartUnit.toSource().trim()); |
| } |
| |
| /** |
| * Function signatures require the name to be an identifier; especially true at the top level. |
| * <p> |
| * http://code.google.com/p/dart/issues/detail?id=839 |
| */ |
| public void testTopLevelFunctionNotIdentifier() { |
| parseExpectErrors( |
| "foo.baz() {}", |
| errEx(ParserErrorCode.FUNCTION_NAME_EXPECTED_IDENTIFIER, 1, 1, 7)); |
| } |
| |
| public void testInvalidStringInterpolation() { |
| parseExpectErrors( |
| Joiner.on("\n").join( |
| "void main() {", |
| " print(\"1 ${42} 2 ${} 3\");", |
| " print(\"1 ${42} 2 ${10;} 3\");", |
| " print(\"1 ${42} 2 ${10,20} 3\");", |
| " print(\"1 ${42} 2 ${10 20} 3\");", |
| " print(\"$\");", |
| " print(\"$", |
| "}"), |
| errEx(ParserErrorCode.UNEXPECTED_TOKEN, 2, 22, 1), |
| errEx(ParserErrorCode.EXPECTED_TOKEN, 2, 23, 3), |
| errEx(ParserErrorCode.EXPECTED_TOKEN, 3, 24, 1), |
| errEx(ParserErrorCode.UNEXPECTED_TOKEN_IN_STRING_INTERPOLATION, 3, 25, 1), |
| errEx(ParserErrorCode.EXPECTED_TOKEN, 4, 24, 1), |
| errEx(ParserErrorCode.UNEXPECTED_TOKEN_IN_STRING_INTERPOLATION, 4, 25, 2), |
| errEx(ParserErrorCode.UNEXPECTED_TOKEN_IN_STRING_INTERPOLATION, 4, 27, 1), |
| errEx(ParserErrorCode.EXPECTED_TOKEN, 5, 25, 2), |
| errEx(ParserErrorCode.UNEXPECTED_TOKEN_IN_STRING_INTERPOLATION, 5, 27, 1), |
| errEx(ParserErrorCode.UNEXPECTED_TOKEN_IN_STRING_INTERPOLATION, 6, 11, 0), |
| errEx(ParserErrorCode.UNEXPECTED_TOKEN_IN_STRING_INTERPOLATION, 7, 11, 0), |
| errEx(ParserErrorCode.UNEXPECTED_TOKEN_IN_STRING_INTERPOLATION, 7, 11, 1), |
| errEx(ParserErrorCode.UNEXPECTED_TOKEN_IN_STRING_INTERPOLATION, 8, 1, 1), |
| errEx(ParserErrorCode.INCOMPLETE_STRING_LITERAL, 8, 1, 1), |
| errEx(ParserErrorCode.EXPECTED_COMMA_OR_RIGHT_PAREN, 8, 2, 0)); |
| } |
| |
| public void testDeprecatedFactoryInInterface() { |
| parseExpectWarnings( |
| "interface foo factory bar {}", |
| errEx(ParserErrorCode.DEPRECATED_INTERFACE, 1, 1, 9), |
| errEx(ParserErrorCode.DEPRECATED_USE_OF_FACTORY_KEYWORD, 1, 15, 7)); |
| } |
| |
| public void test_deprecatedRawString() { |
| parseExpectWarnings( |
| "String s() { return @'s'; }", |
| errEx(ParserErrorCode.DEPRECATED_RAW_STRING, 1, 21, 1)); |
| } |
| |
| public void test_useExtendsInTypedef() { |
| parseExpectErrors(Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "typedef ParameterizedFun1<T, U extends bool, V>(T t, U u);", |
| "")); |
| } |
| |
| public void test_abstractTopLevel_class() { |
| parseExpectErrors(Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "abstract class A {", |
| "}")); |
| } |
| |
| public void test_abstractTopLevel_interface() { |
| parseExpectErrors( |
| Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "abstract interface A {", |
| "}"), |
| errEx(ParserErrorCode.DEPRECATED_INTERFACE, 2, 10, 9), |
| errEx(ParserErrorCode.ABSTRACT_TOP_LEVEL_ELEMENT, 2, 1, 8)); |
| } |
| |
| public void test_deprecatedInterface() { |
| parseExpectErrors( |
| Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "interface A {", |
| "}"), |
| errEx(ParserErrorCode.DEPRECATED_INTERFACE, 2, 1, 9)); |
| } |
| |
| public void test_abstractTopLevel_typedef() { |
| parseExpectErrors( |
| "abstract typedef void f();", |
| errEx(ParserErrorCode.ABSTRACT_TOP_LEVEL_ELEMENT, 1, 1, 8)); |
| } |
| |
| public void test_abstractTopLevel_method() { |
| parseExpectErrors( |
| "abstract void foo() {}", |
| errEx(ParserErrorCode.ABSTRACT_TOP_LEVEL_ELEMENT, 1, 1, 8)); |
| } |
| |
| public void test_incompleteExpressionInInterpolation() { |
| parseExpectErrors( |
| "var s = 'fib(3) = ${fib(3}';", |
| errEx(ParserErrorCode.EXPECTED_COMMA_OR_RIGHT_PAREN, 1, 26, 1)); |
| } |
| |
| public void test_interfaceMethodWithBody() { |
| parseExpectErrors( |
| Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "interface A {", |
| " foo() {", |
| " }", |
| "}"), |
| errEx(ParserErrorCode.DEPRECATED_INTERFACE, 2, 1, 9), |
| errEx(ParserErrorCode.INTERFACE_METHOD_WITH_BODY, 3, 3, 3)); |
| } |
| |
| /** |
| * The Language Specification in the section 6.1 states: "It is a compile-time error to preface a |
| * function declaration with the built-in identifier static." |
| */ |
| public void test_staticFunction_topLevel() { |
| parseExpectErrors( |
| Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "static foo() {", |
| "}"), |
| errEx(ParserErrorCode.TOP_LEVEL_CANNOT_BE_STATIC, 2, 1, 6)); |
| } |
| |
| /** |
| * The Language Specification in the section 6.1 states: "It is a compile-time error to preface a |
| * function declaration with the built-in identifier static." |
| */ |
| public void test_staticFunction_local() { |
| DartParserRunner parserRunner = |
| parseExpectErrors( |
| Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "topLevelMethodWithLongEnoughNameToForceWrapping() {", |
| " static int localFunction() {", |
| " }", |
| "}"), |
| errEx(ParserErrorCode.LOCAL_CANNOT_BE_STATIC, 3, 3, 6)); |
| // Check that "static" was ignored and "int" parsed as return type. |
| assertEquals( |
| makeCode( |
| "// unit " + getName(), |
| "", |
| "topLevelMethodWithLongEnoughNameToForceWrapping() {", |
| " int localFunction() {", |
| " };", |
| "}"), |
| parserRunner.getDartUnit().toSource()); |
| } |
| |
| public void test_positionalArgument_afterNamed() { |
| parseExpectErrors( |
| Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "f(r1, [n1, n2]) {}", |
| "foo() {", |
| " f(-1, n1: 1, 2);", |
| "}"), |
| errEx(ParserErrorCode.POSITIONAL_AFTER_NAMED_ARGUMENT, 4, 16, 1)); |
| } |
| |
| public void test_unaryPlus() { |
| parseExpectErrors( |
| Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "var a = 1;", |
| "var b = -1;", |
| "var c = +1;", |
| "var d = -a;", |
| "var e = +a;", |
| "var f = + 1;", |
| ""), |
| errEx(ParserErrorCode.NO_UNARY_PLUS_OPERATOR, 6, 9, 1), |
| errEx(ParserErrorCode.NO_SPACE_AFTER_PLUS, 7, 9, 1)); |
| } |
| |
| public void test_formalParameters_const() throws Exception { |
| parseExpectErrors( |
| Joiner.on("\n").join( |
| "func_const(const x) {}", |
| "func_constTyped(const int $) {}"), |
| errEx(ParserErrorCode.FORMAL_PARAMETER_IS_CONST, 1, 12, 5), |
| errEx(ParserErrorCode.FORMAL_PARAMETER_IS_CONST, 2, 17, 5)); |
| } |
| |
| /** |
| * Test with variants of function declarations and function literal invocations. |
| */ |
| public void test_functionDeclaration_functionLiteral() { |
| DartParserRunner parserRunner = |
| parseExpectErrors(Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "foo() {", |
| " f0(p){}", // declaration of function as statement |
| " int f1(p){}", // declaration of function as statement, has type |
| " var res = (p){}(1);", // invocation of function literal in assignment |
| " (p){}(2);", // invocation of function literal in statement, no name |
| " f3(p) => 4;", // function with => arrow ends with ';' |
| " (5);", // this is separate statement, not invocation of previous function |
| " join(promises, (p) => 6);", // function with => arrow as argument |
| " join(promises, (p) {return 7;});", // function with block as argument |
| "}", |
| "")); |
| assertEquals( |
| makeCode( |
| "// unit " + getName(), |
| "", |
| "foo() {", |
| " f0(p) {", |
| " };", |
| " int f1(p) {", |
| " };", |
| " var res = (p) {", |
| " }(1);", |
| " (p) {", |
| " }(2);", |
| " f3(p) {", |
| " return 4;", |
| " };", |
| " (5);", |
| " join(promises, (p) {", |
| " return 6;", |
| " });", |
| " join(promises, (p) {", |
| " return 7;", |
| " });", |
| "}"), |
| parserRunner.getDartUnit().toSource()); |
| } |
| |
| /** |
| * Test for {@link DartUnit#getTopDeclarationNames()}. |
| */ |
| public void test_getTopDeclarationNames() throws Exception { |
| DartParserRunner parserRunner = |
| parseSource(Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "class MyClass {}", |
| "class MyInterface {}", |
| "topLevelMethod() {}", |
| "int get topLevelGetter {return 0;}", |
| "void set topLevelSetter(int v) {}", |
| "typedef void MyTypeDef();", |
| "")); |
| DartUnit unit = parserRunner.getDartUnit(); |
| // Check top level declarations. |
| Set<String> names = unit.getTopDeclarationNames(); |
| assertEquals(6, names.size()); |
| assertTrue(names.contains("MyClass")); |
| assertTrue(names.contains("MyInterface")); |
| assertTrue(names.contains("topLevelMethod")); |
| assertTrue(names.contains("topLevelGetter")); |
| assertTrue(names.contains("topLevelSetter")); |
| assertTrue(names.contains("MyTypeDef")); |
| } |
| |
| /** |
| * Test for {@link DartUnit#getTopDeclarationNames()} and qualified top-level method name. |
| * <p> |
| * http://code.google.com/p/dart/issues/detail?id=1738 |
| */ |
| public void test_getTopDeclarationNames_badName() throws Exception { |
| DartParserRunner parserRunner = |
| parseSource(Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "void my.method() {}", |
| "")); |
| DartUnit unit = parserRunner.getDartUnit(); |
| // We have top-level node... |
| List<DartNode> topLevelNodes = unit.getTopLevelNodes(); |
| assertEquals(1, topLevelNodes.size()); |
| // ...but it has wrong name, so ignored. |
| Set<String> names = unit.getTopDeclarationNames(); |
| assertEquals(0, names.size()); |
| } |
| |
| /** |
| * Test for {@link DartUnit#getDeclarationNames()}. |
| */ |
| public void test_getDeclarationNames() throws Exception { |
| DartParserRunner parserRunner = |
| parseSource(Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "class MyClass<TypeVar> {", |
| " myMethod(int pA, int pB) {", |
| " int varA;", |
| " try {", |
| " } catch(var ex) {", |
| " }", |
| " }", |
| "}", |
| "topLevelMethod() {}", |
| "int get topLevelGetter {return 0;}", |
| "void set topLevelSetter(int setterParam) {}", |
| "typedef void MyTypeDef();", |
| "")); |
| DartUnit unit = parserRunner.getDartUnit(); |
| // Check all declarations. |
| Set<String> names = unit.getDeclarationNames(); |
| assertEquals(12, names.size()); |
| assertTrue(names.contains("MyClass")); |
| assertTrue(names.contains("TypeVar")); |
| assertTrue(names.contains("myMethod")); |
| assertTrue(names.contains("pA")); |
| assertTrue(names.contains("pB")); |
| assertTrue(names.contains("varA")); |
| assertTrue(names.contains("ex")); |
| assertTrue(names.contains("topLevelMethod")); |
| assertTrue(names.contains("topLevelGetter")); |
| assertTrue(names.contains("topLevelSetter")); |
| assertTrue(names.contains("setterParam")); |
| assertTrue(names.contains("MyTypeDef")); |
| } |
| |
| /** |
| * There was bug in diet parser, it did not understand new "arrow" syntax of function definition. |
| */ |
| public void test_dietParser_functionArrow() { |
| DartParserRunner parserRunner = |
| DartParserRunner.parse( |
| getName(), |
| Joiner.on("\n").join( |
| "class ClassWithVeryLongNameEnoughToForceLineWrapping {", |
| " foo() => return 0;", |
| "}", |
| ""), |
| true); |
| assertErrors(parserRunner.getErrors()); |
| assertEquals( |
| Joiner.on("\n").join( |
| "// unit " + getName(), |
| "class ClassWithVeryLongNameEnoughToForceLineWrapping {", |
| "", |
| " foo() {", |
| " }", |
| "}"), |
| parserRunner.getDartUnit().toSource().trim()); |
| } |
| |
| /** |
| * "get" is valid name for method, it can cause warning, but not parsing failure. |
| */ |
| public void test_methodNamed_get() { |
| parseExpectErrors(Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "class A {", |
| " void get() {}", |
| "}", |
| "")); |
| } |
| |
| /** |
| * "set" is valid name for method, it can cause warning, but not parsing failure. |
| */ |
| public void test_methodNamed_set() { |
| parseExpectErrors(Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "class A {", |
| " void set() {}", |
| "}", |
| "")); |
| } |
| |
| /** |
| * "operator" is valid name for method, it can cause warning, but not parsing failure. |
| */ |
| public void test_methodNamed_operator() { |
| parseExpectErrors(Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "class A {", |
| " void operator() {}", |
| "}", |
| "")); |
| } |
| |
| /** |
| * We can parse operator "call" declaration. |
| */ |
| public void test_operator_call() { |
| parseExpectErrors(Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "class A {", |
| " operator call() {}", |
| "}", |
| "")); |
| } |
| |
| /** |
| * We can parse operator "equals" declaration. |
| */ |
| public void test_operator_equals() { |
| DartParserRunner runner = parseExpectErrors(Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "class A {", |
| " operator ==(other) => false;", |
| "}", |
| "")); |
| DartClass clazz = (DartClass) runner.getDartUnit().getTopLevelNodes().get(0); |
| DartMethodDefinition method = (DartMethodDefinition) clazz.getMembers().get(0); |
| assertTrue(method.getModifiers().isOperator()); |
| } |
| |
| /** |
| * "native" can be specified only for classes. |
| */ |
| public void test_native_inInterace() { |
| parseExpectErrors( |
| Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "interface A native 'N' {", |
| "}", |
| ""), |
| errEx(ParserErrorCode.DEPRECATED_INTERFACE, 2, 1, 9), |
| errEx(ParserErrorCode.NATIVE_ONLY_CLASS, 2, 13, 6)); |
| } |
| |
| /** |
| * "native" can be specified only for classes without "extends". |
| */ |
| public void test_native_classWithExtends() { |
| parseExpectErrors( |
| Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "class A {", |
| "}", |
| "class B extends A native 'N' {", |
| "}", |
| ""), |
| errEx(ParserErrorCode.NATIVE_ONLY_CORE_LIB, 4, 19, 6)); |
| } |
| |
| /** |
| * "native" can be specified only in "corelib". |
| */ |
| public void test_native_onlyCoreLib() { |
| parseExpectErrors( |
| Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "class A native 'N' {", |
| "}", |
| ""), |
| errEx(ParserErrorCode.NATIVE_ONLY_CORE_LIB, 2, 9, 6)); |
| } |
| |
| /** |
| * "native" can be specified only in "corelib". |
| */ |
| public void test_native_onlyCoreLib_factory() { |
| parseExpectErrors( |
| Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "class A {", |
| " factory A() native;", |
| "}", |
| ""), |
| errEx(ParserErrorCode.NATIVE_ONLY_CORE_LIB, 3, 15, 6)); |
| } |
| |
| /** |
| * "native" can be specified only in "corelib". |
| */ |
| public void test_native_onlyCoreLib_method() { |
| parseExpectErrors( |
| Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "class A {", |
| " factory A() native;", |
| "}", |
| ""), |
| errEx(ParserErrorCode.NATIVE_ONLY_CORE_LIB, 3, 15, 6)); |
| } |
| |
| /** |
| * The spec in the section 10.28 says: |
| * <p> |
| * It is a compile-time error if a built-in identifier is used as the declared name of a class, |
| * interface, type variable or type alias. |
| * <p> |
| * http://code.google.com/p/dart/issues/detail?id=3477 |
| */ |
| public void test_builtInIdentifier_asClassName() { |
| parseExpectErrors( |
| Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "class abstract {}", |
| "class as {}", |
| "class dynamic {}", |
| "class export {}", |
| "class external {}", |
| "class factory {}", |
| "class get {}", |
| "class implements {}", |
| "class import {}", |
| "class library {}", |
| "class operator {}", |
| "class part {}", |
| "class set {}", |
| "class static {}", |
| "class typedef {}", |
| ""), |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME, 2, 7, 8), // abstract |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME, 3, 7, 2), // as |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME, 4, 7, 7), // dynamic |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME, 5, 7, 6), // export |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME, 6, 7, 8), // external |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME, 7, 7, 7), // factory |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME, 8, 7, 3), // get |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME, 9, 7, 10), // implements |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME, 10, 7, 6), // import |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME, 11, 7, 7), // library |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME, 12, 7, 8), // operator |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME, 13, 7, 4), // part |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME, 14, 7, 3), // set |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME, 15, 7, 6), // static |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME, 16, 7, 7)); // typedef |
| } |
| |
| /** |
| * The spec in the section 10.28 says: |
| * <p> |
| * It is a compile-time error if a built-in identifier is used as the declared name of a class, |
| * interface, type variable or type alias. |
| * <p> |
| * http://code.google.com/p/dart/issues/detail?id=3477 |
| */ |
| public void test_builtInIdentifier_asTypevariableName() { |
| parseExpectErrors( |
| Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "class C01<abstract> {}", |
| "class C02<as> {}", |
| "class C03<dynamic> {}", |
| "class C04<export> {}", |
| "class C05<external> {}", |
| "class C06<factory> {}", |
| "class C07<get> {}", |
| "class C08<implements> {}", |
| "class C09<import> {}", |
| "class C10<library> {}", |
| "class C11<operator> {}", |
| "class C12<part> {}", |
| "class C13<set> {}", |
| "class C14<static> {}", |
| "class C15<typedef> {}", |
| ""), |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME, 2, 11, 8), // abstract |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME, 3, 11, 2), // as |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME, 4, 11, 7), // dynamic |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME, 5, 11, 6), // export |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME, 6, 11, 8), // external |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME, 7, 11, 7), // factory |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME, 8, 11, 3), // get |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME, 9, 11, 10), // implements |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME, 10, 11, 6), // import |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME, 11, 11, 7), // library |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME, 12, 11, 8), // operator |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME, 13, 11, 4), // part |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME, 14, 11, 3), // set |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME, 15, 11, 6), // static |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME, 16, 11, 7)); // typedef |
| } |
| |
| /** |
| * The spec in the section 10.28 says: |
| * <p> |
| * It is a compile-time error if a built-in identifier is used as the declared name of a class, |
| * interface, type variable or type alias. |
| * <p> |
| * http://code.google.com/p/dart/issues/detail?id=3477 |
| */ |
| public void test_builtInIdentifier_asTypedefName() { |
| parseExpectErrors( |
| Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "typedef abstract();", |
| "typedef as();", |
| "typedef dynamic();", |
| "typedef export();", |
| "typedef external();", |
| "typedef factory();", |
| "typedef get();", |
| "typedef implements();", |
| "typedef import();", |
| "typedef library();", |
| "typedef operator();", |
| "typedef part();", |
| "typedef set();", |
| "typedef static();", |
| "typedef typedef();", |
| ""), |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME, 2, 9, 8), // abstract |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME, 3, 9, 2), // as |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME, 4, 9, 7), // dynamic |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME, 5, 9, 6), // export |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME, 6, 9, 8), // external |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME, 7, 9, 7), // factory |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME, 8, 9, 3), // get |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME, 9, 9, 10), // implements |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME, 10, 9, 6), // import |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME, 11, 9, 7), // library |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME, 12, 9, 8), // operator |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME, 13, 9, 4), // part |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME, 14, 9, 3), // set |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME, 15, 9, 6), // static |
| errEx(ParserErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME, 16, 9, 7)); // typedef |
| } |
| |
| /** |
| * There is ambiguity in parsing function expression inside of initializer. |
| * <p> |
| * But we should be able to parse when function expression is inside of "new expression". |
| * <p> |
| * http://code.google.com/p/dart/issues/detail?id=2339 |
| */ |
| public void test_functionExpression_inInitializer_newExpression() { |
| parseExpectErrors( |
| Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "class A {", |
| " A(var p) {}", |
| "}", |
| "class B {", |
| " var f;", |
| " B() : f = new A(() => 42) {", |
| " }", |
| "}", |
| "")); |
| } |
| |
| /** |
| * There is ambiguity in parsing function expression inside of initializer. |
| * <p> |
| * But we should be able to parse when function expression is inside of "const expression". |
| * <p> |
| * http://code.google.com/p/dart/issues/detail?id=2339 |
| */ |
| public void test_functionExpression_inInitializer_constExpression() { |
| parseExpectErrors( |
| Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "class A {", |
| " const A(var p) {}", |
| "}", |
| "class B {", |
| " var f;", |
| " B() : f = const A(() => 42) {", |
| " }", |
| "}", |
| "")); |
| } |
| |
| /** |
| * There is ambiguity in parsing function expression inside of initializer. |
| * <p> |
| * But we should be able to parse when function expression is inside of "method invocation". |
| * <p> |
| * http://code.google.com/p/dart/issues/detail?id=2339 |
| */ |
| public void test_functionExpression_inInitializer_methodInvocation() { |
| parseExpectErrors( |
| Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "foo(var p) {}", |
| "class B {", |
| " var f;", |
| " B() : f = foo(() => 42) {", |
| " }", |
| "}", |
| "")); |
| } |
| |
| public void test_qualifiedType_inForIn() { |
| parseExpectErrors(Joiner.on("\n").join( |
| "// filler filler filler filler filler filler filler filler filler filler", |
| "foo() {", |
| " for (pref.A a in elements) {", |
| " }", |
| "}", |
| "")); |
| } |
| } |
