| // 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.type; |
| |
| import com.google.dart.compiler.parser.Token; |
| import com.google.dart.compiler.resolver.ClassElement; |
| import com.google.dart.compiler.resolver.ClassNodeElement; |
| import com.google.dart.compiler.resolver.CyclicDeclarationException; |
| import com.google.dart.compiler.resolver.TypeErrorCode; |
| |
| import java.util.EnumSet; |
| import java.util.Map; |
| |
| /** |
| * Test of static type analysis. This is mostly a test of {@link TypeAnalyzer}, but this test also |
| * exercises code in com.google.dart.compiler.resolver. |
| */ |
| public class TypeAnalyzerTest extends TypeAnalyzerTestCase { |
| |
| /** |
| * There was problem that cyclic class declaration caused infinite loop. |
| * <p> |
| * http://code.google.com/p/dart/issues/detail?id=348 |
| */ |
| public void test_cyclicDeclaration() { |
| Map<String, ClassNodeElement> source = loadSource( |
| "class Foo extends Bar {", |
| "}", |
| "class Bar extends Foo {", |
| "}"); |
| analyzeClasses(source); |
| // Foo and Bar have cyclic declaration |
| ClassElement classFoo = source.get("Foo"); |
| ClassElement classBar = source.get("Bar"); |
| assertEquals(classFoo, classBar.getSupertype().getElement()); |
| assertEquals(classBar, classFoo.getSupertype().getElement()); |
| } |
| |
| public void test_operator_indexAssign() { |
| Map<String, ClassNodeElement> source = loadSource( |
| "class A {", |
| "int operator []=(int index, var value) {}", |
| "}"); |
| analyzeClasses(source, TypeErrorCode.OPERATOR_INDEX_ASSIGN_VOID_RETURN_TYPE); |
| } |
| |
| public void testArrayLiteral() { |
| analyze("['x'];"); |
| analyze("<String>['x'];"); |
| analyzeFail("<int>['x'];", TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail("<String>['x', 1];", TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyze("List<String> strings = ['x'];"); |
| analyze("List<String> strings = <String>['x'];"); |
| analyze("List array = ['x'];"); |
| analyze("List array = <String>['x'];"); |
| analyze("List<int> ints = ['x'];"); |
| analyzeFail("List<int> ints = <String>['x'];", TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| } |
| |
| public void testBadInitializers() { |
| analyzeFail("int i = .0;", TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail("int j = 1.0;", TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| } |
| |
| public void testBinaryOperators() { |
| ClassElement cls = loadClass("class_with_operators.dart", "ClassWithOperators"); |
| analyzeIn(cls, "i = o[0]", 0); |
| analyzeIn(cls, "s = o[0]", 1); |
| analyzeIn(cls, "o['fisk']", 1); |
| analyzeIn(cls, "i && o", 2); |
| analyzeIn(cls, "b && o", 1); |
| analyzeIn(cls, "i && b", 1); |
| analyzeIn(cls, "b && b", 0); |
| analyzeIn(cls, "i || o", 2); |
| analyzeIn(cls, "b || o", 1); |
| analyzeIn(cls, "i || b", 1); |
| analyzeIn(cls, "b || b", 0); |
| |
| EnumSet<Token> userOperators = EnumSet.of(Token.ADD, |
| Token.SUB, |
| Token.MUL, |
| Token.DIV, |
| Token.TRUNC, |
| Token.MOD, |
| Token.LT, |
| Token.GT, |
| Token.LTE, |
| Token.GTE); |
| for (Token op : userOperators) { |
| String expression; |
| expression = String.format("untyped %s untyped", op.getSyntax()); |
| analyzeIn(cls, expression, 0); |
| expression = String.format("o = untyped %s untyped", op.getSyntax()); |
| analyzeIn(cls, expression, 0); |
| expression = String.format("s = untyped %s untyped", op.getSyntax()); |
| analyzeIn(cls, expression, 0); |
| expression = String.format("o %s untyped", op.getSyntax()); |
| analyzeIn(cls, expression, 0); |
| expression = String.format("o = o %s untyped", op.getSyntax()); |
| analyzeIn(cls, expression, 0); |
| expression = String.format("s = o %s untyped", op.getSyntax()); |
| analyzeIn(cls, expression, 1); |
| expression = String.format("o %s null", op.getSyntax()); |
| analyzeIn(cls, expression, 0); |
| expression = String.format("o = o %s null", op.getSyntax()); |
| analyzeIn(cls, expression, 0); |
| expression = String.format("s = o %s null", op.getSyntax()); |
| analyzeIn(cls, expression, 1); |
| expression = String.format("o %s o", op.getSyntax()); |
| analyzeIn(cls, expression, 0); |
| expression = String.format("o = o %s o", op.getSyntax()); |
| analyzeIn(cls, expression, 0); |
| expression = String.format("s = o %s o", op.getSyntax()); |
| analyzeIn(cls, expression, 1); |
| if (!op.equals(Token.ADD)) { |
| expression = String.format("o %s s", op.getSyntax()); |
| analyzeIn(cls, expression, 1); |
| } |
| expression = String.format("o %s i", op.getSyntax()); |
| analyzeIn(cls, expression, 1); |
| } |
| |
| EnumSet<Token> equalityOperators = EnumSet.of(Token.EQ, |
| Token.NE); |
| for (Token op : equalityOperators) { |
| String expression; |
| expression = String.format("untyped %s untyped", op.getSyntax()); |
| analyzeIn(cls, expression, 0); |
| expression = String.format("b = untyped %s untyped", op.getSyntax()); |
| analyzeIn(cls, expression, 0); |
| expression = String.format("s = untyped %s untyped", op.getSyntax()); |
| analyzeIn(cls, expression, 1); |
| expression = String.format("i = untyped %s untyped", op.getSyntax()); |
| analyzeIn(cls, expression, 1); |
| |
| expression = String.format("o %s o", op.getSyntax()); |
| analyzeIn(cls, expression, 0); |
| expression = String.format("b = o %s o", op.getSyntax()); |
| analyzeIn(cls, expression, 0); |
| expression = String.format("s = o %s o", op.getSyntax()); |
| analyzeIn(cls, expression, 1); |
| expression = String.format("i = o %s o", op.getSyntax()); |
| analyzeIn(cls, expression, 1); |
| |
| expression = String.format("o %s s", op.getSyntax()); |
| analyzeIn(cls, expression, 0); |
| expression = String.format("b = o %s s", op.getSyntax()); |
| analyzeIn(cls, expression, 0); |
| expression = String.format("s = o %s s", op.getSyntax()); |
| analyzeIn(cls, expression, 1); |
| expression = String.format("i = o %s s", op.getSyntax()); |
| analyzeIn(cls, expression, 1); |
| } |
| |
| EnumSet<Token> compoundAssignmentOperators = |
| EnumSet.of(Token.ASSIGN_ADD, |
| Token.ASSIGN_SUB, |
| Token.ASSIGN_MUL, |
| Token.ASSIGN_DIV, |
| Token.ASSIGN_MOD, |
| Token.ASSIGN_TRUNC); |
| |
| for (Token op : compoundAssignmentOperators) { |
| String expression; |
| expression = String.format("o %s untyped", op.getSyntax()); |
| analyzeIn(cls, expression, 0); |
| expression = String.format("o %s null", op.getSyntax()); |
| analyzeIn(cls, expression, 0); |
| expression = String.format("o %s o", op.getSyntax()); |
| analyzeIn(cls, expression, 0); |
| expression = String.format("o %s i", op.getSyntax()); |
| analyzeIn(cls, expression, 1); |
| if (!op.equals(Token.ASSIGN_ADD)) { |
| expression = String.format("s %s untyped", op.getSyntax()); |
| analyzeIn(cls, expression, 1); |
| expression = String.format("s %s null", op.getSyntax()); |
| analyzeIn(cls, expression, 1); |
| expression = String.format("s %s o", op.getSyntax()); |
| analyzeIn(cls, expression, 1); |
| } |
| } |
| |
| analyzeIn(cls, "untyped is String", 0); |
| analyzeIn(cls, "b = untyped is String", 0); |
| analyzeIn(cls, "s = untyped is String", 1); |
| analyzeIn(cls, "s is String", 0); |
| analyzeIn(cls, "b = s is String", 0); |
| analyzeIn(cls, "s = s is String", 1); |
| |
| analyzeIn(cls, "untyped is !String", 0); |
| analyzeIn(cls, "b = untyped is !String", 0); |
| analyzeIn(cls, "s = untyped is !String", 1); |
| analyzeIn(cls, "s is !String", 0); |
| analyzeIn(cls, "b = s is !String", 0); |
| analyzeIn(cls, "s = s is !String", 1); |
| |
| analyzeFail("1 == !'s';", TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| } |
| |
| public void testBitOperators() { |
| Map<String, ClassNodeElement> source = loadSource( |
| "class ClassWithBitops {", |
| " num n;", |
| " int i;", |
| " double d;", |
| " ClassWithBitops o;", |
| " num foo() { return 42; }", |
| " int operator |(int arg) { return arg; }", |
| " int operator &(int arg) { return arg; }", |
| " int operator ^(int arg) { return arg; }", |
| " int operator >>(int arg) { return arg; }", |
| " int operator <<(int arg) { return arg; }", |
| " int operator ~() { return 1; }", |
| "}"); |
| ClassElement cls = source.get("ClassWithBitops"); |
| analyzeClasses(source); |
| |
| EnumSet<Token> operators = EnumSet.of(Token.BIT_AND, |
| Token.BIT_OR, |
| Token.BIT_XOR, |
| Token.SHL, |
| Token.SAR); |
| for (Token operator : operators) { |
| analyzeIn(cls, String.format("n %s n" , operator), 0); |
| analyzeIn(cls, String.format("foo() %s i" , operator), 0); |
| analyzeIn(cls, String.format("o %s i" , operator), 0); |
| analyzeIn(cls, String.format("n = d %s i", operator), 1); |
| analyzeIn(cls, String.format("d = o %s i", operator), 1); |
| analyzeIn(cls, String.format("d = n %s i", operator), 1); |
| analyzeIn(cls, String.format("n %s o" , operator), 1); |
| } |
| |
| EnumSet<Token> assignOperators = EnumSet.of(Token.ASSIGN_BIT_AND, |
| Token.ASSIGN_BIT_OR, |
| Token.ASSIGN_BIT_XOR, |
| Token.ASSIGN_SHL, |
| Token.ASSIGN_SAR); |
| for (Token operator : assignOperators) { |
| analyzeIn(cls, String.format("n %s n" , operator), 0); |
| analyzeIn(cls, String.format("n %s i" , operator), 0); |
| analyzeIn(cls, String.format("d %s i", operator), 1); |
| analyzeIn(cls, String.format("o %s i", operator), 1); |
| analyzeIn(cls, String.format("n %s o" , operator), 1); |
| } |
| |
| analyzeIn(cls, "i = ~o", 0); |
| analyzeIn(cls, "i = ~n", 0); |
| analyzeIn(cls, "d = ~n", 1); |
| } |
| |
| public void testConditionalExpression() { |
| analyze("true ? 1 : 2;"); |
| analyze("null ? 1 : 2;"); |
| analyzeFail("0 ? 1 : 2;", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail("'' ? 1 : 2;", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail("{ int i; true ? i = 2.7 : 2; }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail("{ int i; true ? 2 : i = 2.7; }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyze("{ int i; i = true ? 2.7 : 2; }"); |
| } |
| |
| public void testConstructorForwarding() { |
| Map<String, ClassNodeElement> classes = loadSource( |
| "class MissingArgument {", |
| " MissingArgument() : this.bar();", |
| " MissingArgument.bar(int i) {}", |
| "}", |
| "class IntArgument {", |
| " IntArgument() : this.bar(1);", |
| " IntArgument.bar(int i) {}", |
| "}", |
| "class ExtraIntArgument {", |
| " ExtraIntArgument() : this.bar(1, 1);", |
| " ExtraIntArgument.bar(int i) {}", |
| "}", |
| "class StringArgument {", |
| " StringArgument() : this.bar('');", |
| " StringArgument.bar(int i) {}", |
| "}", |
| "class NullArgument {", |
| " NullArgument() : this.bar(null);", |
| " NullArgument.bar(int i) {}", |
| "}", |
| "class OptionalParameter {", |
| " OptionalParameter() : this.bar();", |
| " OptionalParameter.bar([int i = null]) {}", |
| " OptionalParameter.foo() : this.bar('');", |
| "}"); |
| analyzeClass(classes.get("MissingArgument"), 1); |
| analyzeClass(classes.get("IntArgument"), 0); |
| analyzeClass(classes.get("ExtraIntArgument"), 1); |
| analyzeClass(classes.get("StringArgument"), 1); |
| analyzeClass(classes.get("NullArgument"), 0); |
| analyzeClass(classes.get("OptionalParameter"), 1); |
| } |
| |
| public void testCyclicTypeVariable() { |
| Map<String, ClassNodeElement> classes = loadSource( |
| "abstract class A<T> { }", |
| "typedef funcType<T>(T arg);", |
| "class B<T extends T> {}", |
| "class C<T extends A<T>> {}", |
| "class D<T extends funcType<T>> {}"); |
| analyzeClasses(classes, |
| TypeErrorCode.CYCLIC_REFERENCE_TO_TYPE_VARIABLE); |
| ClassNodeElement B = classes.get("B"); |
| analyzeClass(B, 1); |
| assertEquals(1, B.getType().getArguments().size()); |
| ClassNodeElement C = classes.get("C"); |
| analyzeClass(C, 0); |
| assertEquals(1, C.getType().getArguments().size()); |
| ClassNodeElement D = classes.get("D"); |
| analyzeClass(D, 0); |
| assertEquals(1, D.getType().getArguments().size()); |
| |
| } |
| |
| public void testDoWhileStatement() { |
| analyze("do {} while (true);"); |
| analyze("do {} while (null);"); |
| analyzeFail("do {} while (0);", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail("do {} while ('');", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail("do { int i = 0.5; } while (true);", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail("do { int i = 0.5; } while (null);", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| } |
| |
| public void testFieldAccess() { |
| ClassElement element = loadFile("class_with_supertypes.dart").get("ClassWithSupertypes"); |
| assertNotNull("unable to locate ClassWithSupertypes", element); |
| analyzeIn(element, "field = 1", 0); |
| analyzeIn(element, "staticField = 1", 0); |
| analyzeIn(element, "fieldInSuperclass = 1", 0); |
| analyzeIn(element, "staticFieldInSuperclass = 1", 0); |
| |
| analyzeIn(element, "field = field", 0); |
| analyzeIn(element, "field = staticField", 0); |
| analyzeIn(element, "field = fieldInSuperclass", 0); |
| analyzeIn(element, "field = staticFieldInSuperclass", 0); |
| analyzeIn(element, "field = fieldInInterface", 0); |
| analyzeIn(element, "field = staticFieldInInterface", 0); |
| |
| analyzeIn(element, "field = 1", 0); |
| analyzeIn(element, "staticField = 1", 0); |
| analyzeIn(element, "fieldInSuperclass = 1", 0); |
| analyzeIn(element, "staticFieldInSuperclass = 1", 0); |
| |
| analyzeIn(element, "field = ''", 1); |
| analyzeIn(element, "staticField = ''", 1); |
| analyzeIn(element, "fieldInSuperclass = ''", 1); |
| analyzeIn(element, "staticFieldInSuperclass = ''", 1); |
| |
| analyzeIn(element, "field.noSuchField", 1); |
| analyzeIn(element, "staticField.noSuchField", 1); |
| analyzeIn(element, "fieldInSuperclass.noSuchField", 1); |
| analyzeIn(element, "staticFieldInSuperclass.noSuchField", 1); |
| analyzeIn(element, "fieldInInterface.noSuchField", 1); |
| analyzeIn(element, "staticFieldInInterface.noSuchField", 1); |
| |
| analyzeIn(element, "new ClassWithSupertypes()", 0); // concrete class with abstract members |
| analyzeIn(element, "field = new ClassWithSupertypes().field", 0); |
| analyzeIn(element, "field = new ClassWithSupertypes().staticField", 1); |
| analyzeIn(element, "field = new ClassWithSupertypes().fieldInSuperclass", 0); |
| analyzeIn(element, "field = new ClassWithSupertypes().staticFieldInSuperclass", 1); |
| analyzeIn(element, "field = new ClassWithSupertypes().fieldInInterface", 0); |
| analyzeIn(element, "field = new ClassWithSupertypes().staticFieldInInterface", 1); |
| |
| analyzeIn(element, "new ClassWithSupertypes().field = 1", 0); |
| analyzeIn(element, "new ClassWithSupertypes().staticField = 1", 1); |
| analyzeIn(element, "new ClassWithSupertypes().fieldInSuperclass = 1", 0); |
| analyzeIn(element, "new ClassWithSupertypes().staticFieldInSuperclass = 1", 1); |
| // Enable this test when constness is propagated: |
| // analyzeIn(element, "new ClassWithSupertypes().fieldInInterface = 1", 1); |
| analyzeIn(element, "new ClassWithSupertypes().staticFieldInInterface = 1", 1); |
| } |
| |
| public void testFieldInitializers() { |
| Map<String, ClassNodeElement> classes = loadSource( |
| "class Good {", |
| " String string;", |
| " int i;", |
| " Good() : string = '', i = 1;", |
| " Good.name() : string = null, i = null;", |
| " Good.untyped(x) : string = x, i = x;", |
| " Good.string(String s) : string = s, i = 0;", |
| "}", |
| "class Bad {", |
| " String string;", |
| " int i;", |
| " Bad() : string = 1, i = '';", |
| " Bad.string(String s) : string = s, i = s;", |
| "}"); |
| analyzeClass(classes.get("Good"), 0); |
| analyzeClass(classes.get("Bad"), 3); |
| } |
| |
| public void testForStatement() { |
| analyze("for (;true;) {}"); |
| analyze("for (;null;) {}"); |
| analyzeFail("for (;0;) {}", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail("for (;'';) {}", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| |
| // Foreach tests |
| analyze("{ List<String> strings = ['1','2','3']; for (String s in strings) {} }"); |
| analyzeFail("{ List<int> ints = [1,2,3]; for (String s in ints) {} }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail("for (String s in true) {}", TypeErrorCode.INTERFACE_HAS_NO_METHOD_NAMED); |
| } |
| |
| public void testFunctionObjectLiterals() { |
| analyze("{ bool b = () {}(); }"); |
| analyze("{ int i = () {}(); }"); |
| analyze("Function f = () {};"); |
| } |
| |
| public void testFunctionTypeAlias() { |
| Map<String, ClassNodeElement> classes = loadSource( |
| "typedef void VoidFunction();", |
| "typedef String StringFunction();", |
| "typedef String IntToStringFunction(int i);", |
| "class Foo {", |
| " VoidFunction voidFunction;", |
| " StringFunction stringFunction;", |
| " IntToStringFunction intToStringFunction;", |
| " Foo foo;", |
| " String string;", |
| " int i;", |
| "}"); |
| analyzeClasses(classes); |
| ClassElement foo = classes.get("Foo"); |
| analyzeIn(foo, "voidFunction()", 0); |
| analyzeIn(foo, "voidFunction(1)", 1); |
| analyzeIn(foo, "this.voidFunction()", 0); |
| analyzeIn(foo, "this.voidFunction(1)", 1); |
| analyzeIn(foo, "foo.voidFunction()", 0); |
| analyzeIn(foo, "foo.voidFunction(1)", 1); |
| analyzeIn(foo, "(voidFunction)()", 0); |
| analyzeIn(foo, "(voidFunction)(1)", 1); |
| analyzeIn(foo, "(this.voidFunction)()", 0); |
| analyzeIn(foo, "(this.voidFunction)(1)", 1); |
| analyzeIn(foo, "(foo.voidFunction)()", 0); |
| analyzeIn(foo, "(foo.voidFunction)(1)", 1); |
| |
| analyzeIn(foo, "string = stringFunction()", 0); |
| analyzeIn(foo, "i = stringFunction()", 1); |
| analyzeIn(foo, "string = this.stringFunction()", 0); |
| analyzeIn(foo, "i = this.stringFunction()", 1); |
| analyzeIn(foo, "string = foo.stringFunction()", 0); |
| analyzeIn(foo, "i = foo.stringFunction()", 1); |
| analyzeIn(foo, "string = (stringFunction)()", 0); |
| analyzeIn(foo, "i = (stringFunction)()", 1); |
| analyzeIn(foo, "string = (this.stringFunction)()", 0); |
| analyzeIn(foo, "i = (this.stringFunction)()", 1); |
| analyzeIn(foo, "string = (foo.stringFunction)()", 0); |
| analyzeIn(foo, "i = (foo.stringFunction)()", 1); |
| |
| analyzeIn(foo, "voidFunction = stringFunction", 0); |
| analyzeIn(foo, "stringFunction = intToStringFunction", 1); |
| analyzeIn(foo, "stringFunction = () { return ''; }", 0); |
| analyzeIn(foo, "intToStringFunction = () { return ''; }", 1); |
| } |
| |
| public void testFunctionTypes() { |
| checkFunctionStatement("String foo() {};", "() -> String"); |
| checkFunctionStatement("Object foo() {};", "() -> Object"); |
| checkFunctionStatement("String foo(int i, bool b) {};", "(int, bool) -> String"); |
| } |
| |
| public void testGetAllSupertypes() |
| throws CyclicDeclarationException { |
| Map<String, ClassNodeElement> classes = loadSource( |
| "class A extends B<String> {", |
| "}", |
| "class B<T> extends C<G<T>> implements I<int>, I1<T> {", |
| "}", |
| "class C<U> {", |
| "}", |
| "abstract class I<S> extends I2<bool> {", |
| "}", |
| "class G<V> {", |
| "}", |
| "abstract class I1<W> {", |
| "}", |
| "abstract class I2<X> {", |
| "}", |
| "class D implements I2<int> {", |
| "}", |
| "class E extends D implements I2<int> {", |
| "}"); |
| analyzeClasses(classes); |
| assertEquals("[]", object.getAllSupertypes().toString()); |
| assertEquals("[B<String>, I<int>, I1<String>, I2<bool>, C<G<String>>, Object]", |
| classes.get("A").getAllSupertypes().toString()); |
| assertEquals("[I<int>, I1<B.T>, I2<bool>, C<G<B.T>>, Object]", |
| classes.get("B").getAllSupertypes().toString()); |
| assertEquals("[Object]", classes.get("C").getAllSupertypes().toString()); |
| assertEquals("[I2<bool>, Object]", classes.get("I").getAllSupertypes().toString()); |
| assertEquals("[Object]", classes.get("G").getAllSupertypes().toString()); |
| assertEquals("[Object]", classes.get("I1").getAllSupertypes().toString()); |
| assertEquals("[Object]", classes.get("I2").getAllSupertypes().toString()); |
| assertEquals("[I2<int>, Object]", classes.get("D").getAllSupertypes().toString()); |
| assertEquals("[I2<int>, D, I2<int>, Object]", classes.get("E").getAllSupertypes().toString()); |
| } |
| |
| public void testIdentifiers() { |
| analyze("{ int i; i = 2; }"); |
| analyze("{ int j, k; j = 1; k = 3; }"); |
| analyzeFail("{ int i; i = 'string'; }", TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail("{ int j, k; k = 'string'; }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail("{ int j, k; j = 'string'; }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| } |
| |
| public void testIfStatement() { |
| analyze("if (true) {}"); |
| analyze("if (null) {}"); |
| analyzeFail("if (0) {}", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail("if ('') {}", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail("{ int i = 27; if (true) { i = 2.7; } else {} }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail("{ int i = 27; if (true) {} else { i = 2.7; } }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| } |
| |
| public void testImplementsAndOverrides() { |
| analyzeClasses(loadSource( |
| "abstract class Interface {", |
| " void foo(int x);", |
| " void bar();", |
| "}", |
| // Abstract class not reported until first instantiation. |
| "abstract class Class implements Interface {", |
| " Class() {}", |
| " String bar() { return null; }", |
| "}", |
| // Abstract class not reported until first instantiation. |
| "abstract class SubClass extends Class {", |
| " SubClass() : super() {}", |
| " Object bar() { return null; }", |
| "}", |
| "class SubSubClass extends Class {", |
| " num bar() { return null; }", // CANNOT_OVERRIDE_METHOD_NOT_SUBTYPE |
| " void foo(String x) {}", // CANNOT_OVERRIDE_METHOD_NOT_SUBTYPE |
| "}", |
| "class Usage {", |
| " m() {", |
| " }", |
| "}"), |
| TypeErrorCode.CANNOT_OVERRIDE_METHOD_NOT_SUBTYPE, |
| TypeErrorCode.CANNOT_OVERRIDE_METHOD_NOT_SUBTYPE); |
| } |
| |
| public void testImplementsAndOverrides2() { |
| analyzeClasses(loadSource( |
| "abstract class Interface {", |
| " void foo(int x);", |
| "}", |
| // Abstract class not reported until first instantiation. |
| "class Class implements Interface {", |
| " Class() {}", |
| " void foo(String x) {}", // CANNOT_OVERRIDE_METHOD_NOT_SUBTYPE |
| "}"), |
| TypeErrorCode.CANNOT_OVERRIDE_METHOD_NOT_SUBTYPE); |
| } |
| |
| public void testInitializedFields() { |
| Map<String, ClassNodeElement> classes = loadSource( |
| "class GoodField {", |
| " static final int i = 1;", |
| "}"); |
| analyzeClass(classes.get("GoodField"), 0); |
| |
| // Note, the TypeAnalyzer doesn't get a chance |
| // to get its hands on bad initializers anymore |
| // due to type checking in CompileTimeConstVisitor. |
| } |
| |
| public void testInitializedLocals() { |
| analyze("void f([int x = 1]) {}"); |
| analyzeFail("void f([int x = '']) {}", TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| |
| analyze("{ int x = 1; }"); |
| analyzeFail("{ int x = ''; }", TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| } |
| |
| public void testInitializers() { |
| analyze("int i = 1;"); |
| analyze("double d1 = .0;"); |
| analyze("double d2 = 1.0;"); |
| analyze("int x = null;"); |
| } |
| |
| public void testLabels() { |
| // Labels should be inside a function or method to be used |
| |
| // break |
| analyze("foo() { L: for (;true;) { break L; } }"); |
| analyze("foo() { int x; List<int> c; L: for (x in c) { break L; } }"); |
| analyze("foo() { List<int> c; L: for (var x in c) { break L; } }"); |
| analyze("foo() { L: while (true) { break L; } }"); |
| analyze("foo() { L: do { break L; } while (true); }"); |
| |
| analyze("foo() { L: for (;true;) { for (;true;) { break L; } } }"); |
| analyze("foo() { int x; List<int> c; L: for (x in c) { for (;true;) { break L; } } }"); |
| analyze("foo() { List<int> c; L: for (var x in c) { for (;true;) { break L; } } }"); |
| analyze("foo() { L: while (true) { for (;true;) { break L; } } }"); |
| analyze("foo() { L: do { for (;true;) { break L; } } while (true); }"); |
| |
| // continue |
| analyze("foo() { L: for (;true;) { continue L; } }"); |
| analyze("foo() { int x; List<int> c; L: for (x in c) { continue L; } }"); |
| analyze("foo() { List<int> c; L: for (var x in c) { continue L; } }"); |
| analyze("foo() { L: do { continue L; } while (true); }"); |
| |
| analyze("foo() { L: for (;true;) { for (;true;) { continue L; } } }"); |
| analyze( |
| "foo() { int x; List<int> c; L: for (x in c) { for (;true;) { continue L; } } }"); |
| analyze("foo() { List<int> c; L: for (var x in c) { for (;true;) { continue L; } } }"); |
| analyze("foo() { L: while (true) { for (;true;) { continue L; } } }"); |
| analyze("foo() { L: do { for (;true;) { continue L; } } while (true); }"); |
| |
| // corner cases |
| analyze("foo() { L: break L; }"); |
| |
| // TODO(zundel): Not type errors, but warnings. |
| analyze("foo() { L: for (;true;) { } }"); |
| analyze("foo() { while (true) { L: var a; } }"); |
| } |
| |
| public void testLiterals() { |
| checkSimpleType(intElement.getType(), "1"); |
| checkSimpleType(doubleElement.getType(), ".0"); |
| checkSimpleType(doubleElement.getType(), "1.0"); |
| checkSimpleType(bool.getType(), "true"); |
| checkSimpleType(bool.getType(), "false"); |
| checkSimpleType(string.getType(), "'fisk'"); |
| checkSimpleType(string.getType(), "'f${null}sk'"); |
| } |
| |
| public void testMapLiteral() { |
| analyze("{ var x = {\"key\": 42}; }"); |
| analyze("{ var x = {'key': 42}; }"); |
| analyze("{ var x = <num>{'key': 42}; }"); |
| analyze("{ var x = <int>{'key': 42}; }"); |
| analyze("{ var x = <num>{'key': 0.42}; }"); |
| analyze("{ var x = <num>{'key': 42}; }"); |
| analyzeFail("{ var x = <int>{'key': 0.42}; }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail("{ int i; var x = {'key': i = 0.42}; }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyze("{ var x = const {\"key\": 42}; }"); |
| analyze("{ var x = const {'key': 42}; }"); |
| analyze("{ var x = const <num>{'key': 42}; }"); |
| analyze("{ var x = const <int>{'key': 42}; }"); |
| analyze("{ var x = const <num>{'key': 0.42}; }"); |
| analyze("{ var x = const <num>{'key': 42}; }"); |
| analyzeFail("{ var x = const <int>{'key': 0.42}; }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail("{ int i; var x = const {'key': i = 0.42}; }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail("{Map<num, num> x = const <num>{}; }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| } |
| |
| public void testMethodInvocationArgumentCount() { |
| loadFile("class_with_methods.dart"); |
| final String header = "{ ClassWithMethods c; "; |
| |
| analyzeFail(header + "c.untypedNoArgumentMethod(1); }", |
| TypeErrorCode.EXTRA_ARGUMENT); |
| analyzeFail(header + "c.untypedOneArgumentMethod(); }", |
| TypeErrorCode.MISSING_ARGUMENT); |
| analyzeFail(header + "c.untypedOneArgumentMethod(1, 1); }", |
| TypeErrorCode.EXTRA_ARGUMENT); |
| analyzeFail(header + "c.untypedTwoArgumentMethod(); }", |
| TypeErrorCode.MISSING_ARGUMENT); |
| analyzeFail(header + "c.untypedTwoArgumentMethod(1, 2, 3); }", |
| TypeErrorCode.EXTRA_ARGUMENT); |
| analyzeFail(header + "c.intNoArgumentMethod(1); }", |
| TypeErrorCode.EXTRA_ARGUMENT); |
| analyzeFail(header + "c.intOneArgumentMethod(); }", |
| TypeErrorCode.MISSING_ARGUMENT); |
| analyzeFail(header + "c.intOneArgumentMethod(1, 1); }", |
| TypeErrorCode.EXTRA_ARGUMENT); |
| analyzeFail(header + "c.intTwoArgumentMethod(); }", |
| TypeErrorCode.MISSING_ARGUMENT); |
| analyzeFail(header + "c.intTwoArgumentMethod(1, 2, 3); }", |
| TypeErrorCode.EXTRA_ARGUMENT); |
| analyze(header + "c.untypedField(); }"); |
| } |
| |
| public void testMethodInvocations() { |
| loadFile("class_with_methods.dart"); |
| final String header = "{ ClassWithMethods c; int i, j; "; |
| |
| analyze(header + "int k = c.untypedNoArgumentMethod(); }"); |
| analyze(header + "ClassWithMethods x = c.untypedNoArgumentMethod(); }"); |
| |
| analyze(header + "int k = c.untypedOneArgumentMethod(c); }"); |
| analyze(header + "ClassWithMethods x = c.untypedOneArgumentMethod(1); }"); |
| analyze(header + "int k = c.untypedOneArgumentMethod('string'); }"); |
| analyze(header + "int k = c.untypedOneArgumentMethod(i); }"); |
| |
| analyze(header + "int k = c.untypedTwoArgumentMethod(1, 'string'); }"); |
| analyze(header + "int k = c.untypedTwoArgumentMethod(i, j); }"); |
| analyze(header + "ClassWithMethods x = c.untypedTwoArgumentMethod(i, c); }"); |
| |
| analyze(header + "int k = c.intNoArgumentMethod(); }"); |
| analyzeFail(header + "ClassWithMethods x = c.intNoArgumentMethod(); }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| |
| analyzeFail(header + "int k = c.intOneArgumentMethod(c); }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail(header + "ClassWithMethods x = c.intOneArgumentMethod(1); }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail(header + "int k = c.intOneArgumentMethod('string'); }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyze(header + "int k = c.intOneArgumentMethod(i); }"); |
| |
| analyzeFail(header + "int k = c.intTwoArgumentMethod(1, 'string'); }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyze(header + "int k = c.intTwoArgumentMethod(i, j); }"); |
| analyzeFail(header + "ClassWithMethods x = c.intTwoArgumentMethod(i, j); }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| } |
| |
| public void testNamedFunctionTypeAlias() { |
| loadFile("named_function_type_alias.dart"); |
| analyze("VoidFunction f = () {};"); |
| } |
| |
| public void testOddStuff() { |
| Map<String, ClassNodeElement> classes = analyzeClasses(loadSource( |
| "class Class {", |
| " Class() {}", |
| " var field;", |
| " void m() {}", |
| " static void f() {}", |
| " static g(int i) {}", |
| "}")); |
| ClassElement cls = classes.get("Class"); |
| analyzeIn(cls, "m().foo()", 1); |
| analyzeIn(cls, "m().x", 1); |
| analyzeIn(cls, "m()", 0); |
| analyzeIn(cls, "(m)().foo()", 1); |
| analyzeIn(cls, "(m)().x", 1); |
| analyzeIn(cls, "(m)()", 0); |
| analyzeIn(cls, "field = m()", 1); |
| analyzeIn(cls, "field = Class.f()", 1); |
| analyzeIn(cls, "field = (Class.f)()", 1); |
| analyzeIn(cls, "Class.f()", 0); |
| analyzeIn(cls, "(Class.f)()", 0); |
| analyzeIn(cls, "field = Class.g('x')", 1); |
| analyzeIn(cls, "field = (Class.g)('x')", 1); |
| analyzeIn(cls, "field = Class.g(0)", 0); |
| analyzeIn(cls, "field = (Class.g)(0)", 0); |
| analyzeFail("fisk: while (true) fisk++;", TypeErrorCode.CANNOT_BE_RESOLVED); |
| analyzeFail("new Class().m().x;", TypeErrorCode.VOID); |
| analyzeFail("(new Class().m)().x;", TypeErrorCode.VOID); |
| } |
| |
| public void testParameterAccess() { |
| analyze("{ f(int x) { x = 1; } }"); |
| analyzeFail("{ f(String x) { x = 1; } }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyze("{ f(int x, int y) { x = y; } }"); |
| analyzeFail("{ f(String x, int y) { x = y; } }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyze("{ f(x, int y) { x = y; } }"); |
| analyze("{ f(x, int y) { x = y; } }"); |
| analyzeFail("{ f(String x) { x = 1;} }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| } |
| |
| public void testParameterInitializers() { |
| Map<String, ClassNodeElement> classes = loadSource( |
| "class C1 { int i; C1(this.i) {} }", |
| "class C2 { String s; C2(int this.s) {} }", |
| "class C3 { int i; C3(double this.i) {} }", |
| "class C4 { int i; C4(num this.i) {} }"); |
| analyzeClass(classes.get("C1"), 0); |
| analyzeClass(classes.get("C2"), 1); |
| analyzeClass(classes.get("C3"), 1); |
| analyzeClass(classes.get("C4"), 0); |
| } |
| |
| public void testPropertyAccess() { |
| ClassElement cls = loadClass("classes_with_properties.dart", "ClassWithProperties"); |
| analyzeIn(cls, "null", 0); |
| analyzeIn(cls, "noSuchField", 1); |
| analyzeIn(cls, "noSuchMethod()", 1); |
| analyzeIn(cls, "x.noSuchField", 0); |
| analyzeIn(cls, "x.noSuchMethod()", 0); |
| analyzeIn(cls, "x.x.noSuchField", 0); |
| analyzeIn(cls, "x.x.noSuchMethod()", 0); |
| analyzeIn(cls, "x.a.noSuchField", 0); |
| analyzeIn(cls, "x.a.noSuchMethod()", 0); |
| String[] typedFields = { "a", "b", "c"}; |
| for (String field : typedFields) { |
| analyzeIn(cls, field + ".noSuchField", 1); |
| analyzeIn(cls, field + ".noSuchMethod()", 1); |
| analyzeIn(cls, field + ".a", 0); |
| analyzeIn(cls, field + ".a()", 1); |
| } |
| } |
| |
| public void testReturn() { |
| analyzeFail(returnWithType("int", "'string'"), |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyze(returnWithType("", "'string'")); |
| analyze(returnWithType("Object", "'string'")); |
| analyze(returnWithType("String", "'string'")); |
| analyze(returnWithType("String", null)); |
| analyze(returnWithType("int", null)); |
| analyze(returnWithType("void", "")); |
| analyzeFail(returnWithType("void", 1), TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyze(returnWithType("void", null)); |
| analyzeFail(returnWithType("String", ""), TypeErrorCode.MISSING_RETURN_VALUE); |
| analyze("String foo() {};"); // Should probably fail, http://b/4484060. |
| } |
| |
| public void testSuper() { |
| ClassElement sub = loadClass("covariant_class.dart", "Sub"); |
| checkAssignIn(sub, "B", "field", 0); |
| checkAssignIn(sub, "C", "field", 1); |
| checkAssignIn(sub, "D", "field", 1); |
| |
| checkAssignIn(sub, "B", "super.field", 0); |
| checkAssignIn(sub, "C", "super.field", 0); |
| checkAssignIn(sub, "D", "super.field", 1); |
| |
| checkAssignIn(sub, "B", "accessor", 0); |
| checkAssignIn(sub, "C", "accessor", 1); |
| checkAssignIn(sub, "D", "accessor", 1); |
| |
| checkAssignIn(sub, "B", "super.accessor", 0); |
| checkAssignIn(sub, "C", "super.accessor", 0); |
| checkAssignIn(sub, "D", "super.accessor", 1); |
| |
| analyzeIn(sub, "accessor = b", 0); |
| analyzeIn(sub, "accessor = c", 1); |
| analyzeIn(sub, "accessor = d", 1); |
| |
| analyzeIn(sub, "super.accessor = b", 0); |
| analyzeIn(sub, "super.accessor = c", 0); |
| analyzeIn(sub, "super.accessor = d", 1); |
| |
| checkAssignIn(sub, "B", "method()", 0); |
| checkAssignIn(sub, "C", "method()", 1); |
| checkAssignIn(sub, "D", "method()", 1); |
| |
| checkAssignIn(sub, "B", "super.untypedMethod()", 0); |
| checkAssignIn(sub, "C", "super.untypedMethod()", 0); |
| checkAssignIn(sub, "D", "super.untypedMethod()", 0); |
| |
| checkAssignIn(sub, "B", "super.untypedField", 0); |
| checkAssignIn(sub, "C", "super.untypedField", 0); |
| checkAssignIn(sub, "D", "super.untypedField", 0); |
| |
| checkAssignIn(sub, "B", "super.untypedAccessor", 0); |
| checkAssignIn(sub, "C", "super.untypedAccessor", 0); |
| checkAssignIn(sub, "D", "super.untypedAccessor", 0); |
| |
| analyzeIn(sub, "super.untypedAccessor = b", 0); |
| analyzeIn(sub, "super.untypedAccessor = c", 0); |
| analyzeIn(sub, "super.untypedAccessor = d", 0); |
| |
| checkAssignIn(sub, "B", "super.untypedMethod()", 0); |
| checkAssignIn(sub, "C", "super.untypedMethod()", 0); |
| checkAssignIn(sub, "D", "super.untypedMethod()", 0); |
| } |
| |
| public void testSuperConstructorInvocation() { |
| Map<String, ClassNodeElement> classes = loadSource( |
| "class Super {", |
| " Super(int x) {}", |
| " Super.foo() {}", |
| " Super.bar([int i = null]) {}", |
| "}", |
| "class BadSub extends Super {", |
| " BadSub() : super('x') {}", |
| " BadSub.foo() : super.foo('x') {}", |
| " BadSub.bar() : super() {}", |
| " BadSub.baz() : super.foo(null) {}", |
| " BadSub.fisk() : super.bar('') {}", |
| " BadSub.hest() : super.bar(1, 2) {}", |
| "}", |
| "class NullSub extends Super {", |
| " NullSub() : super(null) {}", |
| " NullSub.foo() : super.bar(null) {}", |
| " NullSub.bar() : super.bar() {}", |
| "}", |
| "class IntSub extends Super {", |
| " IntSub() : super(1) {}", |
| " IntSub.foo() : super.bar(1) {}", |
| "}", |
| // The following works fine, but was claimed to be a bug: |
| "class A {", |
| " int value;", |
| " A([this.value = 3]) {}", |
| "}", |
| "class B extends A {", |
| " B() : super() {}", |
| "}"); |
| analyzeClass(classes.get("Super"), 0); |
| analyzeClass(classes.get("BadSub"), 6); |
| analyzeClass(classes.get("NullSub"), 0); |
| analyzeClass(classes.get("IntSub"), 0); |
| analyzeClass(classes.get("A"), 0); |
| analyzeClass(classes.get("B"), 0); |
| } |
| |
| public void testSwitch() { |
| analyze("{ int i = 27; switch(i) { case i: break; } }"); |
| analyzeFail( |
| "{ switch(true) { case 1: break; case 'foo': break; }}", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail( |
| "{ int i = 27; switch(true) { case false: i = 2.7; }}", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| } |
| |
| public void testThis() { |
| Map<String, ClassNodeElement> classes = loadFile("class_with_supertypes.dart"); |
| ClassElement superclass = classes.get("Superclass"); |
| assertNotNull("unable to locate Superclass", superclass); |
| ClassElement subclass = classes.get("ClassWithSupertypes"); |
| assertNotNull("unable to locate ClassWithSupertypes", subclass); |
| analyzeIn(superclass, "() { String x = this; }", 1); |
| analyzeIn(superclass, "() { var x = this; }", 0); |
| analyzeIn(superclass, "() { ClassWithSupertypes x = this; }", 0); |
| analyzeIn(superclass, "() { Superclass x = this; }", 0); |
| analyzeIn(superclass, "() { Interface x = this; }", 1); |
| analyzeIn(subclass, "() { Interface x = this; }", 0); |
| } |
| |
| public void testTryCatchFinally() { |
| analyze("try { } catch (_) { } finally { }"); |
| analyzeFail("try { int i = 4.2; } catch (_) { } finally { }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail("try { } catch (_) { int i = 4.2; } finally { }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail("try { } catch (_) { } finally { int i = 4.2; }", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| } |
| |
| public void testTypeVariables() { |
| ClassElement cls = loadFile("class_with_type_parameter.dart").get("ClassWithTypeParameter"); |
| assertNotNull("unable to locate ClassWithTypeParameter", cls); |
| analyzeIn(cls, "aField = tField", 0); |
| analyzeIn(cls, "bField = tField", 0); |
| analyzeIn(cls, "tField = aField", 0); |
| analyzeIn(cls, "tField = bField", 0); |
| analyzeIn(cls, "tField = null", 0); |
| analyzeIn(cls, "tField = 1", 1); |
| analyzeIn(cls, "tField = ''", 1); |
| analyzeIn(cls, "tField = true", 1); |
| |
| analyzeIn(cls, "() { A a = null; T t = a; }()", 0); |
| analyzeIn(cls, "() { B b = null; T t = b; }()", 0); |
| analyzeIn(cls, "() { T t = null; A a = t; }()", 0); |
| analyzeIn(cls, "() { T t = null; B b = t; }()", 0); |
| analyzeIn(cls, "() { T t = 1; }()", 1); |
| analyzeIn(cls, "() { T t = ''; }()", 1); |
| analyzeIn(cls, "() { T t = true; }()", 1); |
| } |
| |
| public void testUnaryOperators() { |
| Map<String, ClassNodeElement> source = loadSource( |
| "class Foo {", |
| " Foo foo;", |
| " bool b;", |
| " int i;", |
| " Foo operator +(int operand) { return this; }", |
| " Foo operator -(int operand) { return this; }", |
| "}", |
| "class Bar {", |
| " Bar bar;", |
| " Bar operator +(Bar operand) { return this; }", |
| " Bar operator -(Bar operand) { return this; }", |
| "}", |
| "class Baz<T extends Foo> {", |
| " T baz;", |
| "}", |
| "class Qux<T> { ", |
| " T qux; ", |
| " void x() { }", |
| " y() { }", |
| "}", |
| "class X {", |
| " X x;", |
| " Z operator +(int operand) { return null; }", |
| " Z operator -(int operand) { return null; }", |
| "}", |
| "class Y extends X { Y y; }", |
| "class Z extends X { Z z; }" |
| ); |
| analyzeClasses(source); |
| ClassElement foo = source.get("Foo"); |
| ClassElement bar = source.get("Bar"); |
| ClassElement baz = source.get("Baz"); |
| ClassElement qux = source.get("Qux"); |
| ClassElement y = source.get("Y"); |
| ClassElement z = source.get("Z"); |
| for (Token op : EnumSet.of(Token.DEC, Token.INC)) { |
| analyzeIn(foo, String.format("%sfoo", op), 0); |
| analyzeIn(foo, String.format("i = %sfoo", op), 1); |
| analyzeIn(bar, String.format("%sbar", op), 1); |
| analyzeIn(baz, String.format("%sbaz", op), 0); |
| analyzeIn(qux, String.format("%squx", op), 1); |
| } |
| analyzeIn(z, "z = x++", 0); |
| analyzeIn(z, "z = ++x", 0); |
| analyzeIn(z, "z = x--", 0); |
| analyzeIn(z, "z = --x", 0); |
| analyzeIn(y, "y = x++", 0); |
| analyzeIn(y, "y = ++x", 1); |
| analyzeIn(y, "y = x--", 0); |
| analyzeIn(y, "y = --x", 1); |
| |
| analyzeIn(foo, "b = !b", 0); |
| analyzeIn(foo, "foo = !foo", 2); |
| analyzeIn(foo, "b = !i", 1); |
| analyzeIn(foo, "foo = !b", 1); |
| analyzeIn(qux, "-x()", 1); |
| analyzeIn(qux, "-y()", 0); |
| } |
| |
| public void testUnqualified() { |
| ClassElement element = loadClass("class_with_methods.dart", "ClassWithMethods"); |
| checkAssignIn(element, "var", "intNoArgumentMethod()", 0); |
| checkAssignIn(element, "var", "intOneArgumentMethod(1)", 0); |
| checkAssignIn(element, "var", "intOneArgumentMethod('')", 1); |
| checkAssignIn(element, "int", "intNoArgumentMethod()", 0); |
| checkAssignIn(element, "int", "intOneArgumentMethod(1)", 0); |
| checkAssignIn(element, "int", "intOneArgumentMethod('')", 1); |
| checkAssignIn(element, "String", "intNoArgumentMethod()", 1); |
| checkAssignIn(element, "String", "intOneArgumentMethod(1)", 1); |
| checkAssignIn(element, "String", "intOneArgumentMethod('')", 2); |
| |
| checkAssignIn(element, "var", "functionField()", 0); |
| checkAssignIn(element, "int", "functionField()", 0); |
| checkAssignIn(element, "String", "functionField()", 0); |
| |
| checkAssignIn(element, "var", "functionField(1)", 0); |
| checkAssignIn(element, "int", "functionField('x')", 0); |
| checkAssignIn(element, "String", "functionField(2.2)", 0); |
| |
| |
| checkAssignIn(element, "var", "untypedField()", 0); |
| checkAssignIn(element, "int", "untypedField()", 0); |
| checkAssignIn(element, "String", "untypedField()", 0); |
| |
| checkAssignIn(element, "var", "untypedField(1)", 0); |
| checkAssignIn(element, "int", "untypedField('x')", 0); |
| checkAssignIn(element, "String", "untypedField(2.2)", 0); |
| |
| checkAssignIn(element, "var", "intField()", 1); |
| checkAssignIn(element, "int", "intField()", 1); |
| checkAssignIn(element, "String", "intField()", 1); |
| |
| checkAssignIn(element, "var", "intField(1)", 1); |
| checkAssignIn(element, "int", "intField('x')", 1); |
| checkAssignIn(element, "String", "intField(2.2)", 1); |
| |
| analyzeIn(element, "(x) { x(); }", 0); |
| analyzeIn(element, "(int x) { x(); }", 1); |
| analyzeIn(element, "(int x()) { int i = x(); }", 0); |
| analyzeIn(element, "(int x(String s)) { int i = x(1); }", 1); |
| analyzeIn(element, "(int x(String s)) { int i = x(''); }", 0); |
| } |
| |
| public void testUnqualifiedGeneric() { |
| ClassElement element = loadClass("generic_class_with_supertypes.dart", |
| "GenericClassWithSupertypes"); |
| |
| checkAssignIn(element, "var", "localField", 0); |
| checkAssignIn(element, "T1", "localField", 0); |
| checkAssignIn(element, "T2", "localField", 1); |
| |
| checkAssignIn(element, "var", "superField", 0); |
| checkAssignIn(element, "T1", "superField", 1); |
| checkAssignIn(element, "T2", "superField", 0); |
| |
| checkAssignIn(element, "var", "interfaceField", 0); |
| checkAssignIn(element, "T1", "interfaceField", 0); |
| checkAssignIn(element, "T2", "interfaceField", 1); |
| |
| checkAssignIn(element, "var", "localMethod(t2)", 0); |
| checkAssignIn(element, "T1", "localMethod(t2)", 0); |
| checkAssignIn(element, "T2", "localMethod(t2)", 1); |
| |
| checkAssignIn(element, "var", "superMethod(t1)", 0); |
| checkAssignIn(element, "T1", "superMethod(t1)", 1); |
| checkAssignIn(element, "T2", "superMethod(t1)", 0); |
| |
| checkAssignIn(element, "var", "interfaceMethod(t1)", 0); |
| checkAssignIn(element, "T1", "interfaceMethod(t1)", 0); |
| checkAssignIn(element, "T2", "interfaceMethod(t1)", 1); |
| } |
| |
| public void testUnresolved() { |
| ClassElement element = loadClass("class_with_supertypes.dart", "ClassWithSupertypes"); |
| analyzeIn(element, "this.field", 0); |
| analyzeIn(element, "null", 0); |
| analyzeIn(element, "noSuchField", 1); |
| analyzeIn(element, "noSuchMethod()", 1); |
| analyzeIn(element, "method()", 0); |
| analyzeIn(element, "field", 0); |
| analyzeIn(element, "this.noSuchField", 1); |
| analyzeIn(element, "this.noSuchMethod()", 1); |
| analyzeIn(element, "this.method()", 0); |
| analyzeIn(element, "staticMethod()", 0); |
| analyzeIn(element, "staticField", 0); |
| analyzeIn(element, "this.staticMethod()", 1); |
| analyzeIn(element, "this.staticField", 1); |
| analyzeIn(element, "ClassWithSupertypes.staticMethod()", 0); |
| analyzeIn(element, "ClassWithSupertypes.staticField", 0); |
| analyzeIn(element, "methodInSuperclass()", 0); |
| analyzeIn(element, "fieldInSuperclass", 0); |
| analyzeIn(element, "staticMethodInSuperclass()", 0); |
| analyzeIn(element, "staticFieldInSuperclass", 0); |
| analyzeIn(element, "this.methodInSuperclass()", 0); |
| analyzeIn(element, "this.fieldInSuperclass", 0); |
| analyzeIn(element, "this.staticMethodInSuperclass()", 1); |
| analyzeIn(element, "this.staticFieldInSuperclass", 1); |
| analyzeIn(element, "Superclass.staticMethodInSuperclass()", 0); |
| analyzeIn(element, "Superclass.staticFieldInSuperclass", 0); |
| analyzeIn(element, "methodInInterface()", 0); |
| analyzeIn(element, "fieldInInterface", 0); |
| analyzeIn(element, "this.methodInInterface()", 0); |
| analyzeIn(element, "this.fieldInInterface", 0); |
| analyzeIn(element, "staticFieldInInterface", 0); |
| analyzeIn(element, "Interface.staticFieldInInterface", 0); |
| analyzeIn(element, "this.staticFieldInInterface", 1); |
| } |
| |
| public void testUnresolvedIdentifier() { |
| setExpectedTypeErrorCount(3); |
| checkType(typeProvider.getDynamicType(), "y"); |
| checkExpectedTypeErrorCount(); |
| } |
| |
| public void testVoid() { |
| // Return a value from a void function. |
| analyze("void f() { return; }"); |
| analyze("void f() { return null; }"); |
| analyze("void f() { return f(); }"); |
| analyzeFail("void f() { return 1; }", TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyze("void f() { var x; return x; }"); |
| |
| // No-arg return from non-void function. |
| analyzeFail("int f() { return; }", TypeErrorCode.MISSING_RETURN_VALUE); |
| analyze("f() { return; }"); |
| |
| // Calling a method on a void expression, property access. |
| analyzeFail("void f() { f().m(); }", TypeErrorCode.VOID); |
| analyzeFail("void f() { f().x; }", TypeErrorCode.VOID); |
| |
| // Passing a void argument to a method. |
| analyzeFail("{ void f() {} m(x) {} m(f()); }", TypeErrorCode.VOID); |
| |
| // Assigning a void expression to a variable. |
| analyzeFail("{ void f() {} int x = f(); }", TypeErrorCode.VOID); |
| analyzeFail("{ void f() {} int x; x = f(); }", TypeErrorCode.VOID); |
| analyzeFail("{ void f() {} int x; x += f(); }", TypeErrorCode.VOID); |
| |
| // Misc. |
| analyzeFail("{ void f() {} 1 + f(); }", TypeErrorCode.VOID); |
| analyzeFail("{ void f() {} f() + 1; }", TypeErrorCode.VOID); |
| analyzeFail("{ void f() {} var x; x && f(); }", TypeErrorCode.VOID); |
| analyzeFail("{ void f() {} !f(); }", TypeErrorCode.VOID); |
| analyzeFail("{ void f() {} -f(); }", TypeErrorCode.VOID); |
| // We seem to throw away prefix-plus in the parser: |
| // analyzeFail("{ void f() {} +f(); }", TypeErrorCode.VOID); |
| analyzeFail("{ void f() {} var x; x == f(); }", TypeErrorCode.VOID); |
| analyzeFail("{ void f() {} while (f()); }", TypeErrorCode.VOID); |
| analyzeFail("{ void f() {}; ({ 'x': f() }); }", TypeErrorCode.VOID); |
| } |
| |
| public void testWhileStatement() { |
| analyze("while (true) {}"); |
| analyze("while (null) {}"); |
| analyzeFail("while (0) {}", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| analyzeFail("while ('') {}", |
| TypeErrorCode.TYPE_NOT_ASSIGNMENT_COMPATIBLE); |
| } |
| } |
