Bug 562242 - [14] RecordComponentElementImpl should override/implI20200419-1800I20200418-1800I20200417-1800

accept(...)

Change-Id: I261d3f1ebf40defcdbf7c2712ae5bedb774d921a
Signed-off-by: Jay Arthanareeswaran <jarthana@in.ibm.com>

9 files changed, 147 insertions, 1 deletions

diff --git a/org.eclipse.jdt.compiler.apt.tests/lib/apttestprocessors8.jar b/org.eclipse.jdt.compiler.apt.tests/lib/apttestprocessors8.jar
index 78d56c4acc..ad51c0139e 100644
--- a/org.eclipse.jdt.compiler.apt.tests/lib/apttestprocessors8.jar
+++ b/org.eclipse.jdt.compiler.apt.tests/lib/apttestprocessors8.jar
diff --git a/org.eclipse.jdt.compiler.apt.tests/lib/java14api.jar b/org.eclipse.jdt.compiler.apt.tests/lib/java14api.jar
index fcf9985dae..e24da08002 100644
--- a/org.eclipse.jdt.compiler.apt.tests/lib/java14api.jar
+++ b/org.eclipse.jdt.compiler.apt.tests/lib/java14api.jar
diff --git a/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java14ElementProcessor.java b/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java14ElementProcessor.java
index b8042e3204..e4b40baaf2 100644
--- a/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java14ElementProcessor.java
+++ b/org.eclipse.jdt.compiler.apt.tests/processors8/org/eclipse/jdt/compiler/apt/tests/processors/elements/Java14ElementProcessor.java
@@ -19,6 +19,7 @@ import static org.junit.Assert.fail;
 import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -43,10 +44,13 @@ import javax.lang.model.element.ModuleElement;
 import javax.lang.model.element.PackageElement;
 import javax.lang.model.element.RecordComponentElement;
 import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.TypeParameterElement;
 import javax.lang.model.element.VariableElement;
 import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.ExecutableType;
 import javax.lang.model.type.TypeKind;
 import javax.lang.model.util.ElementFilter;
+import javax.lang.model.util.ElementScanner14;
 
 import org.eclipse.jdt.internal.compiler.apt.dispatch.BaseProcessingEnvImpl;
 import org.eclipse.jdt.compiler.apt.tests.processors.base.BaseProcessor;
@@ -383,6 +387,61 @@ public class Java14ElementProcessor extends BaseProcessor {
 			assertEquals("Accessor method name incorrect", record.getSimpleName().toString(), method.getSimpleName().toString());
 		}
 	}
+	public void testRecords8() {
+		boolean result = false;
+        Object r = "DEFAULT";
+        Object param = new Object();
+        ScannerImpl<Object, Object> es = new ScannerImpl<>(r);
+
+		Element e = _elementUtils.getTypeElement("records.Record2");
+		List<? extends Element> recordElements = e.getEnclosedElements();
+		for (Element recComp : recordElements) {
+			if (recComp.getKind() == ElementKind.RECORD_COMPONENT) {
+				result = true;
+				Object r2 = recComp.accept(es, param);
+				assertSame("returned message not same", r, r2);
+				assertTrue("not visited", es.visited);
+				assertSame("Visited element not the same", recComp, es.el);
+				assertSame("Visited param not the same", param, es.param);
+			}
+		}
+        assertTrue("Test returned negative", result);
+	}
+	public void testRecords9() {
+			String[] arr1 = new String[] { "x", "bigInt", "r1", "floatValue", "c", "recordInstance" };
+			TypeKind[] arr2 = new TypeKind[] { TypeKind.INT, TypeKind.DECLARED, TypeKind.DECLARED, TypeKind.FLOAT,
+					TypeKind.DECLARED, TypeKind.DECLARED };
+			List<String> names = Arrays.asList(arr1);
+			List<TypeKind> types = Arrays.asList(arr2);
+			
+	        Element record = _elementUtils.getTypeElement("records.R3");
+	        List<? extends Element> allElements = record.getEnclosedElements();
+	        List<RecordComponentElement> components = ElementFilter.recordComponentsIn(allElements);
+	        List<ExecutableElement> accessors = components.stream().map
+	                (RecordComponentElement::getAccessor).collect(Collectors.toList());
+	        assertEquals("Size mismatch", names.size(), accessors.size());
+	        for (ExecutableElement accessor : accessors) {
+	            String name = accessor.getSimpleName().toString();
+	            int indexOf = names.indexOf(name);
+	            assertSame("Type kind not same for \"" + name + "\".", types.get(indexOf), accessor.getReturnType().getKind());
+	            assertTrue("should be executable type for \"" + name + "\".", (accessor.asType() instanceof ExecutableType));
+	            assertNull("should be null", accessor.getDefaultValue());
+	            if (accessor.getSimpleName().toString().equals("c")) {
+	            	assertEquals("annotations count mismatch for \"" + name + "\".", 1, accessor.getAnnotationMirrors().size());
+	            	Set<? extends ExecutableElement> accessorAnnotations = accessor.getAnnotationMirrors().get(0)
+	                        .getElementValues().keySet();
+	            	assertEquals("annotations type element mismatch for \"" + name + "\".", 1, accessorAnnotations.size());
+	            	int val = (int) accessorAnnotations.toArray(new ExecutableElement[0])[0].getDefaultValue()
+	                        .getValue();
+	            	assertEquals("Incorrect default value for \"" + name + "\".", 1, val);
+	            }
+	            assertTrue("Parameters should be empty for \"" + name + "\".", accessor.getParameters().isEmpty());
+	            assertTrue("Thrown types should be empty for \"" + name + "\".", accessor.getThrownTypes().isEmpty());
+	            assertTrue("Type parameters should be empty for \"" + name + "\".", accessor.getTypeParameters().isEmpty());
+	            assertFalse("Should not be default for \"" + name + "\".", accessor.isDefault());
+	            assertFalse("Should not be varargs for \"" + name + "\".", accessor.isVarArgs());
+	        }
+	}
 
 	@Override
 	public void reportError(String msg) {
@@ -524,4 +583,55 @@ public class Java14ElementProcessor extends BaseProcessor {
 			super(msg);
 		}
 	}
+
+	class ScannerImpl<R, P> extends ElementScanner14<R, P> {
+		public Object el;
+		boolean isType;
+		boolean isMethod;
+		public boolean visited;
+		public boolean scanned;
+		R result;
+		public Object param;
+
+		public List<TypeParameterElement> params = new ArrayList<>();
+
+		public ScannerImpl() {
+			super();
+		}
+
+		public ScannerImpl(R r) {
+			super(r);
+		}
+
+		@Override
+		public R visitType(TypeElement e, P p) {
+			el = e;
+			param = p;
+			isType = true;
+			return super.visitType(e, p);
+		}
+
+		@Override
+		public R visitExecutable(ExecutableElement e, P p) {
+			isMethod = true;
+			el = e;
+			param = p;
+			return super.visitExecutable(e, p);
+		}
+
+		public R visitRecordComponent(RecordComponentElement e, P p) {
+			el = e;
+			param = p;
+			visited = true;
+			return super.visitRecordComponent(e, p);
+		}
+
+		public R scan(Element e, P p) {
+			scanned = true;
+			if (e instanceof TypeParameterElement) {
+				params.add((TypeParameterElement) e);
+			}
+			return DEFAULT_VALUE;
+		}
+	}
 }
diff --git a/org.eclipse.jdt.compiler.apt.tests/resources/mod_locations/records/mod.records/records/R3.java b/org.eclipse.jdt.compiler.apt.tests/resources/mod_locations/records/mod.records/records/R3.java
new file mode 100644
index 0000000000..8a586950b5
--- /dev/null
+++ b/org.eclipse.jdt.compiler.apt.tests/resources/mod_locations/records/mod.records/records/R3.java
@@ -0,0 +1,15 @@
+package records;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.math.BigInteger;
+public record R3(int x, BigInteger bigInt, R1 r1, float floatValue, @MyAnn(value=5) Character c, R1 recordInstance){}
+
+record R1(){}
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.RECORD_COMPONENT,ElementType.METHOD})
+@interface MyAnn {
+     int value() default 1;
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.compiler.apt.tests/src/org/eclipse/jdt/compiler/apt/tests/Java14ElementsTests.java b/org.eclipse.jdt.compiler.apt.tests/src/org/eclipse/jdt/compiler/apt/tests/Java14ElementsTests.java
index 4a411b11c9..667882731d 100644
--- a/org.eclipse.jdt.compiler.apt.tests/src/org/eclipse/jdt/compiler/apt/tests/Java14ElementsTests.java
+++ b/org.eclipse.jdt.compiler.apt.tests/src/org/eclipse/jdt/compiler/apt/tests/Java14ElementsTests.java
@@ -46,7 +46,7 @@ public class Java14ElementsTests extends TestCase {
 		JavaCompiler compiler = BatchTestUtils.getEclipseCompiler();
 		internalTestWithPreview(compiler, MODULE_PROC, "14", "testRecords2", null, "records", true);
 	}
-	public void _testRecords2Javac() throws Exception {
+	public void testRecords2Javac() throws Exception {
 		JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
 		internalTestWithPreview(compiler, MODULE_PROC, "14", "testRecords2", null, "records", true);
 	}
@@ -98,6 +98,22 @@ public class Java14ElementsTests extends TestCase {
 		JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
 		internalTestWithPreview(compiler, MODULE_PROC, "14", "testRecords7", null, "records", true);
 	}
+	public void testRecords8() throws IOException {
+		JavaCompiler compiler = BatchTestUtils.getEclipseCompiler();
+		internalTestWithPreview(compiler, MODULE_PROC, "14", "testRecords8", null, "records", true);
+	}
+	public void testRecords8Javac() throws IOException {
+		JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+		internalTestWithPreview(compiler, MODULE_PROC, "14", "testRecords8", null, "records", true);
+	}
+	public void _testRecords9() throws IOException {
+		JavaCompiler compiler = BatchTestUtils.getEclipseCompiler();
+		internalTestWithPreview(compiler, MODULE_PROC, "14", "testRecords9", null, "records", true);
+	}
+	public void testRecords9Javac() throws IOException {
+		JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+		internalTestWithPreview(compiler, MODULE_PROC, "14", "testRecords9", null, "records", true);
+	}
 
 	protected void internalTestWithPreview(JavaCompiler compiler, String processor, String compliance,
 			String testMethod, String testClass, String resourceArea, boolean preview) throws IOException {
diff --git a/org.eclipse.jdt.compiler.apt/lib/java14api.jar b/org.eclipse.jdt.compiler.apt/lib/java14api.jar
index fcf9985dae..e24da08002 100644
--- a/org.eclipse.jdt.compiler.apt/lib/java14api.jar
+++ b/org.eclipse.jdt.compiler.apt/lib/java14api.jar
diff --git a/org.eclipse.jdt.compiler.apt/src/org/eclipse/jdt/internal/compiler/apt/model/RecordComponentElementImpl.java b/org.eclipse.jdt.compiler.apt/src/org/eclipse/jdt/internal/compiler/apt/model/RecordComponentElementImpl.java
index 2ce4c1294b..9be30c625c 100644
--- a/org.eclipse.jdt.compiler.apt/src/org/eclipse/jdt/internal/compiler/apt/model/RecordComponentElementImpl.java
+++ b/org.eclipse.jdt.compiler.apt/src/org/eclipse/jdt/internal/compiler/apt/model/RecordComponentElementImpl.java
@@ -15,6 +15,7 @@
 package org.eclipse.jdt.internal.compiler.apt.model;
 
 import javax.lang.model.element.ElementKind;
+import javax.lang.model.element.ElementVisitor;
 import javax.lang.model.element.ExecutableElement;
 import javax.lang.model.element.RecordComponentElement;
 
@@ -45,4 +46,8 @@ public class RecordComponentElementImpl extends VariableElementImpl implements R
 		}
 		return null;
 	}
+	@Override
+	public <R, P> R accept(ElementVisitor<R, P> visitor, P param) {
+		return visitor.visitRecordComponent(this, param);
+	}
 }
diff --git a/org.eclipse.jdt.compiler.tool.tests/lib/java14api.jar b/org.eclipse.jdt.compiler.tool.tests/lib/java14api.jar
index fcf9985dae..e24da08002 100644
--- a/org.eclipse.jdt.compiler.tool.tests/lib/java14api.jar
+++ b/org.eclipse.jdt.compiler.tool.tests/lib/java14api.jar
diff --git a/org.eclipse.jdt.compiler.tool/lib/java14api.jar b/org.eclipse.jdt.compiler.tool/lib/java14api.jar
index fcf9985dae..e24da08002 100644
--- a/org.eclipse.jdt.compiler.tool/lib/java14api.jar
+++ b/org.eclipse.jdt.compiler.tool/lib/java14api.jar