[Records 2.0] Alternate generation of synthetic component accessors and record override methods. (eclipse-jdt#3954)

Avoid generating duplicate methods in the first
place rather than generate, detect duplication and delete which is
clunky.

* Fixes eclipse-jdt#3901

Author: srikanth-sankaran

org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ClassFile.java

@@ -2345,7 +2345,9 @@ public void completeMethodInfo(
 			AbstractMethodDeclaration methodDeclaration = binding.sourceMethod();
 			if (methodDeclaration != null) {
 				if ((methodDeclaration.bits & ASTNode.HasTypeAnnotations) != 0) {
-					Argument[] arguments = methodDeclaration.arguments;
+					AbstractVariableDeclaration[] arguments = binding.isCompactConstructor() ?
+							getRecordComponents(binding.declaringClass) : methodDeclaration.arguments;
+
 					if (arguments != null) {
 						completeArgumentAnnotationInfo(arguments, allTypeAnnotationContexts);
 					}
@@ -3758,7 +3760,7 @@ private int addBootStrapRecordEntry(int localContentsOffset, TypeDeclaration typ
 
 		assert type instanceof SourceTypeBinding;
 		SourceTypeBinding sourceType = (SourceTypeBinding) type;
-		FieldBinding[] recordComponents = sourceType.getImplicitComponentFields();
+		RecordComponentBinding[] recordComponents = sourceType.components();
 
 		int numArgs = 2 + recordComponents.length;
 		this.contents[numArgsLocation++] = (byte) (numArgs >> 8);
@@ -3776,10 +3778,10 @@ private int addBootStrapRecordEntry(int localContentsOffset, TypeDeclaration typ
 		if (recordComponents.length * 2 + localContentsOffset >= this.contents.length) {
 			resizeContents(recordComponents.length * 2);
 		}
-		for (FieldBinding field : recordComponents) {
+		for (RecordComponentBinding component : recordComponents) {
 			int methodHandleIndex = this.constantPool.literalIndexForMethodHandleFieldRef(
 					ClassFileConstants.MethodHandleRefKindGetField,
-					recordName, field.name, field.type.signature());
+					recordName, component.name, component.type.signature());
 
 			this.contents[localContentsOffset++] = (byte) (methodHandleIndex >> 8);
 			this.contents[localContentsOffset++] = (byte) methodHandleIndex;

org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/ConstructorDeclaration.java

@@ -701,11 +701,30 @@ public void resolveJavadoc() {
 @Override
 public void resolve(ClassScope upperScope) {
 
-	if (this.isCompactConstructor() && !upperScope.referenceContext.isRecord()) {
-		upperScope.problemReporter().compactConstructorsOnlyInRecords(this);
-		return;
+	if (this.binding != null && this.binding.isCanonicalConstructor()) {
+		RecordComponentBinding[] rcbs = upperScope.referenceContext.binding.components();
+		for (int i = 0; i < rcbs.length; ++i) {
+			TypeBinding mpt = this.binding.parameters[i];
+			TypeBinding rct = rcbs[i].type;
+			if (TypeBinding.notEquals(mpt, rct))
+				upperScope.problemReporter().recordErasureIncompatibilityInCanonicalConstructor(this.arguments[i].type);
+		}
+
+		if (!this.binding.isAsVisible(this.binding.declaringClass))
+			this.scope.problemReporter().recordCanonicalConstructorVisibilityReduced(this);
+		if (this.typeParameters != null && this.typeParameters.length > 0)
+			this.scope.problemReporter().recordCanonicalConstructorShouldNotBeGeneric(this);
+		if (this.binding.thrownExceptions != null && this.binding.thrownExceptions.length > 0)
+			this.scope.problemReporter().recordCanonicalConstructorHasThrowsClause(this);
+		if (this.isCompactConstructor()) {
+			if (!upperScope.referenceContext.isRecord())
+				upperScope.problemReporter().compactConstructorsOnlyInRecords(this);
+		} else {
+			for (int i = 0; i < rcbs.length; i++)
+				if (!CharOperation.equals(this.arguments[i].name, rcbs[i].name))
+					this.scope.problemReporter().recordIllegalParameterNameInCanonicalConstructor(rcbs[i], this.arguments[i]);
+		}
 	}
-
 	super.resolve(upperScope);
 }
 /*

org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/ast/RecordComponent.java

@@ -16,17 +16,11 @@
 import java.util.List;
 import org.eclipse.jdt.internal.compiler.ASTVisitor;
 import org.eclipse.jdt.internal.compiler.ast.TypeReference.AnnotationCollector;
-import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
 import org.eclipse.jdt.internal.compiler.codegen.AnnotationContext;
 import org.eclipse.jdt.internal.compiler.codegen.CodeStream;
-import org.eclipse.jdt.internal.compiler.flow.FlowContext;
-import org.eclipse.jdt.internal.compiler.flow.FlowInfo;
 import org.eclipse.jdt.internal.compiler.lookup.Binding;
 import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
-import org.eclipse.jdt.internal.compiler.lookup.ExtraCompilerModifiers;
-import org.eclipse.jdt.internal.compiler.lookup.MethodBinding;
 import org.eclipse.jdt.internal.compiler.lookup.RecordComponentBinding;
-import org.eclipse.jdt.internal.compiler.lookup.SyntheticMethodBinding;
 import org.eclipse.jdt.internal.compiler.lookup.TagBits;
 import org.eclipse.jdt.internal.compiler.lookup.TypeBinding;
 
@@ -39,6 +33,7 @@ public RecordComponent(
 		int sourceStart,
 		int sourceEnd) {
 
+
 		this.name = name;
 		this.sourceStart = sourceStart;
 		this.sourceEnd = sourceEnd;
@@ -54,28 +49,11 @@ public RecordComponent(char[] name, long posNom, TypeReference tr, int modifiers
 		}
 	}
 
-	@Override
-	public FlowInfo analyseCode(BlockScope currentScope, FlowContext flowContext, FlowInfo flowInfo) {
-		//TODO: Add error checking if relevant.
-		return flowInfo;
-	}
-
-	public void checkModifiers() {
-
-		//only potential valid modifier is <<final>>
-		if (((this.modifiers & ExtraCompilerModifiers.AccJustFlag) & ~ClassFileConstants.AccFinal) != 0)
-			//AccModifierProblem -> other (non-visibility problem)
-			//AccAlternateModifierProblem -> duplicate modifier
-			//AccModifierProblem | AccAlternateModifierProblem -> visibility problem"
-
-			this.modifiers = (this.modifiers & ~ExtraCompilerModifiers.AccAlternateModifierProblem) | ExtraCompilerModifiers.AccModifierProblem;
-	}
-
 	@Override
 	public void generateCode(BlockScope currentScope, CodeStream codeStream) {
 
 		if ((this.bits & IsReachable) == 0) {
-			return; // TODO: can this ever happen?
+			return;
 		}
 		codeStream.recordPositionsFrom(codeStream.position, this.sourceStart);
 	}
@@ -117,18 +95,6 @@ public void resolve(BlockScope scope) {
 				TypeBinding resolvedAnnotationType = annotation.resolvedType;
 				if (resolvedAnnotationType != null && (resolvedAnnotationType.getAnnotationTagBits() & TagBits.AnnotationForTypeUse) != 0) {
 					this.bits |= ASTNode.HasTypeAnnotations;
-					// also update the accessor's return type:
-					if (this.binding != null && this.binding.declaringRecord != null) {
-						for (MethodBinding methodBinding : this.binding.declaringRecord.methods()) {
-							if (methodBinding instanceof SyntheticMethodBinding) {
-								SyntheticMethodBinding smb = (SyntheticMethodBinding) methodBinding;
-								if (smb.purpose == SyntheticMethodBinding.FieldReadAccess && smb.recordComponentBinding == this.binding) {
-									smb.returnType = this.binding.type;
-									break;
-								}
-							}
-						}
-					}
 					break;
 				}
 			}

org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/codegen/CodeStream.java

@@ -1334,8 +1334,8 @@ public void fdiv() {
 	this.bCodeStream[this.classFileOffset++] = Opcodes.OPC_fdiv;
 }
 
-public void fieldAccess(byte opcode, FieldBinding fieldBinding, TypeBinding declaringClass) {
-	if (declaringClass == null) declaringClass = fieldBinding.declaringClass;
+public void fieldAccess(byte opcode, VariableBinding fieldBinding, TypeBinding declaringClass) {
+	if (declaringClass == null) declaringClass = fieldBinding.getDeclaringClass();
 	if ((declaringClass.tagBits & TagBits.ContainsNestedTypeReferences) != 0) {
 		Util.recordNestedType(this.classFile, declaringClass);
 	}
@@ -2862,7 +2862,7 @@ public void generateSyntheticBodyForEnumInitializationMethod(SyntheticMethodBind
 	return_();
 }
 public void generateSyntheticBodyForFieldReadAccess(SyntheticMethodBinding accessMethod) {
-	FieldBinding fieldBinding = accessMethod.targetReadField;
+	VariableBinding fieldBinding = accessMethod.targetReadField;
 	// target method declaring class may not be accessible (247953);
 	TypeBinding declaringClass = accessMethod.purpose == SyntheticMethodBinding.SuperFieldReadAccess
 			? accessMethod.declaringClass.superclass()
@@ -3025,7 +3025,7 @@ ReferenceBinding findDirectSuperTypeTowards(SyntheticMethodBinding accessMethod,
 public void generateSyntheticBodyForSwitchTable(SyntheticMethodBinding methodBinding) {
 	ClassScope scope = ((SourceTypeBinding)methodBinding.declaringClass).scope;
 	final BranchLabel nullLabel = new BranchLabel(this);
-	FieldBinding syntheticFieldBinding = methodBinding.targetReadField;
+	VariableBinding syntheticFieldBinding = methodBinding.targetReadField;
 	fieldAccess(Opcodes.OPC_getstatic, syntheticFieldBinding, null /* default declaringClass */);
 	dup();
 	ifnull(nullLabel);
@@ -3152,11 +3152,11 @@ public void generateSyntheticBodyForRecordCanonicalConstructor(SyntheticMethodBi
 	aload_0();
 	invoke(Opcodes.OPC_invokespecial, superCons, superClass);
 	int resolvedPosition;
-	FieldBinding[] fields =  declaringClass.getImplicitComponentFields();
+	VariableBinding[] fields =  declaringClass.components();
 	int len = fields != null ? fields.length : 0;
 	resolvedPosition = 1;
 	for (int i = 0;  i < len; ++i) {
-		FieldBinding field = fields[i];
+		VariableBinding field = fields[i];
 		aload_0();
 	    TypeBinding type = field.type;
 		load(type, resolvedPosition);

org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/ClassScope.java

@@ -487,10 +487,6 @@ void buildMethods() {
 			if (hasAbstractMethods)
 				problemReporter().abstractMethodInConcreteClass(sourceType);
 		}
-		if (sourceType.isRecord()) {
-			methodBindings = sourceType.checkAndAddSyntheticRecordMethods(methodBindings, count);
-			count = methodBindings.length;
-		}
 		if (count != methodBindings.length)
 			System.arraycopy(methodBindings, 0, methodBindings = new MethodBinding[count], 0, count);
 		sourceType.tagBits &= ~(TagBits.AreMethodsSorted|TagBits.AreMethodsComplete); // in case some static imports reached already into this type

org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/FieldBinding.java

@@ -332,15 +332,19 @@ public long getAnnotationTagBits() {
 	return originalField.tagBits;
 }
 
-public final boolean isDefault() {
-	return !isPublic() && !isProtected() && !isPrivate();
+@Override
+public ReferenceBinding getDeclaringClass() {
+	return this.declaringClass;
 }
-/* Answer true if the receiver is a deprecated field
-*/
 
 /* Answer true if the receiver has default visibility
 */
+public final boolean isDefault() {
+	return !isPublic() && !isProtected() && !isPrivate();
+}
 
+/* Answer true if the receiver is a deprecated field
+*/
 public final boolean isDeprecated() {
 	return (this.modifiers & ClassFileConstants.AccDeprecated) != 0;
 }
@@ -370,12 +374,7 @@ public final boolean isProtected() {
 public final boolean isPublic() {
 	return (this.modifiers & ClassFileConstants.AccPublic) != 0;
 }
-/* Answer true if the receiver is a static field
-*/
 
-public final boolean isStatic() {
-	return (this.modifiers & ClassFileConstants.AccStatic) != 0;
-}
 /* Answer true if the receiver is not defined in the source of the declaringClass
 */
 

org.eclipse.jdt.core.compiler.batch/src/org/eclipse/jdt/internal/compiler/lookup/RecordComponentBinding.java

@@ -98,6 +98,11 @@ public long getAnnotationTagBits() {
 		return originalRecordComponentBinding.tagBits;
 	}
 
+	@Override
+	public ReferenceBinding getDeclaringClass() {
+		return this.declaringRecord;
+	}
+
 	public final boolean isDeprecated() {
 		return (this.modifiers & ClassFileConstants.AccDeprecated) != 0;
 	}