Added additional Xtend validator tests

org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/AbstractXtendTestCase.java

@@ -56,10 +56,19 @@ public abstract class AbstractXtendTestCase extends Assert {
 
 	@Rule
 	@Inject public TemporaryFolder temporaryFolder;
-	
+
 	@Inject
 	private Provider<XtextResourceSet> resourceSetProvider;
 
+	/**
+	 * To build a function or constructor for tests
+	 */
+	protected static final String TEMPLATE_CLASS = "class Foo { %s }";
+	/**
+	 * Use it to add it to the index position of a source element of a function or constructor
+	 */
+	protected static final int TEMPLATE_CLASS_PREFIX_SIZE = TEMPLATE_CLASS.indexOf("%s");
+
 	protected XtendClass clazz(String string) throws Exception {
 		return (XtendClass) file(string).getXtendTypes().get(0);
 	}
@@ -160,7 +169,7 @@ protected XtendEnum enumeration(String string) throws Exception {
 	}
 
 	protected XtendFunction function(String string) throws Exception {
-		XtendClass clazz = clazz("class Foo { " + string + "}");
+		XtendClass clazz = clazz(String.format(TEMPLATE_CLASS, string));
 		return (XtendFunction) clazz.getMembers().get(0);
 	}
 

org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/java8/validation/Java8ValidationTest.xtend

@@ -69,57 +69,65 @@ class Java8ValidationTest extends AbstractXtendTestCase {
 
 	@Test
 	def void testConflictingDefaultMethods01() {
-		file('''
+		val source = '''
 			interface A {
 				def void foo() { }
 			}
 			interface B {
 				def void foo() { }
 			}
 			class C implements A, B { }
-		''').assertError(XTEND_CLASS, CONFLICTING_DEFAULT_METHODS,
+		'''
+		file(source).assertError(XTEND_CLASS, CONFLICTING_DEFAULT_METHODS,
+			source.indexOf("C"), 1,
 			"The type C inherits multiple implementations of the method foo() from A and B.")
 	}
 
 	@Test
 	def void testConflictingDefaultMethods02() {
-		file('''
+		val source = '''
 			interface A {
 				def void foo() { }
 			}
 			interface B {
 				def void foo() { }
 			}
 			interface C extends A, B { }
-		''').assertError(XTEND_INTERFACE, CONFLICTING_DEFAULT_METHODS,
+		'''
+		file(source).assertError(XTEND_INTERFACE, CONFLICTING_DEFAULT_METHODS,
+			source.indexOf("C"), 1,
 			"The type C inherits multiple implementations of the method foo() from A and B.")
 	}
 
 	@Test
 	def void testConflictingDefaultMethods03() {
-		file('''
+		val source = '''
 			interface A {
 				def void foo() { }
 			}
 			interface B {
 				def void foo()
 			}
 			class C implements A, B { }
-		''').assertError(XTEND_CLASS, CONFLICTING_DEFAULT_METHODS,
+		'''
+		file(source).assertError(XTEND_CLASS, CONFLICTING_DEFAULT_METHODS,
+			source.indexOf("C"), 1,
 			"The non-abstract method foo() inherited from A conflicts with the method foo() inherited from B.")
 	}
 
 	@Test
 	def void testConflictingDefaultMethods04() {
-		file('''
+		val source = '''
 			interface A {
 				def void foo() { }
 			}
 			interface B {
 				def void foo()
 			}
 			interface C extends A, B { }
-		''').assertError(XTEND_INTERFACE, CONFLICTING_DEFAULT_METHODS,
+		'''
+		file(source).assertError(XTEND_INTERFACE, CONFLICTING_DEFAULT_METHODS,
+			source.indexOf("C"), 1,
 			"The non-abstract method foo() inherited from A conflicts with the method foo() inherited from B.")
 	}
 

org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java

@@ -34,8 +34,14 @@ public class OverrideValidationTest extends AbstractXtendTestCase {
 	private ValidationTestHelper helper;
 
 	@Test public void testDuplicateMethod_0() throws Exception {
-		XtendClass xtendClass = clazz("class Foo { def bar(int x) {true} def bar(int x) {false} }");
-		helper.assertError(xtendClass.getMembers().get(0), XTEND_FUNCTION, DUPLICATE_METHOD, "duplicate");
+		var source = "class Foo { def bar(int x) {true} def bar(int x) {false} }";
+		XtendClass xtendClass = clazz(source);
+		helper.assertError(xtendClass.getMembers().get(0), XTEND_FUNCTION, DUPLICATE_METHOD,
+				source.indexOf("bar"), "bar".length(),
+				"duplicate", "method");
+		helper.assertError(xtendClass.getMembers().get(0), XTEND_FUNCTION, DUPLICATE_METHOD,
+				source.lastIndexOf("bar"), "bar".length(),
+				"duplicate", "method");
 	}
 
 	@Test public void testDuplicateMethod_1() throws Exception {
@@ -50,9 +56,11 @@ public class OverrideValidationTest extends AbstractXtendTestCase {
 
 	@Test public void testDuplicateMethod_3() throws Exception {
 		XtendClass xtendClass = clazz("class Foo { def bar(java.util.List<String> x) {true} def bar(java.util.List<Integer> x) {false} }");
-		helper.assertError(xtendClass.getMembers().get(0), XTEND_FUNCTION, DUPLICATE_METHOD, "erasure", "List)",
+		helper.assertError(xtendClass.getMembers().get(0), XTEND_FUNCTION, DUPLICATE_METHOD,
+				"erasure", "List)", "method",
 				"List<String");
-		helper.assertError(xtendClass.getMembers().get(1), XTEND_FUNCTION, DUPLICATE_METHOD, "erasure", "List)",
+		helper.assertError(xtendClass.getMembers().get(1), XTEND_FUNCTION, DUPLICATE_METHOD,
+				"erasure", "List)", "method",
 				"List<Integer");
 	}
 
@@ -148,10 +156,14 @@ public class OverrideValidationTest extends AbstractXtendTestCase {
 	}
 
 	@Test public void testOverrideGenericMethod_10() throws Exception {
-		XtendClass xtendClass = clazz(" abstract class Foo<T> extends test.GenericSuperTypeClass<T> {  " +
+		var source = " abstract class Foo<T> extends test.GenericSuperTypeClass<T> {  " +
 									"override <T extends String> foo1() {}"+
-									"}");
-		helper.assertError(xtendClass, XTEND_FUNCTION, DUPLICATE_METHOD);
+									"}";
+		XtendClass xtendClass = clazz(source);
+		helper.assertError(xtendClass, XTEND_FUNCTION, DUPLICATE_METHOD,
+				source.indexOf("foo1"), "foo1".length(),
+				"Name clash", "same erasure", "GenericSuperTypeClass",
+				"does not override it");
 	}
 
 	@Test public void testOverrideGenericMethod_11() throws Exception {
@@ -189,6 +201,28 @@ public class OverrideValidationTest extends AbstractXtendTestCase {
 		helper.assertNoErrors(xtendClass);
 	}
 
+	@Test public void testStaticMethodHidesInstanceMethod() throws Exception {
+		var source = " abstract class Foo<T> extends test.GenericSuperTypeClass<T> {  " +
+						"static def foo1() {}"+
+						"}";
+		XtendClass xtendClass = clazz(source);
+		helper.assertError(xtendClass, XTEND_FUNCTION, DUPLICATE_METHOD,
+				source.indexOf("foo1"), "foo1".length(),
+				"The static method", "GenericSuperTypeClass",
+				"cannot hide the instance method");
+	}
+
+	@Test public void testOverrideStaticMethod() throws Exception {
+		var source = " abstract class Foo extends testdata.Methods {  " +
+						"override staticMethod() {}"+
+						"}";
+		XtendClass xtendClass = clazz(source);
+		helper.assertError(xtendClass, XTEND_FUNCTION, DUPLICATE_METHOD,
+				source.indexOf("staticMethod"), "staticMethod".length(),
+				"The instance method", "Methods",
+				"cannot override the static method");
+	}
+
 	@Test public void testOverrideReturnType() throws Exception {
 		XtendClass xtendClass = clazz("abstract class Foo<T> extends test.GenericSuperTypeClass<T> {  " +
 									"override <T> T getSomething(T t){} "+
@@ -355,20 +389,29 @@ public class OverrideValidationTest extends AbstractXtendTestCase {
 	}
 
 	@Test public void testClassMustBeAbstract_01() throws Exception {
-		XtendClass xtendClass = clazz("class Foo<S> implements Comparable<S> { }");
-		helper.assertError(xtendClass, XTEND_CLASS, CLASS_MUST_BE_ABSTRACT, "abstract", "not", "implement",
+		var source = "class Foo<S> implements Comparable<S> { }";
+		XtendClass xtendClass = clazz(source);
+		helper.assertError(xtendClass, XTEND_CLASS, CLASS_MUST_BE_ABSTRACT,
+				source.indexOf("Foo"), "Foo".length(),
+				"abstract", "not", "implement",
 				"compareTo(S)");
 	}
 
 	@Test public void testClassMustBeAbstract_02() throws Exception {
-		XtendClass xtendClass = clazz("class Foo<S> implements Comparable { }");
-		helper.assertError(xtendClass, XTEND_CLASS, CLASS_MUST_BE_ABSTRACT, "abstract", "not", "implement",
+		var source = "class Foo<S> implements Comparable { }";
+		XtendClass xtendClass = clazz(source);
+		helper.assertError(xtendClass, XTEND_CLASS, CLASS_MUST_BE_ABSTRACT,
+				source.indexOf("Foo"), "Foo".length(),
+				"abstract", "not", "implement",
 				"compareTo(Object)");
 	}
 
 	@Test public void testClassMustBeAbstract_03() throws Exception {
-		XtendClass xtendClass = clazz("class Foo implements Comparable<String> { }");
-		helper.assertError(xtendClass, XTEND_CLASS, CLASS_MUST_BE_ABSTRACT, "abstract", "not", "implement",
+		var source = "class Foo implements Comparable<String> { }";
+		XtendClass xtendClass = clazz(source);
+		helper.assertError(xtendClass, XTEND_CLASS, CLASS_MUST_BE_ABSTRACT,
+				source.indexOf("Foo"), "Foo".length(),
+				"abstract", "not", "implement",
 				"compareTo(String)");
 	}
 
@@ -391,8 +434,11 @@ public void testClassMustBeAbstract_06() throws Exception {
 	}
 
 	@Test public void testOverrideFinalClass() throws Exception {
-		XtendClass xtendClass = clazz("class Foo extends String { }");
-		helper.assertError(xtendClass, XTEND_CLASS, OVERRIDDEN_FINAL, "override", "final");
+		var source = "class Foo extends String { }";
+		XtendClass xtendClass = clazz(source);
+		helper.assertError(xtendClass, XTEND_CLASS, OVERRIDDEN_FINAL,
+				source.indexOf("String"), "String".length(),
+				"override", "final");
 	}
 
 	@Test public void testOverrideFinalMethod() throws Exception {
@@ -913,8 +959,19 @@ public void testClassMustBeAbstract_06() throws Exception {
 	}
 
 	@Test public void testAnonymousClassMustBeAbstract() throws Exception {
-		XtendClass xtendClass = clazz("class Foo { val foo = new Runnable() {} }");
-		helper.assertError(xtendClass, ANONYMOUS_CLASS, ANONYMOUS_CLASS_MISSING_MEMBERS, "The anonymous subclass of Runnable does not implement run()");
+		var source = "class Foo { val foo = new Runnable() {} }";
+		XtendClass xtendClass = clazz(source);
+		helper.assertError(xtendClass, ANONYMOUS_CLASS, ANONYMOUS_CLASS_MISSING_MEMBERS,
+				source.indexOf("new Runnable()"), "new Runnable()".length(),
+				"The anonymous subclass of Runnable does not implement run()");
+	}
+
+	@Test public void testAnonymousClassMustBeAbstract_1() throws Exception {
+		var source = "class Foo { val foo = new Runnable() { int i; } }";
+		XtendClass xtendClass = clazz(source);
+		helper.assertError(xtendClass, ANONYMOUS_CLASS, ANONYMOUS_CLASS_MISSING_MEMBERS,
+				source.indexOf("new Runnable()"), "new Runnable()".length(),
+				"The anonymous subclass of Runnable does not implement run()");
 	}
 
 	@Test public void testAnonymousClassIncompatibleSignature_0() throws Exception {

org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/ValidationBug435020Test.xtend

@@ -42,33 +42,41 @@ class ValidationBug435020Test extends AbstractXtendTestCase {
 	}
 
 	@Test def void test_02() {
-		val c = parser.parse('''
+		val source = '''
 			class Foo {
 				def void foo() {
 					new Object {
 						static var x = 1
 					}
 				}
 			}
-		''')
-		c.assertError(XtendPackage.Literals.XTEND_FIELD, IssueCodes.ANONYMOUS_CLASS_STATIC_FIELD)
+		'''
+		val c = parser.parse(source)
+		c.assertError(XtendPackage.Literals.XTEND_FIELD, IssueCodes.ANONYMOUS_CLASS_STATIC_FIELD,
+			source.indexOf("static"), "static".length,
+			"A static field of an anonymous class must be final"
+		)
 	}
 
 	@Test def void test_03() {
-		val c = parser.parse('''
+		val source = '''
 			class Foo {
 				def void foo() {
 					new Object {
 						static val x = Math.max(1, 2)
 					}
 				}
 			}
-		''')
-		c.assertError(XtendPackage.Literals.XTEND_FIELD, IssueCodes.ANONYMOUS_CLASS_STATIC_FIELD)
+		'''
+		val c = parser.parse(source)
+		c.assertError(XtendPackage.Literals.XTEND_FIELD, IssueCodes.ANONYMOUS_CLASS_STATIC_FIELD,
+			source.indexOf("Math.max(1, 2)"), "Math.max(1, 2)".length,
+			"must be initialized with a constant expression"
+		)
 	}
 
 	@Test def void test_04() {
-		val c = parser.parse('''
+		val source = '''
 			class Foo {
 				def void foo() {
 					new Object {
@@ -77,8 +85,12 @@ class ValidationBug435020Test extends AbstractXtendTestCase {
 					}
 				}
 			}
-		''')
-		c.assertError(XtendPackage.Literals.XTEND_FUNCTION, IssueCodes.ANONYMOUS_CLASS_STATIC_METHOD)
+		'''
+		val c = parser.parse(source)
+		c.assertError(XtendPackage.Literals.XTEND_FUNCTION, IssueCodes.ANONYMOUS_CLASS_STATIC_METHOD,
+			source.indexOf("static"), "static".length,
+			"A method of an anonymous class cannot be static"
+		)
 	}
 
 }