From a5be13b6ef3c6ec03d3409de31c4304e9ce67c41 Mon Sep 17 00:00:00 2001 From: Lorenzo Bettini Date: Mon, 18 Dec 2023 14:52:16 +0100 Subject: [PATCH 01/20] Added an Xtend validator test for cycles in internal types --- .../tests/validation/XtendValidationTest.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java index b05cad5739f..b95459ee958 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java +++ b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java @@ -996,6 +996,7 @@ public void clearPreferences() { + "class Foo implements Bar { interface I {} }" + "interface Bar extends Foo.I {}").getXtendTypes().iterator(); helper.assertError(types.next(), XTEND_CLASS, CYCLIC_INHERITANCE, "hierarchy", "cycles"); + helper.assertError(types.next(), XTEND_CLASS, CYCLIC_INHERITANCE, "hierarchy", "cycles"); } @Test public void testInheritanceCycle_5() throws Exception { @@ -1003,6 +1004,21 @@ public void clearPreferences() { + "class Foo extends Bar { static class Baz {} }" + "class Bar extends Foo.Baz {}").getXtendTypes().iterator(); helper.assertError(types.next(), XTEND_CLASS, CYCLIC_INHERITANCE, "hierarchy", "cycles"); + helper.assertError(types.next(), XTEND_CLASS, CYCLIC_INHERITANCE, "hierarchy", "cycles"); + } + + @Test public void testInheritanceCycle_6() throws Exception { + Iterator types = file("package test " + + "class Container {" + + " interface Foo extends Bar {}" + + " interface Bar extends Baz {}" + + " interface Baz extends Foo {}" + + "}").getXtendTypes().iterator(); + var container = types.next(); + var internalTypes = container.getMembers().iterator(); + helper.assertError(internalTypes.next(), XTEND_INTERFACE, CYCLIC_INHERITANCE, "hierarchy", "cycles"); + helper.assertError(internalTypes.next(), XTEND_INTERFACE, CYCLIC_INHERITANCE, "hierarchy", "cycles"); + helper.assertError(internalTypes.next(), XTEND_INTERFACE, CYCLIC_INHERITANCE, "hierarchy", "cycles"); } @Test public void testMultipleInheritance() throws Exception { From e90a83cc2dfbb1d62ee2144d4f89be54f78ec66a Mon Sep 17 00:00:00 2001 From: Lorenzo Bettini Date: Wed, 20 Dec 2023 08:57:56 +0100 Subject: [PATCH 02/20] also verify the error's position for hierarchy cycles --- .../tests/validation/XtendValidationTest.java | 24 +++++++++++++------ 1 file changed, 17 insertions(+), 7 deletions(-) diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java index b95459ee958..1a4e35df08a 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java +++ b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java @@ -914,8 +914,11 @@ public void clearPreferences() { } @Test public void testClassExtendsItself() throws Exception { - XtendClass clazz = clazz("class Foo extends Foo {}"); - helper.assertError(clazz, XTEND_CLASS, CYCLIC_INHERITANCE, "hierarchy", "cycles"); + var source = "class Foo extends Foo {}"; + XtendClass clazz = clazz(source); + helper.assertError(clazz, XTEND_CLASS, CYCLIC_INHERITANCE, + source.indexOf("Foo"), "Foo".length(), + "hierarchy", "cycles"); } @Test public void testClassUniqueNames() throws Exception { @@ -956,13 +959,20 @@ public void clearPreferences() { } @Test public void testInheritanceCycle() throws Exception { - Iterator types = file("package test " + var source = "package test " + "class Foo extends Bar {}" + "class Bar extends Baz {}" - + "class Baz extends Foo {}").getXtendTypes().iterator(); - helper.assertError(types.next(), XTEND_CLASS, CYCLIC_INHERITANCE, "hierarchy", "cycles"); - helper.assertError(types.next(), XTEND_CLASS, CYCLIC_INHERITANCE, "hierarchy", "cycles"); - helper.assertError(types.next(), XTEND_CLASS, CYCLIC_INHERITANCE, "hierarchy", "cycles"); + + "class Baz extends Foo {}"; + Iterator types = file(source).getXtendTypes().iterator(); + helper.assertError(types.next(), XTEND_CLASS, CYCLIC_INHERITANCE, + source.indexOf("Foo"), "Foo".length(), + "hierarchy", "cycles"); + helper.assertError(types.next(), XTEND_CLASS, CYCLIC_INHERITANCE, + source.lastIndexOf("Bar"), "Bar".length(), + "hierarchy", "cycles"); + helper.assertError(types.next(), XTEND_CLASS, CYCLIC_INHERITANCE, + source.lastIndexOf("Baz"), "Baz".length(), + "hierarchy", "cycles"); } @Test public void testInheritanceCycle_1() throws Exception { From 7620075874b93eedb44bc4cb18714f24602cf0df Mon Sep 17 00:00:00 2001 From: Lorenzo Bettini Date: Wed, 20 Dec 2023 09:07:15 +0100 Subject: [PATCH 03/20] also verify error's position for INTERFACE_EXPECTED --- .../tests/validation/XtendValidationTest.java | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java index 1a4e35df08a..92b8d5de2b4 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java +++ b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java @@ -909,10 +909,13 @@ public void clearPreferences() { } @Test public void testClassImplementsClass() throws Exception { - XtendClass clazz = clazz("class Foo implements Object {}"); - helper.assertError(clazz, XTEND_CLASS, INTERFACE_EXPECTED, "Implemented", "interface"); + var source = "class Foo implements Object {}"; + XtendClass clazz = clazz(source); + helper.assertError(clazz, XTEND_CLASS, INTERFACE_EXPECTED, + source.indexOf("Object"), "Object".length(), + "Implemented", "interface"); } - + @Test public void testClassExtendsItself() throws Exception { var source = "class Foo extends Foo {}"; XtendClass clazz = clazz(source); @@ -932,8 +935,11 @@ public void clearPreferences() { } @Test public void testInterfaceExtendsClass() throws Exception { - XtendInterface interfaze = interfaze("interface Foo extends Object {}"); - helper.assertError(interfaze, XTEND_INTERFACE, INTERFACE_EXPECTED, "Extended", "interface"); + var source = "interface Foo extends Object {}"; + XtendInterface interfaze = interfaze(source); + helper.assertError(interfaze, XTEND_INTERFACE, INTERFACE_EXPECTED, + source.indexOf("Object"), "Object".length(), + "Extended", "interface"); } @Test public void testInterfaceExtendsItself() throws Exception { From 69b04d324b206243167a6c5a42aa86660e375471 Mon Sep 17 00:00:00 2001 From: Lorenzo Bettini Date: Wed, 20 Dec 2023 09:32:24 +0100 Subject: [PATCH 04/20] also verify error's position for OVERRIDDEN_FINAL --- .../core/tests/validation/OverrideValidationTest.java | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java index 9cad086493b..d18a321f49a 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java +++ b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java @@ -391,8 +391,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 { From bd3c61ae3e26173d7a79d8705c1ae07aebda1185 Mon Sep 17 00:00:00 2001 From: Lorenzo Bettini Date: Wed, 20 Dec 2023 09:37:34 +0100 Subject: [PATCH 05/20] also verify error's position for CLASS_EXPECTED --- .../xtend/core/tests/validation/XtendValidationTest.java | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java index 92b8d5de2b4..2edab5299ee 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java +++ b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java @@ -904,8 +904,11 @@ public void clearPreferences() { } @Test public void testClassExtendsInterface() throws Exception { - XtendClass clazz = clazz("class Foo extends Cloneable {}"); - helper.assertError(clazz, XTEND_CLASS, CLASS_EXPECTED, "Superclass"); + var source = "class Foo extends Cloneable {}"; + XtendClass clazz = clazz(source); + helper.assertError(clazz, XTEND_CLASS, CLASS_EXPECTED, + source.indexOf("Cloneable"), "Cloneable".length(), + "Superclass"); } @Test public void testClassImplementsClass() throws Exception { From 3af4f668e45fbc1887e0d864a0033005872a84b0 Mon Sep 17 00:00:00 2001 From: Lorenzo Bettini Date: Wed, 20 Dec 2023 10:22:43 +0100 Subject: [PATCH 06/20] also verify error's position for field INVALID_USE_OF_TYPE --- .../xtend/core/tests/validation/XtendValidationTest.java | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java index 2edab5299ee..00a90558671 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java +++ b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java @@ -577,8 +577,10 @@ public void clearPreferences() { } @Test public void testVoidInDependency() throws Exception { - XtendClass clazz = clazz("class X { @Inject void v }"); - helper.assertError(clazz, TypesPackage.Literals.JVM_TYPE_REFERENCE, INVALID_USE_OF_TYPE); + var source = "class X { @Inject void v }"; + XtendClass clazz = clazz(source); + helper.assertError(clazz, TypesPackage.Literals.JVM_TYPE_REFERENCE, INVALID_USE_OF_TYPE, + source.indexOf("void"), "void".length()); } @Test public void testVoidInReturn() throws Exception { From b68fdb0def96892d4af0b981e4ad310b0597513b Mon Sep 17 00:00:00 2001 From: Lorenzo Bettini Date: Wed, 20 Dec 2023 11:21:34 +0100 Subject: [PATCH 07/20] also verify error's position for parameter INVALID_USE_OF_TYPE --- .../xtend/core/tests/AbstractXtendTestCase.java | 13 +++++++++++-- .../core/tests/validation/XtendValidationTest.java | 7 +++++-- 2 files changed, 16 insertions(+), 4 deletions(-) diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/AbstractXtendTestCase.java b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/AbstractXtendTestCase.java index be4a2d97b03..f26fec70098 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/AbstractXtendTestCase.java +++ b/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 resourceSetProvider; + /** + * To build a function or constructor for tests + */ + protected static final String TEMPLATE_CLASS = "class Foo { %s }"; + /** + * Use it to subtract from the index position of a source element of a function or constructor + */ + protected static final int TEMPLATE_CLASS_SIZE = TEMPLATE_CLASS.length() - 2; // 2 is the length of placeholder %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); } diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java index 00a90558671..0ff592d079a 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java +++ b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java @@ -589,8 +589,11 @@ public void clearPreferences() { } @Test public void testParameterTypeMayNotBeVoid() throws Exception { - XtendFunction function = function("def void foo(void myParam) { }"); - helper.assertError(function, TypesPackage.Literals.JVM_TYPE_REFERENCE, INVALID_USE_OF_TYPE); + var source = "def void foo(void myParam) { }"; + XtendFunction function = function(source); + helper.assertError(function, TypesPackage.Literals.JVM_TYPE_REFERENCE, + INVALID_USE_OF_TYPE, + source.lastIndexOf("void") - TEMPLATE_CLASS_SIZE, "void".length()); } @Test public void testVarArgIsNotExtension() throws Exception { From 798947ebc238d54a749bd0287e8f8e6738b12dde Mon Sep 17 00:00:00 2001 From: Lorenzo Bettini Date: Wed, 20 Dec 2023 13:59:41 +0100 Subject: [PATCH 08/20] fixed verify error's position for parameter INVALID_USE_OF_TYPE --- .../org/eclipse/xtend/core/tests/AbstractXtendTestCase.java | 4 ++-- .../xtend/core/tests/validation/XtendValidationTest.java | 3 ++- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/AbstractXtendTestCase.java b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/AbstractXtendTestCase.java index f26fec70098..04a5f1230b0 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/AbstractXtendTestCase.java +++ b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/AbstractXtendTestCase.java @@ -65,9 +65,9 @@ public abstract class AbstractXtendTestCase extends Assert { */ protected static final String TEMPLATE_CLASS = "class Foo { %s }"; /** - * Use it to subtract from the index position of a source element of a function or constructor + * Use it to add it to the index position of a source element of a function or constructor */ - protected static final int TEMPLATE_CLASS_SIZE = TEMPLATE_CLASS.length() - 2; // 2 is the length of placeholder %s + 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); diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java index 0ff592d079a..72639d30daa 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java +++ b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java @@ -591,9 +591,10 @@ public void clearPreferences() { @Test public void testParameterTypeMayNotBeVoid() throws Exception { var source = "def void foo(void myParam) { }"; XtendFunction function = function(source); + var lastIndexOf = source.lastIndexOf("void"); helper.assertError(function, TypesPackage.Literals.JVM_TYPE_REFERENCE, INVALID_USE_OF_TYPE, - source.lastIndexOf("void") - TEMPLATE_CLASS_SIZE, "void".length()); + lastIndexOf + TEMPLATE_CLASS_PREFIX_SIZE, "void".length()); } @Test public void testVarArgIsNotExtension() throws Exception { From 9ee830021cff034f1e18d353c21c9c5714a84794 Mon Sep 17 00:00:00 2001 From: Lorenzo Bettini Date: Wed, 20 Dec 2023 14:04:10 +0100 Subject: [PATCH 09/20] also verify error's position for DUPLICATE_PARAMETER_NAME --- .../tests/validation/XtendValidationTest.java | 24 ++++++++++++++----- 1 file changed, 18 insertions(+), 6 deletions(-) diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java index 72639d30daa..36100656707 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java +++ b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java @@ -1229,15 +1229,27 @@ public void testInaccessibleMethod15() throws Exception { } @Test public void testDuplicateParameter() throws Exception { - XtendFunction function = function("def foo(int x, int x) {null}"); - helper.assertError(function, XTEND_FUNCTION, DUPLICATE_PARAMETER_NAME, "duplicate", "x"); + var source = "def foo(int x, int x) {null}"; + XtendFunction function = function(source); + helper.assertError(function, XTEND_FUNCTION, DUPLICATE_PARAMETER_NAME, + source.indexOf("int x") + TEMPLATE_CLASS_PREFIX_SIZE, "int x".length(), + "duplicate", "x"); + helper.assertError(function, XTEND_FUNCTION, DUPLICATE_PARAMETER_NAME, + source.lastIndexOf("int x") + TEMPLATE_CLASS_PREFIX_SIZE, "int x".length(), + "duplicate", "x"); } - + @Test public void testDuplicateConstructorParameter() throws Exception { - XtendConstructor constructor = constructor("new(int x, int x) {null}"); - helper.assertError(constructor, XTEND_CONSTRUCTOR, DUPLICATE_PARAMETER_NAME, "duplicate", "x"); + var source = "new(int x, int x) {null}"; + XtendConstructor constructor = constructor(source); + helper.assertError(constructor, XTEND_CONSTRUCTOR, DUPLICATE_PARAMETER_NAME, + source.indexOf("int x") + TEMPLATE_CLASS_PREFIX_SIZE, "int x".length(), + "duplicate", "x"); + helper.assertError(constructor, XTEND_CONSTRUCTOR, DUPLICATE_PARAMETER_NAME, + source.lastIndexOf("int x") + TEMPLATE_CLASS_PREFIX_SIZE, "int x".length(), + "duplicate", "x"); } - + @Test public void testDuplicateParameter_CreateExtension_01() throws Exception { XtendFunction function = function("def create newArrayList foo(int it) {}"); helper.assertError(function, CREATE_EXTENSION_INFO, DUPLICATE_PARAMETER_NAME, "duplicate", "implicit", "it"); From 0a107d62486e2182cdc5d5e9a80b1856c037e10e Mon Sep 17 00:00:00 2001 From: Lorenzo Bettini Date: Wed, 20 Dec 2023 15:07:38 +0100 Subject: [PATCH 10/20] also verify error's position for duplicates --- .../tests/validation/XtendValidationTest.java | 35 ++++++++++++++----- 1 file changed, 27 insertions(+), 8 deletions(-) diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java index 36100656707..9f6c19db731 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java +++ b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java @@ -934,8 +934,14 @@ public void clearPreferences() { } @Test public void testClassUniqueNames() throws Exception { - XtendClass clazz = clazz("class Foo {} class Foo {}"); - helper.assertError(clazz, XTEND_CLASS, DUPLICATE_TYPE_NAME, "type", "already defined"); + var source = "class Foo {} class Foo {}"; + XtendClass clazz = clazz(source); + helper.assertError(clazz, XTEND_CLASS, DUPLICATE_TYPE_NAME, + source.indexOf("Foo"), "Foo".length(), + "type", "already defined"); + helper.assertError(clazz, XTEND_CLASS, DUPLICATE_TYPE_NAME, + source.lastIndexOf("Foo"), "Foo".length(), + "type", "already defined"); } @Test public void testInterfaceExtendsInterface() throws Exception { @@ -1084,15 +1090,28 @@ public void clearPreferences() { } @Test public void testDuplicateFieldName() throws Exception { - XtendClass clazz = clazz("class Foo { int foo String foo double foo }"); - for(XtendMember member: clazz.getMembers()) - helper.assertError(member, XTEND_FIELD, DUPLICATE_FIELD, "foo", "duplicate"); + var source = "class Foo { int foo String foo double foo }"; + Iterator members = clazz(source).getMembers().iterator(); + helper.assertError(members.next(), XTEND_FIELD, DUPLICATE_FIELD, + source.indexOf("foo"), "foo".length(), + "foo", "duplicate"); + helper.assertError(members.next(), XTEND_FIELD, DUPLICATE_FIELD, + source.indexOf("String foo") + "String ".length(), "foo".length(), + "foo", "duplicate"); + helper.assertError(members.next(), XTEND_FIELD, DUPLICATE_FIELD, + source.indexOf("double foo") + "double ".length(), "foo".length(), + "foo", "duplicate"); } @Test public void testDuplicateAnonymousExtension() throws Exception { - XtendClass clazz = clazz("import com.google.inject.Inject class Foo { @Inject extension String @Inject extension String }"); - for(XtendMember member: clazz.getMembers()) - helper.assertError(member, XTEND_FIELD, DUPLICATE_FIELD, "duplicate", "same", "type"); + var source = "import com.google.inject.Inject class Foo { @Inject extension String @Inject extension String }"; + Iterator members = clazz(source).getMembers().iterator(); + helper.assertError(members.next(), XTEND_FIELD, DUPLICATE_FIELD, + source.indexOf("String"), "String".length(), + "duplicate", "same", "type"); + helper.assertError(members.next(), XTEND_FIELD, DUPLICATE_FIELD, + source.lastIndexOf("String"), "String".length(), + "duplicate", "same", "type"); } @Test public void testCaseFunctionNoParameters() throws Exception { From 2492401c21ec15ed20e137448600bbe19bd08d74 Mon Sep 17 00:00:00 2001 From: Lorenzo Bettini Date: Wed, 20 Dec 2023 16:44:07 +0100 Subject: [PATCH 11/20] also verify error's position for duplicate methods --- .../validation/OverrideValidationTest.java | 10 ++++++++-- .../tests/validation/XtendValidationTest.java | 18 ++++++++++++------ 2 files changed, 20 insertions(+), 8 deletions(-) diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java index d18a321f49a..b36fd6752a6 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java +++ 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"); + helper.assertError(xtendClass.getMembers().get(0), XTEND_FUNCTION, DUPLICATE_METHOD, + source.lastIndexOf("bar"), "bar".length(), + "duplicate"); } @Test public void testDuplicateMethod_1() throws Exception { diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java index 9f6c19db731..cbacb25bdfa 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java +++ b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java @@ -381,15 +381,21 @@ public void clearPreferences() { } @Test public void testConstructorDuplicate() throws Exception { - XtendClass clazz = clazz("class K { new(Object o) {} new(Object o) {} }"); - helper.assertError(clazz, XTEND_CONSTRUCTOR, DUPLICATE_METHOD); - helper.assertError(clazz, XTEND_CONSTRUCTOR, DUPLICATE_METHOD); + var source = "class K { new(Object o) {} new(Object o) {} }"; + XtendClass clazz = clazz(source); + helper.assertError(clazz, XTEND_CONSTRUCTOR, DUPLICATE_METHOD, + source.indexOf("new(Object o) {}"), "new(Object o) {}".length()); + helper.assertError(clazz, XTEND_CONSTRUCTOR, DUPLICATE_METHOD, + source.lastIndexOf("new(Object o) {}"), "new(Object o) {}".length()); } @Test public void testConstructorDuplicateErasure() throws Exception { - XtendClass clazz = clazz("class K { new(java.util.List o) {} new(java.util.List o) {} }"); - helper.assertError(clazz, XTEND_CONSTRUCTOR, DUPLICATE_METHOD); - helper.assertError(clazz, XTEND_CONSTRUCTOR, DUPLICATE_METHOD); + var source = "class K { new(java.util.List o) {} new(java.util.List o) {} }"; + XtendClass clazz = clazz(source); + helper.assertError(clazz, XTEND_CONSTRUCTOR, DUPLICATE_METHOD, + source.indexOf("new(java.util.List o) {}"), "new(java.util.List o) {}".length()); + helper.assertError(clazz, XTEND_CONSTRUCTOR, DUPLICATE_METHOD, + source.indexOf("new(java.util.List o) {}"), "new(java.util.List o) {}".length()); } @Test public void testConstructorDoesNotSupportTypeArguments() throws Exception { From 0216c6ba41c087941585a30924db126149a9bd54 Mon Sep 17 00:00:00 2001 From: Lorenzo Bettini Date: Wed, 20 Dec 2023 16:51:25 +0100 Subject: [PATCH 12/20] also verify error's message parts for duplicate methods --- .../tests/validation/OverrideValidationTest.java | 10 ++++++---- .../core/tests/validation/XtendValidationTest.java | 12 ++++++++---- 2 files changed, 14 insertions(+), 8 deletions(-) diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java index b36fd6752a6..564f6f82521 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java +++ b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java @@ -38,10 +38,10 @@ public class OverrideValidationTest extends AbstractXtendTestCase { XtendClass xtendClass = clazz(source); helper.assertError(xtendClass.getMembers().get(0), XTEND_FUNCTION, DUPLICATE_METHOD, source.indexOf("bar"), "bar".length(), - "duplicate"); + "duplicate", "method"); helper.assertError(xtendClass.getMembers().get(0), XTEND_FUNCTION, DUPLICATE_METHOD, source.lastIndexOf("bar"), "bar".length(), - "duplicate"); + "duplicate", "method"); } @Test public void testDuplicateMethod_1() throws Exception { @@ -56,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 x) {true} def bar(java.util.List 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 o) {}"), "new(java.util.List o) {}".length()); + source.indexOf("new(java.util.List o) {}"), "new(java.util.List o) {}".length(), + "erasure", "constructor", "List"); helper.assertError(clazz, XTEND_CONSTRUCTOR, DUPLICATE_METHOD, - source.indexOf("new(java.util.List o) {}"), "new(java.util.List o) {}".length()); + source.indexOf("new(java.util.List o) {}"), "new(java.util.List o) {}".length(), + "erasure", "constructor", "List"); } @Test public void testConstructorDoesNotSupportTypeArguments() throws Exception { From 17137235343459371f9ce6bbb4d362f5dd2b83c4 Mon Sep 17 00:00:00 2001 From: Lorenzo Bettini Date: Fri, 29 Dec 2023 10:00:52 +0100 Subject: [PATCH 13/20] added missing tests for doCheckOverriddenMethods --- .../validation/OverrideValidationTest.java | 32 +++++++++++++++++-- 1 file changed, 29 insertions(+), 3 deletions(-) diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java index 564f6f82521..488408083c1 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java +++ b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java @@ -156,10 +156,14 @@ public class OverrideValidationTest extends AbstractXtendTestCase { } @Test public void testOverrideGenericMethod_10() throws Exception { - XtendClass xtendClass = clazz(" abstract class Foo extends test.GenericSuperTypeClass { " + + var source = " abstract class Foo extends test.GenericSuperTypeClass { " + "override 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 { @@ -197,6 +201,28 @@ public class OverrideValidationTest extends AbstractXtendTestCase { helper.assertNoErrors(xtendClass); } + @Test public void testStaticMethodHidesInstanceMethod() throws Exception { + var source = " abstract class Foo extends test.GenericSuperTypeClass { " + + "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 extends test.GenericSuperTypeClass { " + "override T getSomething(T t){} "+ From 31e82ab103fa5f4ccfed76fa6a119029ad45a898 Mon Sep 17 00:00:00 2001 From: Lorenzo Bettini Date: Fri, 29 Dec 2023 12:12:46 +0100 Subject: [PATCH 14/20] also verify error position for CONFLICTING_DEFAULT_METHODS --- .../validation/Java8ValidationTest.xtend | 24 ++++++++++++------- .../java8/validation/Java8ValidationTest.java | 16 +++++++++---- 2 files changed, 28 insertions(+), 12 deletions(-) diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/java8/validation/Java8ValidationTest.xtend b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/java8/validation/Java8ValidationTest.xtend index cfbb022d22f..c27f4d57859 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/java8/validation/Java8ValidationTest.xtend +++ b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/java8/validation/Java8ValidationTest.xtend @@ -69,7 +69,7 @@ class Java8ValidationTest extends AbstractXtendTestCase { @Test def void testConflictingDefaultMethods01() { - file(''' + val source = ''' interface A { def void foo() { } } @@ -77,13 +77,15 @@ class Java8ValidationTest extends AbstractXtendTestCase { 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() { } } @@ -91,13 +93,15 @@ class Java8ValidationTest extends AbstractXtendTestCase { 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() { } } @@ -105,13 +109,15 @@ class Java8ValidationTest extends AbstractXtendTestCase { 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() { } } @@ -119,7 +125,9 @@ class Java8ValidationTest extends AbstractXtendTestCase { 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.") } diff --git a/org.eclipse.xtend.core.tests/xtend-gen/org/eclipse/xtend/core/tests/java8/validation/Java8ValidationTest.java b/org.eclipse.xtend.core.tests/xtend-gen/org/eclipse/xtend/core/tests/java8/validation/Java8ValidationTest.java index 82c409a39db..f2b49575b94 100644 --- a/org.eclipse.xtend.core.tests/xtend-gen/org/eclipse/xtend/core/tests/java8/validation/Java8ValidationTest.java +++ b/org.eclipse.xtend.core.tests/xtend-gen/org/eclipse/xtend/core/tests/java8/validation/Java8ValidationTest.java @@ -128,7 +128,9 @@ public void testConflictingDefaultMethods01() { _builder.newLine(); _builder.append("class C implements A, B { }"); _builder.newLine(); - this._validationTestHelper.assertError(this.file(_builder.toString()), XtendPackage.Literals.XTEND_CLASS, IssueCodes.CONFLICTING_DEFAULT_METHODS, + final String source = _builder.toString(); + this._validationTestHelper.assertError(this.file(source), XtendPackage.Literals.XTEND_CLASS, IssueCodes.CONFLICTING_DEFAULT_METHODS, + source.indexOf("C"), 1, "The type C inherits multiple implementations of the method foo() from A and B."); } catch (Throwable _e) { throw Exceptions.sneakyThrow(_e); @@ -155,7 +157,9 @@ public void testConflictingDefaultMethods02() { _builder.newLine(); _builder.append("interface C extends A, B { }"); _builder.newLine(); - this._validationTestHelper.assertError(this.file(_builder.toString()), XtendPackage.Literals.XTEND_INTERFACE, IssueCodes.CONFLICTING_DEFAULT_METHODS, + final String source = _builder.toString(); + this._validationTestHelper.assertError(this.file(source), XtendPackage.Literals.XTEND_INTERFACE, IssueCodes.CONFLICTING_DEFAULT_METHODS, + source.indexOf("C"), 1, "The type C inherits multiple implementations of the method foo() from A and B."); } catch (Throwable _e) { throw Exceptions.sneakyThrow(_e); @@ -182,7 +186,9 @@ public void testConflictingDefaultMethods03() { _builder.newLine(); _builder.append("class C implements A, B { }"); _builder.newLine(); - this._validationTestHelper.assertError(this.file(_builder.toString()), XtendPackage.Literals.XTEND_CLASS, IssueCodes.CONFLICTING_DEFAULT_METHODS, + final String source = _builder.toString(); + this._validationTestHelper.assertError(this.file(source), XtendPackage.Literals.XTEND_CLASS, IssueCodes.CONFLICTING_DEFAULT_METHODS, + source.indexOf("C"), 1, "The non-abstract method foo() inherited from A conflicts with the method foo() inherited from B."); } catch (Throwable _e) { throw Exceptions.sneakyThrow(_e); @@ -209,7 +215,9 @@ public void testConflictingDefaultMethods04() { _builder.newLine(); _builder.append("interface C extends A, B { }"); _builder.newLine(); - this._validationTestHelper.assertError(this.file(_builder.toString()), XtendPackage.Literals.XTEND_INTERFACE, IssueCodes.CONFLICTING_DEFAULT_METHODS, + final String source = _builder.toString(); + this._validationTestHelper.assertError(this.file(source), XtendPackage.Literals.XTEND_INTERFACE, IssueCodes.CONFLICTING_DEFAULT_METHODS, + source.indexOf("C"), 1, "The non-abstract method foo() inherited from A conflicts with the method foo() inherited from B."); } catch (Throwable _e) { throw Exceptions.sneakyThrow(_e); From 82b03fb2583b79ea84669f445dc69f120de5b5a7 Mon Sep 17 00:00:00 2001 From: Lorenzo Bettini Date: Fri, 29 Dec 2023 14:26:51 +0100 Subject: [PATCH 15/20] also verify error position for CLASS_MUST_BE_ABSTRACT --- .../validation/OverrideValidationTest.java | 21 +++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java index 488408083c1..ec4e172429e 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java +++ b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java @@ -389,20 +389,29 @@ public class OverrideValidationTest extends AbstractXtendTestCase { } @Test public void testClassMustBeAbstract_01() throws Exception { - XtendClass xtendClass = clazz("class Foo implements Comparable { }"); - helper.assertError(xtendClass, XTEND_CLASS, CLASS_MUST_BE_ABSTRACT, "abstract", "not", "implement", + var source = "class Foo implements Comparable { }"; + 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 implements Comparable { }"); - helper.assertError(xtendClass, XTEND_CLASS, CLASS_MUST_BE_ABSTRACT, "abstract", "not", "implement", + var source = "class Foo 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 { }"); - helper.assertError(xtendClass, XTEND_CLASS, CLASS_MUST_BE_ABSTRACT, "abstract", "not", "implement", + var source = "class Foo implements Comparable { }"; + XtendClass xtendClass = clazz(source); + helper.assertError(xtendClass, XTEND_CLASS, CLASS_MUST_BE_ABSTRACT, + source.indexOf("Foo"), "Foo".length(), + "abstract", "not", "implement", "compareTo(String)"); } From ad69b302d24b43f22b706609529d174ede136fa6 Mon Sep 17 00:00:00 2001 From: Lorenzo Bettini Date: Fri, 29 Dec 2023 14:54:19 +0100 Subject: [PATCH 16/20] also verify error position for ANONYMOUS_CLASS_MISSING_MEMBERS --- .../core/tests/validation/OverrideValidationTest.java | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java index ec4e172429e..9598e14e999 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java +++ b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java @@ -959,8 +959,11 @@ 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 testAnonymousClassIncompatibleSignature_0() throws Exception { From fd8c3bc967113d531145c8d501bbeebe7d08aa0b Mon Sep 17 00:00:00 2001 From: Lorenzo Bettini Date: Fri, 29 Dec 2023 16:48:53 +0100 Subject: [PATCH 17/20] also verify error position for anonymous class override final class --- .../tests/validation/XtendValidationTest.java | 21 +++++++++++-------- 1 file changed, 12 insertions(+), 9 deletions(-) diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java index c0358d8850b..7247f6cead0 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java +++ b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java @@ -2367,16 +2367,19 @@ public void testWildcardSuperType_5() throws Exception { @Test public void testAnonymousClassExtendsFinal() throws Exception { - XtendFile file = file( - "class Foo {" - + " val bar = new Bar() {" - + " }" - + "}" - + "final class Bar {" - + "}"); - helper.assertError(file.getXtendTypes().get(0), XCONSTRUCTOR_CALL, OVERRIDDEN_FINAL); + var source = "class Foo {" + + " val bar = new Bar() {" + + " }" + + "}" + + "final class Bar {" + + "}"; + XtendFile file = file(source); + helper.assertError(file.getXtendTypes().get(0), + XCONSTRUCTOR_CALL, OVERRIDDEN_FINAL, + source.indexOf("Bar"), "Bar".length(), + "Attempt to override final class"); } - + @Test public void testVoidInFunctionParams() throws Exception { XtendFile file = file( From 365f1fa4489ada3ce337f109de74ad14623fe7da Mon Sep 17 00:00:00 2001 From: Lorenzo Bettini Date: Sat, 30 Dec 2023 11:05:04 +0100 Subject: [PATCH 18/20] added test with anonymous class not implementing abstract methods --- .../core/tests/validation/OverrideValidationTest.java | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java index 9598e14e999..d9658b73199 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java +++ b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/OverrideValidationTest.java @@ -966,6 +966,14 @@ public void testClassMustBeAbstract_06() throws Exception { "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 { XtendClass xtendClass = clazz("class Foo { val foo = new Runnable() { override run(int x) {} } }"); helper.assertError(xtendClass, XTEND_FUNCTION, OBSOLETE_OVERRIDE); From 9b52cd7684832c2ccf2c1965609555931c3d39d5 Mon Sep 17 00:00:00 2001 From: Lorenzo Bettini Date: Thu, 4 Jan 2024 18:59:09 +0100 Subject: [PATCH 19/20] also verify error position for constructors' errors --- .../core/tests/validation/XtendValidationTest.java | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java index 7247f6cead0..b459b26dd4f 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java +++ b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/XtendValidationTest.java @@ -408,13 +408,19 @@ public void clearPreferences() { } @Test public void testMissingConstructor() throws Exception { - XtendClass clazz = clazz("class K extends test.NoDefaultConstructor {}"); - helper.assertError(clazz, XTEND_CLASS, MISSING_CONSTRUCTOR); + var source = "class K extends test.NoDefaultConstructor {}"; + XtendClass clazz = clazz(source); + helper.assertError(clazz, XTEND_CLASS, MISSING_CONSTRUCTOR, + source.indexOf("K"), 1, + "must define an explicit constructor"); } @Test public void testMissingSuperConstructorCall() throws Exception { - XtendClass clazz = clazz("class K extends test.NoDefaultConstructor { new() {} }"); - helper.assertError(clazz, XTEND_CONSTRUCTOR, MUST_INVOKE_SUPER_CONSTRUCTOR); + var source = "class K extends test.NoDefaultConstructor { new() {} }"; + XtendClass clazz = clazz(source); + helper.assertError(clazz, XTEND_CONSTRUCTOR, MUST_INVOKE_SUPER_CONSTRUCTOR, + source.indexOf("new() {}"), "new() {}".length(), + "Another constructor must be invoked explicitly"); } @Test public void testSuperConstructorCall() throws Exception { From 6140007abc5a017ebb316118f61c4ce5ce011477 Mon Sep 17 00:00:00 2001 From: Lorenzo Bettini Date: Fri, 5 Jan 2024 08:00:22 +0100 Subject: [PATCH 20/20] also verify error position for anonymous class' members --- .../validation/ValidationBug435020Test.xtend | 30 +++++++++++++------ .../validation/ValidationBug435020Test.java | 21 +++++++++---- 2 files changed, 36 insertions(+), 15 deletions(-) diff --git a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/ValidationBug435020Test.xtend b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/ValidationBug435020Test.xtend index 71775e544be..198bc87de0c 100644 --- a/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/ValidationBug435020Test.xtend +++ b/org.eclipse.xtend.core.tests/src/org/eclipse/xtend/core/tests/validation/ValidationBug435020Test.xtend @@ -42,7 +42,7 @@ class ValidationBug435020Test extends AbstractXtendTestCase { } @Test def void test_02() { - val c = parser.parse(''' + val source = ''' class Foo { def void foo() { new Object { @@ -50,12 +50,16 @@ class ValidationBug435020Test extends AbstractXtendTestCase { } } } - ''') - 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 { @@ -63,12 +67,16 @@ class ValidationBug435020Test extends AbstractXtendTestCase { } } } - ''') - 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" + ) } } \ No newline at end of file diff --git a/org.eclipse.xtend.core.tests/xtend-gen/org/eclipse/xtend/core/tests/validation/ValidationBug435020Test.java b/org.eclipse.xtend.core.tests/xtend-gen/org/eclipse/xtend/core/tests/validation/ValidationBug435020Test.java index daedd3de1cc..9051b87f11a 100644 --- a/org.eclipse.xtend.core.tests/xtend-gen/org/eclipse/xtend/core/tests/validation/ValidationBug435020Test.java +++ b/org.eclipse.xtend.core.tests/xtend-gen/org/eclipse/xtend/core/tests/validation/ValidationBug435020Test.java @@ -94,8 +94,11 @@ public void test_02() { _builder.newLine(); _builder.append("}"); _builder.newLine(); - final XtendFile c = this.parser.parse(_builder); - this.helper.assertError(c, XtendPackage.Literals.XTEND_FIELD, IssueCodes.ANONYMOUS_CLASS_STATIC_FIELD); + final String source = _builder.toString(); + final XtendFile c = this.parser.parse(source); + this.helper.assertError(c, XtendPackage.Literals.XTEND_FIELD, IssueCodes.ANONYMOUS_CLASS_STATIC_FIELD, + source.indexOf("static"), "static".length(), + "A static field of an anonymous class must be final"); } catch (Throwable _e) { throw Exceptions.sneakyThrow(_e); } @@ -124,8 +127,11 @@ public void test_03() { _builder.newLine(); _builder.append("}"); _builder.newLine(); - final XtendFile c = this.parser.parse(_builder); - this.helper.assertError(c, XtendPackage.Literals.XTEND_FIELD, IssueCodes.ANONYMOUS_CLASS_STATIC_FIELD); + final String source = _builder.toString(); + final XtendFile c = this.parser.parse(source); + this.helper.assertError(c, 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"); } catch (Throwable _e) { throw Exceptions.sneakyThrow(_e); } @@ -157,8 +163,11 @@ public void test_04() { _builder.newLine(); _builder.append("}"); _builder.newLine(); - final XtendFile c = this.parser.parse(_builder); - this.helper.assertError(c, XtendPackage.Literals.XTEND_FUNCTION, IssueCodes.ANONYMOUS_CLASS_STATIC_METHOD); + final String source = _builder.toString(); + final XtendFile c = this.parser.parse(source); + this.helper.assertError(c, XtendPackage.Literals.XTEND_FUNCTION, IssueCodes.ANONYMOUS_CLASS_STATIC_METHOD, + source.indexOf("static"), "static".length(), + "A method of an anonymous class cannot be static"); } catch (Throwable _e) { throw Exceptions.sneakyThrow(_e); }