From 04a3e0273bcf79830c52493ba8330dc1558ee700 Mon Sep 17 00:00:00 2001 From: Pavel Vojtechovsky Date: Mon, 8 Oct 2018 22:02:40 +0200 Subject: [PATCH] refactor: return types of Spoon model methods --- .../reflect/code/BinaryOperatorKind.java | 3 + .../reflect/code/CtAbstractInvocation.java | 17 ++- .../reflect/code/CtAnnotationFieldAccess.java | 6 +- .../spoon/reflect/code/CtArrayAccess.java | 6 +- .../java/spoon/reflect/code/CtArrayRead.java | 3 + .../java/spoon/reflect/code/CtArrayWrite.java | 3 + .../java/spoon/reflect/code/CtAssert.java | 8 +- .../java/spoon/reflect/code/CtAssignment.java | 6 +- .../spoon/reflect/code/CtBinaryOperator.java | 12 +- src/main/java/spoon/reflect/code/CtBlock.java | 4 + .../java/spoon/reflect/code/CtBodyHolder.java | 8 +- src/main/java/spoon/reflect/code/CtBreak.java | 3 + .../java/spoon/reflect/code/CtCFlowBreak.java | 3 + src/main/java/spoon/reflect/code/CtCase.java | 6 +- src/main/java/spoon/reflect/code/CtCatch.java | 6 +- .../spoon/reflect/code/CtCatchVariable.java | 9 +- .../spoon/reflect/code/CtCodeElement.java | 4 + .../reflect/code/CtCodeSnippetExpression.java | 4 + .../reflect/code/CtCodeSnippetStatement.java | 4 + .../java/spoon/reflect/code/CtComment.java | 12 +- .../spoon/reflect/code/CtConditional.java | 10 +- .../spoon/reflect/code/CtConstructorCall.java | 15 +- .../java/spoon/reflect/code/CtContinue.java | 3 + src/main/java/spoon/reflect/code/CtDo.java | 6 +- .../code/CtExecutableReferenceExpression.java | 8 +- .../java/spoon/reflect/code/CtExpression.java | 15 +- .../spoon/reflect/code/CtFieldAccess.java | 6 +- .../java/spoon/reflect/code/CtFieldRead.java | 3 + .../java/spoon/reflect/code/CtFieldWrite.java | 3 + src/main/java/spoon/reflect/code/CtFor.java | 17 ++- .../java/spoon/reflect/code/CtForEach.java | 8 +- src/main/java/spoon/reflect/code/CtIf.java | 10 +- .../java/spoon/reflect/code/CtInvocation.java | 15 +- .../java/spoon/reflect/code/CtJavaDoc.java | 19 ++- .../java/spoon/reflect/code/CtJavaDocTag.java | 16 +- .../reflect/code/CtLabelledFlowBreak.java | 6 +- .../java/spoon/reflect/code/CtLambda.java | 15 +- .../java/spoon/reflect/code/CtLiteral.java | 6 +- .../spoon/reflect/code/CtLocalVariable.java | 8 +- src/main/java/spoon/reflect/code/CtLoop.java | 4 + .../java/spoon/reflect/code/CtNewArray.java | 15 +- .../java/spoon/reflect/code/CtNewClass.java | 19 ++- .../reflect/code/CtOperatorAssignment.java | 6 +- .../spoon/reflect/code/CtRHSReceiver.java | 8 +- .../java/spoon/reflect/code/CtReturn.java | 11 +- .../java/spoon/reflect/code/CtStatement.java | 16 +- .../spoon/reflect/code/CtStatementList.java | 29 ++-- .../spoon/reflect/code/CtSuperAccess.java | 4 + .../java/spoon/reflect/code/CtSwitch.java | 13 +- .../spoon/reflect/code/CtSynchronized.java | 8 +- .../reflect/code/CtTargetedExpression.java | 4 + .../java/spoon/reflect/code/CtThisAccess.java | 3 + src/main/java/spoon/reflect/code/CtThrow.java | 6 +- src/main/java/spoon/reflect/code/CtTry.java | 13 +- .../spoon/reflect/code/CtTryWithResource.java | 11 +- .../java/spoon/reflect/code/CtTypeAccess.java | 9 +- .../spoon/reflect/code/CtUnaryOperator.java | 8 +- .../spoon/reflect/code/CtVariableAccess.java | 10 +- .../spoon/reflect/code/CtVariableRead.java | 3 + .../spoon/reflect/code/CtVariableWrite.java | 3 + src/main/java/spoon/reflect/code/CtWhile.java | 6 +- .../spoon/reflect/code/UnaryOperatorKind.java | 3 + .../declaration/CtAnnotatedElementType.java | 3 + .../reflect/declaration/CtAnnotation.java | 37 ++--- .../declaration/CtAnnotationMethod.java | 24 +-- .../reflect/declaration/CtAnnotationType.java | 19 ++- .../declaration/CtAnonymousExecutable.java | 19 ++- .../spoon/reflect/declaration/CtClass.java | 25 ++-- .../reflect/declaration/CtCodeSnippet.java | 6 +- .../reflect/declaration/CtConstructor.java | 10 +- .../spoon/reflect/declaration/CtElement.java | 48 +++--- .../spoon/reflect/declaration/CtEnum.java | 17 ++- .../reflect/declaration/CtEnumValue.java | 7 +- .../reflect/declaration/CtExecutable.java | 21 +-- .../spoon/reflect/declaration/CtField.java | 6 +- .../declaration/CtFormalTypeDeclarer.java | 11 +- .../spoon/reflect/declaration/CtImport.java | 6 +- .../reflect/declaration/CtImportKind.java | 3 + .../reflect/declaration/CtInterface.java | 6 +- .../spoon/reflect/declaration/CtMethod.java | 9 +- .../reflect/declaration/CtModifiable.java | 17 ++- .../spoon/reflect/declaration/CtModule.java | 49 +++--- .../declaration/CtModuleDirective.java | 3 + .../declaration/CtModuleRequirement.java | 9 +- .../declaration/CtMultiTypedElement.java | 13 +- .../reflect/declaration/CtNamedElement.java | 10 +- .../spoon/reflect/declaration/CtPackage.java | 21 +-- .../reflect/declaration/CtPackageExport.java | 18 ++- .../reflect/declaration/CtParameter.java | 12 +- .../declaration/CtProvidedService.java | 16 +- .../reflect/declaration/CtShadowable.java | 8 +- .../spoon/reflect/declaration/CtType.java | 41 +++--- .../declaration/CtTypeInformation.java | 11 +- .../reflect/declaration/CtTypeMember.java | 4 + .../reflect/declaration/CtTypeParameter.java | 29 ++-- .../reflect/declaration/CtTypedElement.java | 8 +- .../reflect/declaration/CtUsedService.java | 6 +- .../spoon/reflect/declaration/CtVariable.java | 10 +- .../reflect/declaration/ModifierKind.java | 6 + .../ParentNotInitializedException.java | 4 + .../reference/CtActualTypeContainer.java | 9 +- .../reference/CtArrayTypeReference.java | 10 +- .../reference/CtCatchVariableReference.java | 4 + .../reference/CtExecutableReference.java | 17 ++- .../reflect/reference/CtFieldReference.java | 11 +- .../CtIntersectionTypeReference.java | 11 +- .../reference/CtLocalVariableReference.java | 4 + .../reflect/reference/CtModuleReference.java | 4 + .../reflect/reference/CtPackageReference.java | 4 + .../reference/CtParameterReference.java | 4 + .../spoon/reflect/reference/CtReference.java | 9 +- .../reference/CtTypeParameterReference.java | 7 +- .../reflect/reference/CtTypeReference.java | 9 +- .../reference/CtUnboundVariableReference.java | 10 +- .../reference/CtVariableReference.java | 7 +- .../reference/CtWildcardReference.java | 10 +- .../code/CtAnnotationFieldAccessImpl.java | 4 + .../reflect/code/CtArrayAccessImpl.java | 8 +- .../support/reflect/code/CtArrayReadImpl.java | 4 + .../reflect/code/CtArrayWriteImpl.java | 4 + .../support/reflect/code/CtAssertImpl.java | 12 +- .../reflect/code/CtAssignmentImpl.java | 35 ++--- .../reflect/code/CtBinaryOperatorImpl.java | 16 +- .../support/reflect/code/CtBlockImpl.java | 58 ++++---- .../support/reflect/code/CtBreakImpl.java | 12 +- .../support/reflect/code/CtCaseImpl.java | 61 ++++---- .../support/reflect/code/CtCatchImpl.java | 13 +- .../reflect/code/CtCatchVariableImpl.java | 60 ++++---- .../reflect/code/CtCodeElementImpl.java | 4 + .../code/CtCodeSnippetExpressionImpl.java | 9 +- .../code/CtCodeSnippetStatementImpl.java | 9 +- .../support/reflect/code/CtCommentImpl.java | 17 ++- .../reflect/code/CtConditionalImpl.java | 16 +- .../reflect/code/CtConstructorCallImpl.java | 64 ++++---- .../support/reflect/code/CtContinueImpl.java | 12 +- .../spoon/support/reflect/code/CtDoImpl.java | 8 +- .../CtExecutableReferenceExpressionImpl.java | 8 +- .../reflect/code/CtExpressionImpl.java | 26 ++-- .../reflect/code/CtFieldAccessImpl.java | 4 + .../support/reflect/code/CtFieldReadImpl.java | 4 + .../reflect/code/CtFieldWriteImpl.java | 4 + .../support/reflect/code/CtForEachImpl.java | 12 +- .../spoon/support/reflect/code/CtForImpl.java | 37 ++--- .../spoon/support/reflect/code/CtIfImpl.java | 21 +-- .../reflect/code/CtInvocationImpl.java | 64 ++++---- .../support/reflect/code/CtJavaDocImpl.java | 28 ++-- .../reflect/code/CtJavaDocTagImpl.java | 23 +-- .../support/reflect/code/CtLambdaImpl.java | 50 ++++--- .../support/reflect/code/CtLiteralImpl.java | 8 +- .../reflect/code/CtLocalVariableImpl.java | 50 +++---- .../support/reflect/code/CtLoopImpl.java | 14 +- .../support/reflect/code/CtNewArrayImpl.java | 33 +++-- .../support/reflect/code/CtNewClassImpl.java | 8 +- .../code/CtOperatorAssignmentImpl.java | 8 +- .../support/reflect/code/CtReturnImpl.java | 13 +- .../support/reflect/code/CtStatementImpl.java | 29 ++-- .../reflect/code/CtStatementListImpl.java | 68 ++++----- .../reflect/code/CtSuperAccessImpl.java | 4 + .../support/reflect/code/CtSwitchImpl.java | 25 ++-- .../reflect/code/CtSynchronizedImpl.java | 12 +- .../code/CtTargetedExpressionImpl.java | 4 + .../reflect/code/CtThisAccessImpl.java | 4 + .../support/reflect/code/CtThrowImpl.java | 13 +- .../spoon/support/reflect/code/CtTryImpl.java | 35 ++--- .../reflect/code/CtTryWithResourceImpl.java | 21 +-- .../reflect/code/CtTypeAccessImpl.java | 14 +- .../reflect/code/CtUnaryOperatorImpl.java | 32 ++-- .../reflect/code/CtVariableAccessImpl.java | 13 +- .../reflect/code/CtVariableReadImpl.java | 4 + .../reflect/code/CtVariableWriteImpl.java | 4 + .../support/reflect/code/CtWhileImpl.java | 8 +- .../reflect/declaration/CtAnnotationImpl.java | 90 ++++++------ .../declaration/CtAnnotationMethodImpl.java | 30 ++-- .../declaration/CtAnnotationTypeImpl.java | 31 ++-- .../CtAnonymousExecutableImpl.java | 48 +++--- .../reflect/declaration/CtClassImpl.java | 73 ++++----- .../declaration/CtConstructorImpl.java | 60 ++++---- .../reflect/declaration/CtElementImpl.java | 87 +++++------ .../reflect/declaration/CtEnumImpl.java | 38 ++--- .../reflect/declaration/CtEnumValueImpl.java | 4 + .../reflect/declaration/CtExecutableImpl.java | 42 +++--- .../reflect/declaration/CtFieldImpl.java | 46 +++--- .../reflect/declaration/CtImportImpl.java | 12 +- .../reflect/declaration/CtInterfaceImpl.java | 18 ++- .../reflect/declaration/CtMethodImpl.java | 60 ++++---- .../reflect/declaration/CtModuleImpl.java | 133 +++++++++-------- .../declaration/CtModuleRequirementImpl.java | 17 ++- .../declaration/CtNamedElementImpl.java | 10 +- .../declaration/CtPackageExportImpl.java | 29 ++-- .../reflect/declaration/CtPackageImpl.java | 27 ++-- .../reflect/declaration/CtParameterImpl.java | 45 +++--- .../declaration/CtProvidedServiceImpl.java | 25 ++-- .../reflect/declaration/CtTypeImpl.java | 139 +++++++++--------- .../declaration/CtTypeParameterImpl.java | 83 ++++++----- .../declaration/CtUsedServiceImpl.java | 8 +- .../InvisibleArrayConstructorImpl.java | 11 +- .../reference/CtArrayTypeReferenceImpl.java | 20 +-- .../CtCatchVariableReferenceImpl.java | 4 + .../reference/CtExecutableReferenceImpl.java | 63 ++++---- .../reference/CtFieldReferenceImpl.java | 25 ++-- .../CtIntersectionTypeReferenceImpl.java | 24 +-- .../CtLocalVariableReferenceImpl.java | 5 + .../reference/CtModuleReferenceImpl.java | 5 +- .../reference/CtPackageReferenceImpl.java | 5 +- .../reference/CtParameterReferenceImpl.java | 5 +- .../reflect/reference/CtReferenceImpl.java | 24 +-- .../CtTypeParameterReferenceImpl.java | 19 ++- .../reference/CtTypeReferenceImpl.java | 47 +++--- .../CtUnboundVariableReferenceImpl.java | 11 +- .../reference/CtVariableReferenceImpl.java | 15 +- .../reference/CtWildcardReferenceImpl.java | 21 +-- ...WildcardStaticTypeMemberReferenceImpl.java | 7 +- 212 files changed, 2248 insertions(+), 1579 deletions(-) diff --git a/src/main/java/spoon/reflect/code/BinaryOperatorKind.java b/src/main/java/spoon/reflect/code/BinaryOperatorKind.java index 23675fcb735..f5ea28decd4 100644 --- a/src/main/java/spoon/reflect/code/BinaryOperatorKind.java +++ b/src/main/java/spoon/reflect/code/BinaryOperatorKind.java @@ -16,6 +16,9 @@ */ package spoon.reflect.code; + + + /** * This enumeration defines all the kinds of binary operators. */ diff --git a/src/main/java/spoon/reflect/code/CtAbstractInvocation.java b/src/main/java/spoon/reflect/code/CtAbstractInvocation.java index 89a2eb5b049..2b1711449f9 100644 --- a/src/main/java/spoon/reflect/code/CtAbstractInvocation.java +++ b/src/main/java/spoon/reflect/code/CtAbstractInvocation.java @@ -16,16 +16,19 @@ */ package spoon.reflect.code; -import spoon.reflect.declaration.CtElement; -import spoon.reflect.reference.CtExecutableReference; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; import java.util.List; +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; +import spoon.reflect.declaration.CtElement; +import spoon.reflect.reference.CtExecutableReference; import static spoon.reflect.path.CtRole.ARGUMENT; import static spoon.reflect.path.CtRole.EXECUTABLE_REF; + + + /** * This code element defines an abstract invocation on a * {@link spoon.reflect.declaration.CtExecutable}. @@ -46,7 +49,7 @@ public interface CtAbstractInvocation extends CtElement { * Adds an argument expression to the invocation. */ @PropertySetter(role = ARGUMENT) - > C addArgument(CtExpression argument); + CtAbstractInvocation addArgument(CtExpression argument); /** * Removes an argument expression from the invocation. @@ -58,7 +61,7 @@ public interface CtAbstractInvocation extends CtElement { * Sets the invocation's arguments. */ @PropertySetter(role = ARGUMENT) - > C setArguments(List> arguments); + CtAbstractInvocation setArguments(List> arguments); /** * Returns the invoked executable. @@ -70,5 +73,5 @@ public interface CtAbstractInvocation extends CtElement { * Sets the invoked executable. */ @PropertySetter(role = EXECUTABLE_REF) - > C setExecutable(CtExecutableReference executable); + CtAbstractInvocation setExecutable(CtExecutableReference executable); } diff --git a/src/main/java/spoon/reflect/code/CtAnnotationFieldAccess.java b/src/main/java/spoon/reflect/code/CtAnnotationFieldAccess.java index 867b79dd7ed..e65b99dc246 100644 --- a/src/main/java/spoon/reflect/code/CtAnnotationFieldAccess.java +++ b/src/main/java/spoon/reflect/code/CtAnnotationFieldAccess.java @@ -16,11 +16,15 @@ */ package spoon.reflect.code; -import spoon.reflect.reference.CtFieldReference; + import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.reference.CtFieldReference; import static spoon.reflect.path.CtRole.VARIABLE; + + + /** * This code element defines an access to a annotation parameter variable. * diff --git a/src/main/java/spoon/reflect/code/CtArrayAccess.java b/src/main/java/spoon/reflect/code/CtArrayAccess.java index a53a9c8805c..40098b216ee 100644 --- a/src/main/java/spoon/reflect/code/CtArrayAccess.java +++ b/src/main/java/spoon/reflect/code/CtArrayAccess.java @@ -16,11 +16,15 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import static spoon.reflect.path.CtRole.EXPRESSION; + + + /** * This code element defines a one-dimensional array access. When * multi-dimensional, array accesses are applied to other one-dimensional array @@ -37,7 +41,7 @@ public interface CtArrayAccess> extends CtTargetedE * Sets the expression that defines the index. */ @PropertySetter(role = EXPRESSION) - > C setIndexExpression(CtExpression expression); + CtArrayAccess setIndexExpression(CtExpression expression); /** * Returns the expression that defines the index. diff --git a/src/main/java/spoon/reflect/code/CtArrayRead.java b/src/main/java/spoon/reflect/code/CtArrayRead.java index d0b51c9f4f9..37a3e3a838c 100644 --- a/src/main/java/spoon/reflect/code/CtArrayRead.java +++ b/src/main/java/spoon/reflect/code/CtArrayRead.java @@ -16,6 +16,9 @@ */ package spoon.reflect.code; + + + /** * This code element defines a read access to an array. * diff --git a/src/main/java/spoon/reflect/code/CtArrayWrite.java b/src/main/java/spoon/reflect/code/CtArrayWrite.java index efdb46c25ac..52b305ae188 100644 --- a/src/main/java/spoon/reflect/code/CtArrayWrite.java +++ b/src/main/java/spoon/reflect/code/CtArrayWrite.java @@ -16,6 +16,9 @@ */ package spoon.reflect.code; + + + /** * This code element defines a write access to an array. * diff --git a/src/main/java/spoon/reflect/code/CtAssert.java b/src/main/java/spoon/reflect/code/CtAssert.java index c32161e50f5..418847b4240 100644 --- a/src/main/java/spoon/reflect/code/CtAssert.java +++ b/src/main/java/spoon/reflect/code/CtAssert.java @@ -16,6 +16,7 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; @@ -23,6 +24,9 @@ import static spoon.reflect.path.CtRole.EXPRESSION; + + + /** * This code element defines an assert clause. * Example: 
assert 1+1==2
@@ -38,7 +42,7 @@ public interface CtAssert extends CtStatement { * Sets the assert expression. */ @PropertySetter(role = CONDITION) - > A setAssertExpression(CtExpression asserted); + CtAssert setAssertExpression(CtExpression asserted); /** * Gets the expression of the assertion if defined. @@ -50,7 +54,7 @@ public interface CtAssert extends CtStatement { * Sets the expression of the assertion. */ @PropertySetter(role = EXPRESSION) - > A setExpression(CtExpression expression); + CtAssert setExpression(CtExpression expression); @Override CtAssert clone(); diff --git a/src/main/java/spoon/reflect/code/CtAssignment.java b/src/main/java/spoon/reflect/code/CtAssignment.java index 58824f20e5f..4b902afae43 100644 --- a/src/main/java/spoon/reflect/code/CtAssignment.java +++ b/src/main/java/spoon/reflect/code/CtAssignment.java @@ -16,12 +16,16 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import static spoon.reflect.path.CtRole.ASSIGNED; + + + /** * This code element defines an assignment. * @@ -47,7 +51,7 @@ public interface CtAssignment extends CtStatement, CtExpression< * Sets the assigned expression (left hand side - LHS). */ @PropertySetter(role = ASSIGNED) - > C setAssigned(CtExpression assigned); + CtAssignment setAssigned(CtExpression assigned); @Override CtAssignment clone(); diff --git a/src/main/java/spoon/reflect/code/CtBinaryOperator.java b/src/main/java/spoon/reflect/code/CtBinaryOperator.java index a89c3ec8088..1f323a8d807 100644 --- a/src/main/java/spoon/reflect/code/CtBinaryOperator.java +++ b/src/main/java/spoon/reflect/code/CtBinaryOperator.java @@ -16,13 +16,17 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; -import static spoon.reflect.path.CtRole.OPERATOR_KIND; import static spoon.reflect.path.CtRole.LEFT_OPERAND; +import static spoon.reflect.path.CtRole.OPERATOR_KIND; import static spoon.reflect.path.CtRole.RIGHT_OPERAND; + + + /** * This interface defines a binary operator. * @@ -52,19 +56,19 @@ public interface CtBinaryOperator extends CtExpression { * Sets the left-hand operand. */ @PropertySetter(role = LEFT_OPERAND) - > C setLeftHandOperand(CtExpression expression); + CtBinaryOperator setLeftHandOperand(CtExpression expression); /** * Sets the right-hand operand. */ @PropertySetter(role = RIGHT_OPERAND) - > C setRightHandOperand(CtExpression expression); + CtBinaryOperator setRightHandOperand(CtExpression expression); /** * Sets the kind of this binary operator. */ @PropertySetter(role = OPERATOR_KIND) - > C setKind(BinaryOperatorKind kind); + CtBinaryOperator setKind(BinaryOperatorKind kind); /** * Gets the kind of this binary operator. diff --git a/src/main/java/spoon/reflect/code/CtBlock.java b/src/main/java/spoon/reflect/code/CtBlock.java index 523551c156b..cb195b39485 100644 --- a/src/main/java/spoon/reflect/code/CtBlock.java +++ b/src/main/java/spoon/reflect/code/CtBlock.java @@ -16,8 +16,12 @@ */ package spoon.reflect.code; + import spoon.template.TemplateParameter; + + + /** * This code element represents a block of code, that is to say a list of * statements enclosed in curly brackets. diff --git a/src/main/java/spoon/reflect/code/CtBodyHolder.java b/src/main/java/spoon/reflect/code/CtBodyHolder.java index c1a55cd6976..c921dba1a76 100644 --- a/src/main/java/spoon/reflect/code/CtBodyHolder.java +++ b/src/main/java/spoon/reflect/code/CtBodyHolder.java @@ -16,12 +16,16 @@ */ package spoon.reflect.code; -import spoon.reflect.declaration.CtElement; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; +import spoon.reflect.declaration.CtElement; import static spoon.reflect.path.CtRole.BODY; + + + /** * This abstract code element defines an element, which contains a body */ @@ -38,5 +42,5 @@ public interface CtBodyHolder extends CtElement { * If body is not a block, it is wrapped in a CtBlock which is semantically equivalent and eases transformation afterwards if required. */ @PropertySetter(role = BODY) - T setBody(CtStatement body); + CtBodyHolder setBody(CtStatement body); } diff --git a/src/main/java/spoon/reflect/code/CtBreak.java b/src/main/java/spoon/reflect/code/CtBreak.java index 35dcee225de..eaa0fb11050 100644 --- a/src/main/java/spoon/reflect/code/CtBreak.java +++ b/src/main/java/spoon/reflect/code/CtBreak.java @@ -16,6 +16,9 @@ */ package spoon.reflect.code; + + + /** * This code element defines a break statement. * Example: diff --git a/src/main/java/spoon/reflect/code/CtCFlowBreak.java b/src/main/java/spoon/reflect/code/CtCFlowBreak.java index 6b4fcf53ad8..f5934c8c376 100644 --- a/src/main/java/spoon/reflect/code/CtCFlowBreak.java +++ b/src/main/java/spoon/reflect/code/CtCFlowBreak.java @@ -16,6 +16,9 @@ */ package spoon.reflect.code; + + + /** * This abstract code element represents all the statements that break the * control flow of the program. diff --git a/src/main/java/spoon/reflect/code/CtCase.java b/src/main/java/spoon/reflect/code/CtCase.java index e22e4e73c23..fb06325d4b1 100644 --- a/src/main/java/spoon/reflect/code/CtCase.java +++ b/src/main/java/spoon/reflect/code/CtCase.java @@ -16,11 +16,15 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import static spoon.reflect.path.CtRole.EXPRESSION; + + + /** * This code element defines a case within a switch-case. * @@ -46,7 +50,7 @@ public interface CtCase extends CtStatement, CtStatementList { * Sets the case expression. */ @PropertySetter(role = EXPRESSION) - > T setCaseExpression(CtExpression caseExpression); + CtCase setCaseExpression(CtExpression caseExpression); @Override CtCase clone(); diff --git a/src/main/java/spoon/reflect/code/CtCatch.java b/src/main/java/spoon/reflect/code/CtCatch.java index 3edebef1fa5..6fb29369d74 100644 --- a/src/main/java/spoon/reflect/code/CtCatch.java +++ b/src/main/java/spoon/reflect/code/CtCatch.java @@ -16,6 +16,7 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; @@ -23,6 +24,9 @@ import static spoon.reflect.path.CtRole.PARAMETER; + + + /** * This code element defines a catch of a try. * @@ -40,7 +44,7 @@ public interface CtCatch extends CtCodeElement, CtBodyHolder { * Sets the catch's parameter (a throwable). */ @PropertySetter(role = PARAMETER) - T setParameter(CtCatchVariable parameter); + CtCatch setParameter(CtCatchVariable parameter); /** * Gets the catch's body. diff --git a/src/main/java/spoon/reflect/code/CtCatchVariable.java b/src/main/java/spoon/reflect/code/CtCatchVariable.java index 2a1ff802239..23bf7301873 100644 --- a/src/main/java/spoon/reflect/code/CtCatchVariable.java +++ b/src/main/java/spoon/reflect/code/CtCatchVariable.java @@ -16,14 +16,17 @@ */ package spoon.reflect.code; + import spoon.reflect.declaration.CtMultiTypedElement; -import spoon.reflect.declaration.CtTypedElement; import spoon.reflect.declaration.CtVariable; import spoon.reflect.reference.CtCatchVariableReference; import spoon.reflect.reference.CtTypeReference; import spoon.support.DerivedProperty; import spoon.support.UnsettableProperty; + + + /** * This code element defines an exception variable in a catch. * @@ -46,7 +49,7 @@ public interface CtCatchVariable extends CtVariable, CtMultiTypedElement, @Override @UnsettableProperty - > C setDefaultExpression(CtExpression assignedExpression); + CtCatchVariable setDefaultExpression(CtExpression assignedExpression); /** * Returns type reference of the exception variable in a catch. @@ -58,5 +61,5 @@ public interface CtCatchVariable extends CtVariable, CtMultiTypedElement, @Override @UnsettableProperty - C setType(CtTypeReference type); + CtCatchVariable setType(CtTypeReference type); } diff --git a/src/main/java/spoon/reflect/code/CtCodeElement.java b/src/main/java/spoon/reflect/code/CtCodeElement.java index 959cc16b9ba..7f8236abd4a 100644 --- a/src/main/java/spoon/reflect/code/CtCodeElement.java +++ b/src/main/java/spoon/reflect/code/CtCodeElement.java @@ -16,8 +16,12 @@ */ package spoon.reflect.code; + import spoon.reflect.declaration.CtElement; + + + /** * This interface is the root interface of the code elements. */ diff --git a/src/main/java/spoon/reflect/code/CtCodeSnippetExpression.java b/src/main/java/spoon/reflect/code/CtCodeSnippetExpression.java index d5005cbcb36..dc9d7150e6d 100644 --- a/src/main/java/spoon/reflect/code/CtCodeSnippetExpression.java +++ b/src/main/java/spoon/reflect/code/CtCodeSnippetExpression.java @@ -16,9 +16,13 @@ */ package spoon.reflect.code; + import spoon.reflect.declaration.CtCodeSnippet; import spoon.support.compiler.SnippetCompilationError; + + + /** * This element is a code snippet that must represent an expression and can thus * be inserted in the program's model as is. Code snippets should be avoided diff --git a/src/main/java/spoon/reflect/code/CtCodeSnippetStatement.java b/src/main/java/spoon/reflect/code/CtCodeSnippetStatement.java index 1fbacfeff88..22ffb61cca3 100644 --- a/src/main/java/spoon/reflect/code/CtCodeSnippetStatement.java +++ b/src/main/java/spoon/reflect/code/CtCodeSnippetStatement.java @@ -16,10 +16,14 @@ */ package spoon.reflect.code; + import spoon.reflect.declaration.CtCodeSnippet; import spoon.reflect.reference.CtTypeReference; import spoon.support.compiler.SnippetCompilationError; + + + /** * This element is a code snippet that must represent a statement and can thus * be inserted in the program's model as is. Code snippets should be avoided diff --git a/src/main/java/spoon/reflect/code/CtComment.java b/src/main/java/spoon/reflect/code/CtComment.java index bd9da5b186d..cd946e4a519 100644 --- a/src/main/java/spoon/reflect/code/CtComment.java +++ b/src/main/java/spoon/reflect/code/CtComment.java @@ -16,11 +16,15 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; -import static spoon.reflect.path.CtRole.COMMENT_TYPE; import static spoon.reflect.path.CtRole.COMMENT_CONTENT; +import static spoon.reflect.path.CtRole.COMMENT_TYPE; + + + /** * This code element defines a comment @@ -66,7 +70,7 @@ enum CommentType { String getContent(); @PropertySetter(role = COMMENT_CONTENT) - E setContent(String content); + CtComment setContent(String content); /** * Get the type of the comment @@ -76,11 +80,11 @@ enum CommentType { CommentType getCommentType(); @PropertySetter(role = COMMENT_TYPE) - E setCommentType(CommentType commentType); + CtComment setCommentType(CommentType commentType); @Override CtComment clone(); /** Utility method to for casting the object, throws an exception if not of the correct type */ - CtJavaDoc asJavaDoc(); + CtComment asJavaDoc(); } diff --git a/src/main/java/spoon/reflect/code/CtConditional.java b/src/main/java/spoon/reflect/code/CtConditional.java index f66ee6ee964..adeedf9cf3a 100644 --- a/src/main/java/spoon/reflect/code/CtConditional.java +++ b/src/main/java/spoon/reflect/code/CtConditional.java @@ -16,6 +16,7 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; @@ -24,6 +25,9 @@ import static spoon.reflect.path.CtRole.THEN; + + + /** * This code element defines conditional expressions using the ? (ternary expressions). * @@ -58,19 +62,19 @@ public interface CtConditional extends CtExpression { * Sets the "false" expression. */ @PropertySetter(role = ELSE) - > C setElseExpression(CtExpression elseExpression); + CtConditional setElseExpression(CtExpression elseExpression); /** * Sets the "true" expression. */ @PropertySetter(role = THEN) - > C setThenExpression(CtExpression thenExpression); + CtConditional setThenExpression(CtExpression thenExpression); /** * Sets the condition expression. */ @PropertySetter(role = CONDITION) - > C setCondition(CtExpression condition); + CtConditional setCondition(CtExpression condition); @Override CtConditional clone(); diff --git a/src/main/java/spoon/reflect/code/CtConstructorCall.java b/src/main/java/spoon/reflect/code/CtConstructorCall.java index 3f6c982b329..30a78cca7b0 100644 --- a/src/main/java/spoon/reflect/code/CtConstructorCall.java +++ b/src/main/java/spoon/reflect/code/CtConstructorCall.java @@ -16,19 +16,22 @@ */ package spoon.reflect.code; + +import java.util.List; +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; import spoon.reflect.reference.CtActualTypeContainer; import spoon.reflect.reference.CtExecutableReference; import spoon.reflect.reference.CtTypeReference; import spoon.support.DefaultCoreFactory; import spoon.support.DerivedProperty; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; - -import java.util.List; import static spoon.reflect.path.CtRole.TYPE; import static spoon.reflect.path.CtRole.TYPE_ARGUMENT; + + + /** * This code element represents a constructor call. * @@ -59,7 +62,7 @@ public interface CtConstructorCall extends CtTargetedExpression T setActualTypeArguments(List> actualTypeArguments); + CtConstructorCall setActualTypeArguments(List> actualTypeArguments); /** * Delegate to the executable reference of the constructor call. @@ -68,7 +71,7 @@ public interface CtConstructorCall extends CtTargetedExpression T addActualTypeArgument(CtTypeReference actualTypeArgument); + CtConstructorCall addActualTypeArgument(CtTypeReference actualTypeArgument); @Override CtConstructorCall clone(); diff --git a/src/main/java/spoon/reflect/code/CtContinue.java b/src/main/java/spoon/reflect/code/CtContinue.java index 992e8d578e8..c77f7aeffec 100644 --- a/src/main/java/spoon/reflect/code/CtContinue.java +++ b/src/main/java/spoon/reflect/code/CtContinue.java @@ -16,6 +16,9 @@ */ package spoon.reflect.code; + + + /** * This code element defines the continue statement. * Example: diff --git a/src/main/java/spoon/reflect/code/CtDo.java b/src/main/java/spoon/reflect/code/CtDo.java index e2019aac3df..c54e4d44c0e 100644 --- a/src/main/java/spoon/reflect/code/CtDo.java +++ b/src/main/java/spoon/reflect/code/CtDo.java @@ -16,11 +16,15 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import static spoon.reflect.path.CtRole.EXPRESSION; + + + /** * This code element defines a do loop. * @@ -44,7 +48,7 @@ public interface CtDo extends CtLoop { * Sets the looping test as a boolean expression. */ @PropertySetter(role = EXPRESSION) - T setLoopingExpression(CtExpression expression); + CtDo setLoopingExpression(CtExpression expression); @Override CtDo clone(); diff --git a/src/main/java/spoon/reflect/code/CtExecutableReferenceExpression.java b/src/main/java/spoon/reflect/code/CtExecutableReferenceExpression.java index 6cd874569b8..3d05205613e 100644 --- a/src/main/java/spoon/reflect/code/CtExecutableReferenceExpression.java +++ b/src/main/java/spoon/reflect/code/CtExecutableReferenceExpression.java @@ -16,12 +16,16 @@ */ package spoon.reflect.code; -import spoon.reflect.reference.CtExecutableReference; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; +import spoon.reflect.reference.CtExecutableReference; import static spoon.reflect.path.CtRole.EXECUTABLE_REF; + + + /** * This abstract code element defines an expression which represents an executable reference. * @@ -48,7 +52,7 @@ public interface CtExecutableReferenceExpression> e * Sets the executable will be referenced by the expression. */ @PropertySetter(role = EXECUTABLE_REF) - > C setExecutable(CtExecutableReference executable); + CtExecutableReferenceExpression setExecutable(CtExecutableReference executable); @Override CtExecutableReferenceExpression clone(); diff --git a/src/main/java/spoon/reflect/code/CtExpression.java b/src/main/java/spoon/reflect/code/CtExpression.java index 2f4a9ab5fe8..63fd50a26c5 100644 --- a/src/main/java/spoon/reflect/code/CtExpression.java +++ b/src/main/java/spoon/reflect/code/CtExpression.java @@ -16,16 +16,19 @@ */ package spoon.reflect.code; -import spoon.reflect.declaration.CtTypedElement; -import spoon.reflect.reference.CtTypeReference; + +import java.util.List; import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; +import spoon.reflect.declaration.CtTypedElement; +import spoon.reflect.reference.CtTypeReference; import spoon.template.TemplateParameter; -import java.util.List; - import static spoon.reflect.path.CtRole.CAST; + + + /** * This abstract code element defines a typed expression. * @@ -44,13 +47,13 @@ public interface CtExpression extends CtCodeElement, CtTypedElement, Templ * Sets the type casts. */ @PropertySetter(role = CAST) - > C setTypeCasts(List> types); + CtExpression setTypeCasts(List> types); /** * Adds a type cast. */ @PropertySetter(role = CAST) - > C addTypeCast(CtTypeReference type); + CtExpression addTypeCast(CtTypeReference type); @Override CtExpression clone(); diff --git a/src/main/java/spoon/reflect/code/CtFieldAccess.java b/src/main/java/spoon/reflect/code/CtFieldAccess.java index e6cb10ab2d1..96176c05775 100644 --- a/src/main/java/spoon/reflect/code/CtFieldAccess.java +++ b/src/main/java/spoon/reflect/code/CtFieldAccess.java @@ -16,11 +16,15 @@ */ package spoon.reflect.code; -import spoon.reflect.reference.CtFieldReference; + import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.reference.CtFieldReference; import static spoon.reflect.path.CtRole.VARIABLE; + + + /** * This code element defines an access to a field variable (read and write) * diff --git a/src/main/java/spoon/reflect/code/CtFieldRead.java b/src/main/java/spoon/reflect/code/CtFieldRead.java index 59ca0b8b397..001794c945e 100644 --- a/src/main/java/spoon/reflect/code/CtFieldRead.java +++ b/src/main/java/spoon/reflect/code/CtFieldRead.java @@ -16,6 +16,9 @@ */ package spoon.reflect.code; + + + /** * This code element defines a read access to a field. * diff --git a/src/main/java/spoon/reflect/code/CtFieldWrite.java b/src/main/java/spoon/reflect/code/CtFieldWrite.java index c2f61acbf39..f8f99f8753c 100644 --- a/src/main/java/spoon/reflect/code/CtFieldWrite.java +++ b/src/main/java/spoon/reflect/code/CtFieldWrite.java @@ -16,6 +16,9 @@ */ package spoon.reflect.code; + + + /** * This code element defines a write access to a field. * diff --git a/src/main/java/spoon/reflect/code/CtFor.java b/src/main/java/spoon/reflect/code/CtFor.java index 4b86c2c5b33..099549dcc9c 100644 --- a/src/main/java/spoon/reflect/code/CtFor.java +++ b/src/main/java/spoon/reflect/code/CtFor.java @@ -16,15 +16,18 @@ */ package spoon.reflect.code; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; import java.util.List; +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; import static spoon.reflect.path.CtRole.EXPRESSION; import static spoon.reflect.path.CtRole.FOR_INIT; import static spoon.reflect.path.CtRole.FOR_UPDATE; + + + /** * This code element defines a for loop. * Example: @@ -47,7 +50,7 @@ public interface CtFor extends CtLoop { * Sets the end-loop test expression. */ @PropertySetter(role = EXPRESSION) - T setExpression(CtExpression expression); + CtFor setExpression(CtExpression expression); /** * Gets the init statements. @@ -59,13 +62,13 @@ public interface CtFor extends CtLoop { * Adds an init statement. */ @PropertySetter(role = FOR_INIT) - T addForInit(CtStatement statement); + CtFor addForInit(CtStatement statement); /** * Sets the init statements. */ @PropertySetter(role = FOR_INIT) - T setForInit(List forInit); + CtFor setForInit(List forInit); /** * Removes an init statement. @@ -83,13 +86,13 @@ public interface CtFor extends CtLoop { * Adds an update statement. */ @PropertySetter(role = FOR_UPDATE) - T addForUpdate(CtStatement statement); + CtFor addForUpdate(CtStatement statement); /** * Sets the update statements. */ @PropertySetter(role = FOR_UPDATE) - T setForUpdate(List forUpdate); + CtFor setForUpdate(List forUpdate); /** * Removes an update statement. diff --git a/src/main/java/spoon/reflect/code/CtForEach.java b/src/main/java/spoon/reflect/code/CtForEach.java index e581bc5b16a..951a5b537dc 100644 --- a/src/main/java/spoon/reflect/code/CtForEach.java +++ b/src/main/java/spoon/reflect/code/CtForEach.java @@ -16,6 +16,7 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; @@ -23,6 +24,9 @@ import static spoon.reflect.path.CtRole.FOREACH_VARIABLE; + + + /** * This code element defines a foreach statement. * Example: @@ -50,13 +54,13 @@ public interface CtForEach extends CtLoop { * Sets the iterated expression (an iterable of an array). */ @PropertySetter(role = EXPRESSION) - T setExpression(CtExpression expression); + CtForEach setExpression(CtExpression expression); /** * Sets the variable that references the currently iterated element. */ @PropertySetter(role = FOREACH_VARIABLE) - T setVariable(CtLocalVariable variable); + CtForEach setVariable(CtLocalVariable variable); @Override CtForEach clone(); diff --git a/src/main/java/spoon/reflect/code/CtIf.java b/src/main/java/spoon/reflect/code/CtIf.java index 79270989af7..95870a621c3 100644 --- a/src/main/java/spoon/reflect/code/CtIf.java +++ b/src/main/java/spoon/reflect/code/CtIf.java @@ -16,6 +16,7 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.template.TemplateParameter; @@ -24,6 +25,9 @@ import static spoon.reflect.path.CtRole.ELSE; import static spoon.reflect.path.CtRole.THEN; + + + /** * This code element represents an if statement. * Example: @@ -61,19 +65,19 @@ public interface CtIf extends CtStatement, TemplateParameter { * condition. */ @PropertySetter(role = CONDITION) - T setCondition(CtExpression expression); + CtIf setCondition(CtExpression expression); /** * Sets the statement executed when the condition is false. */ @PropertySetter(role = ELSE) - T setElseStatement(CtStatement elseStatement); + CtIf setElseStatement(CtStatement elseStatement); /** * Sets the statement executed when the condition is true. */ @PropertySetter(role = THEN) - T setThenStatement(CtStatement thenStatement); + CtIf setThenStatement(CtStatement thenStatement); @Override CtIf clone(); diff --git a/src/main/java/spoon/reflect/code/CtInvocation.java b/src/main/java/spoon/reflect/code/CtInvocation.java index 693effc5ada..c9419b989e1 100644 --- a/src/main/java/spoon/reflect/code/CtInvocation.java +++ b/src/main/java/spoon/reflect/code/CtInvocation.java @@ -16,18 +16,21 @@ */ package spoon.reflect.code; + +import java.util.List; +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; import spoon.reflect.reference.CtActualTypeContainer; import spoon.reflect.reference.CtExecutableReference; import spoon.reflect.reference.CtTypeReference; import spoon.support.DerivedProperty; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; - -import java.util.List; import static spoon.reflect.path.CtRole.TYPE; import static spoon.reflect.path.CtRole.TYPE_ARGUMENT; + + + /** * This code element defines a concrete invocation. * @@ -59,7 +62,7 @@ public interface CtInvocation extends CtAbstractInvocation, CtStatement, C */ @Override @PropertySetter(role = TYPE_ARGUMENT) - T setActualTypeArguments(List> actualTypeArguments); + CtInvocation setActualTypeArguments(List> actualTypeArguments); /** * Delegate to the executable reference of the invocation. @@ -68,7 +71,7 @@ public interface CtInvocation extends CtAbstractInvocation, CtStatement, C */ @Override @PropertySetter(role = TYPE_ARGUMENT) - T addActualTypeArgument(CtTypeReference actualTypeArgument); + CtInvocation addActualTypeArgument(CtTypeReference actualTypeArgument); /** * Return the type returned by the invocation. If the invocation is to a diff --git a/src/main/java/spoon/reflect/code/CtJavaDoc.java b/src/main/java/spoon/reflect/code/CtJavaDoc.java index f06d2e9b9ae..e2f6888db31 100644 --- a/src/main/java/spoon/reflect/code/CtJavaDoc.java +++ b/src/main/java/spoon/reflect/code/CtJavaDoc.java @@ -16,14 +16,17 @@ */ package spoon.reflect.code; -import spoon.support.DerivedProperty; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; import java.util.List; +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; +import spoon.support.DerivedProperty; import static spoon.reflect.path.CtRole.COMMENT_TAG; + + + /** * This code element defines a javadoc comment * @@ -48,14 +51,14 @@ public interface CtJavaDoc extends CtComment { * @param tags the new list of tags */ @PropertySetter(role = COMMENT_TAG) - E setTags(List tags); + CtJavaDoc setTags(List tags); /** * Add a new tag at the end of the list * @param tag the new tag */ @PropertySetter(role = COMMENT_TAG) - E addTag(CtJavaDocTag tag); + CtJavaDoc addTag(CtJavaDocTag tag); /** * Add a new tag at the index position @@ -63,21 +66,21 @@ public interface CtJavaDoc extends CtComment { * @param tag the new tag */ @PropertySetter(role = COMMENT_TAG) - E addTag(int index, CtJavaDocTag tag); + CtJavaDoc addTag(int index, CtJavaDocTag tag); /** * Remove a tag from the index * @param index the position of the tag to remove */ @PropertySetter(role = COMMENT_TAG) - E removeTag(int index); + CtJavaDoc removeTag(int index); /** * Remove a specific tag * @param tag the tag to remove */ @PropertySetter(role = COMMENT_TAG) - E removeTag(CtJavaDocTag tag); + CtJavaDoc removeTag(CtJavaDocTag tag); /** * Get the short summary of the javadoc (first sentence of the javadoc) diff --git a/src/main/java/spoon/reflect/code/CtJavaDocTag.java b/src/main/java/spoon/reflect/code/CtJavaDocTag.java index 24f049de248..38787e8088d 100644 --- a/src/main/java/spoon/reflect/code/CtJavaDocTag.java +++ b/src/main/java/spoon/reflect/code/CtJavaDocTag.java @@ -16,13 +16,17 @@ */ package spoon.reflect.code; -import spoon.reflect.declaration.CtElement; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; +import spoon.reflect.declaration.CtElement; import static spoon.reflect.path.CtRole.COMMENT_CONTENT; -import static spoon.reflect.path.CtRole.JAVADOC_TAG_VALUE; import static spoon.reflect.path.CtRole.DOCUMENTATION_TYPE; +import static spoon.reflect.path.CtRole.JAVADOC_TAG_VALUE; + + + /** * This code element defines a javadoc tag @@ -97,14 +101,14 @@ public String toString() { * @param type the type name */ @PropertySetter(role = DOCUMENTATION_TYPE) - E setType(String type); + CtJavaDocTag setType(String type); /** * Define the type of the tag * @param type the new type */ @PropertySetter(role = DOCUMENTATION_TYPE) - E setType(TagType type); + CtJavaDocTag setType(TagType type); /** * Get the content of the atg @@ -118,7 +122,7 @@ public String toString() { * @param content the new content of the tag */ @PropertySetter(role = COMMENT_CONTENT) - E setContent(String content); + CtJavaDocTag setContent(String content); /** * Get the parameter of the tag return null when none is specified (only for @param and @throws) @@ -132,7 +136,7 @@ public String toString() { * @param param the parameter */ @PropertySetter(role = JAVADOC_TAG_VALUE) - E setParam(String param); + CtJavaDocTag setParam(String param); @Override CtJavaDocTag clone(); diff --git a/src/main/java/spoon/reflect/code/CtLabelledFlowBreak.java b/src/main/java/spoon/reflect/code/CtLabelledFlowBreak.java index e1528712bc9..14803b989ab 100644 --- a/src/main/java/spoon/reflect/code/CtLabelledFlowBreak.java +++ b/src/main/java/spoon/reflect/code/CtLabelledFlowBreak.java @@ -16,12 +16,16 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.support.DerivedProperty; import static spoon.reflect.path.CtRole.TARGET_LABEL; + + + /** * This abstract code element represents all the statements that break the * control flow of the program and which can support a label. @@ -39,7 +43,7 @@ public interface CtLabelledFlowBreak extends CtCFlowBreak { * defined). */ @PropertySetter(role = TARGET_LABEL) - T setTargetLabel(String targetLabel); + CtLabelledFlowBreak setTargetLabel(String targetLabel); @DerivedProperty CtStatement getLabelledStatement(); diff --git a/src/main/java/spoon/reflect/code/CtLambda.java b/src/main/java/spoon/reflect/code/CtLambda.java index 84d8e440477..2fe12152c6d 100644 --- a/src/main/java/spoon/reflect/code/CtLambda.java +++ b/src/main/java/spoon/reflect/code/CtLambda.java @@ -16,18 +16,21 @@ */ package spoon.reflect.code; + +import java.util.Set; +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; import spoon.reflect.declaration.CtExecutable; import spoon.reflect.declaration.CtMethod; import spoon.reflect.reference.CtTypeReference; import spoon.support.DerivedProperty; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; import spoon.support.UnsettableProperty; -import java.util.Set; - import static spoon.reflect.path.CtRole.EXPRESSION; + + + /** * This code element represents the creation of a lambda. A lambda * can have two sorts of body : an simple expression or a block of @@ -78,12 +81,12 @@ public interface CtLambda extends CtExpression, CtExecutable { * if the lambda already has a value in the body attribute. */ @PropertySetter(role = EXPRESSION) - > C setExpression(CtExpression expression); + CtLambda setExpression(CtExpression expression); @Override CtLambda clone(); @Override @UnsettableProperty - > T1 setThrownTypes(Set> thrownTypes); + CtLambda setThrownTypes(Set> thrownTypes); } diff --git a/src/main/java/spoon/reflect/code/CtLiteral.java b/src/main/java/spoon/reflect/code/CtLiteral.java index dc30bf8f87c..19baf07f454 100644 --- a/src/main/java/spoon/reflect/code/CtLiteral.java +++ b/src/main/java/spoon/reflect/code/CtLiteral.java @@ -16,11 +16,15 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import static spoon.reflect.path.CtRole.VALUE; + + + /** * This code element defines a literal value (an int, a string, etc). * @@ -44,7 +48,7 @@ public interface CtLiteral extends CtExpression { * Sets the actual value of the literal. */ @PropertySetter(role = VALUE) - > C setValue(T value); + CtLiteral setValue(T value); /** Overriding return type, a clone of a CtLiteral returns a CtLiteral */ @Override diff --git a/src/main/java/spoon/reflect/code/CtLocalVariable.java b/src/main/java/spoon/reflect/code/CtLocalVariable.java index 6a6443f34a6..806c338f1ea 100644 --- a/src/main/java/spoon/reflect/code/CtLocalVariable.java +++ b/src/main/java/spoon/reflect/code/CtLocalVariable.java @@ -16,6 +16,7 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.reflect.declaration.CtVariable; @@ -25,6 +26,9 @@ import static spoon.reflect.path.CtRole.IS_INFERRED; + + + /** * This code element defines a local variable definition (within an executable * body). @@ -68,7 +72,7 @@ public interface CtLocalVariable extends CtStatement, CtVariable, CtRHSRec @Override @UnsettableProperty - > U setAssignment(CtExpression assignment); + CtLocalVariable setAssignment(CtExpression assignment); /** * Return true if this variable's type is not explicitely defined in the source code, but was using the `var` keyword of Java 10. @@ -81,6 +85,6 @@ public interface CtLocalVariable extends CtStatement, CtVariable, CtRHSRec * Warning: this method should only be used if compliance level is set to 10 or more. */ @PropertySetter(role = IS_INFERRED) - > U setInferred(boolean inferred); + CtLocalVariable setInferred(boolean inferred); } diff --git a/src/main/java/spoon/reflect/code/CtLoop.java b/src/main/java/spoon/reflect/code/CtLoop.java index 84bd60a68e4..bef65551876 100644 --- a/src/main/java/spoon/reflect/code/CtLoop.java +++ b/src/main/java/spoon/reflect/code/CtLoop.java @@ -16,11 +16,15 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.template.TemplateParameter; import static spoon.reflect.path.CtRole.BODY; + + + /** * This abstract code element defines a loop. */ diff --git a/src/main/java/spoon/reflect/code/CtNewArray.java b/src/main/java/spoon/reflect/code/CtNewArray.java index 212b0c3addf..dfe60d87712 100644 --- a/src/main/java/spoon/reflect/code/CtNewArray.java +++ b/src/main/java/spoon/reflect/code/CtNewArray.java @@ -16,14 +16,17 @@ */ package spoon.reflect.code; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; import java.util.List; +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; import static spoon.reflect.path.CtRole.DIMENSION; import static spoon.reflect.path.CtRole.EXPRESSION; + + + /** * This code element defines the inline creation of a new array. * @@ -47,13 +50,13 @@ public interface CtNewArray extends CtExpression { * Sets the expressions that define the array's dimensions. */ @PropertySetter(role = DIMENSION) - > C setDimensionExpressions(List> dimensions); + CtNewArray setDimensionExpressions(List> dimensions); /** * Adds a dimension expression. */ @PropertySetter(role = DIMENSION) - > C addDimensionExpression(CtExpression dimension); + CtNewArray addDimensionExpression(CtExpression dimension); /** * Removes a dimension expression. @@ -71,13 +74,13 @@ public interface CtNewArray extends CtExpression { * Sets the initialization expressions. */ @PropertySetter(role = EXPRESSION) - > C setElements(List> expression); + CtNewArray setElements(List> expression); /** * Adds an element. */ @PropertySetter(role = EXPRESSION) - > C addElement(CtExpression expression); + CtNewArray addElement(CtExpression expression); /** * Removes an element. diff --git a/src/main/java/spoon/reflect/code/CtNewClass.java b/src/main/java/spoon/reflect/code/CtNewClass.java index 93efde50d14..e18acf9b7d7 100644 --- a/src/main/java/spoon/reflect/code/CtNewClass.java +++ b/src/main/java/spoon/reflect/code/CtNewClass.java @@ -16,20 +16,23 @@ */ package spoon.reflect.code; + +import java.util.List; import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.reflect.declaration.CtClass; -import spoon.reflect.reference.CtActualTypeContainer; import spoon.reflect.reference.CtExecutableReference; import spoon.reflect.reference.CtTypeReference; import spoon.support.DerivedProperty; -import java.util.List; - import static spoon.reflect.path.CtRole.NESTED_TYPE; import static spoon.reflect.path.CtRole.TYPE_ARGUMENT; -/** + + + + +public/** * This code element represents the creation of a anonymous class. * * Example: @@ -45,7 +48,7 @@ * @param * created type */ -public interface CtNewClass extends CtConstructorCall { +interface CtNewClass extends CtConstructorCall { /** * Delegate to the executable reference of the new class. * @@ -63,7 +66,7 @@ public interface CtNewClass extends CtConstructorCall { */ @Override @PropertySetter(role = TYPE_ARGUMENT) - T setActualTypeArguments(List> actualTypeArguments); + CtNewClass setActualTypeArguments(List> actualTypeArguments); /** * Delegate to the executable reference of the new class. @@ -72,7 +75,7 @@ public interface CtNewClass extends CtConstructorCall { */ @Override @PropertySetter(role = TYPE_ARGUMENT) - T addActualTypeArgument(CtTypeReference actualTypeArgument); + CtNewClass addActualTypeArgument(CtTypeReference actualTypeArgument); /** * Gets the created class. @@ -84,7 +87,7 @@ public interface CtNewClass extends CtConstructorCall { * Sets the created class. */ @PropertySetter(role = NESTED_TYPE) - N setAnonymousClass(CtClass anonymousClass); + CtNewClass setAnonymousClass(CtClass anonymousClass); @Override CtNewClass clone(); diff --git a/src/main/java/spoon/reflect/code/CtOperatorAssignment.java b/src/main/java/spoon/reflect/code/CtOperatorAssignment.java index d63b909378c..b323183a283 100644 --- a/src/main/java/spoon/reflect/code/CtOperatorAssignment.java +++ b/src/main/java/spoon/reflect/code/CtOperatorAssignment.java @@ -16,12 +16,16 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import static spoon.reflect.path.CtRole.OPERATOR_KIND; + + + /** * This code element defines an self-operated assignment such as += or *=. * @@ -37,7 +41,7 @@ public interface CtOperatorAssignment extends CtAssignment * Sets the operator kind. */ @PropertySetter(role = OPERATOR_KIND) - > C setKind(BinaryOperatorKind kind); + CtOperatorAssignment setKind(BinaryOperatorKind kind); /** * Gets the operator kind. diff --git a/src/main/java/spoon/reflect/code/CtRHSReceiver.java b/src/main/java/spoon/reflect/code/CtRHSReceiver.java index 633849e9682..750eaf71b16 100644 --- a/src/main/java/spoon/reflect/code/CtRHSReceiver.java +++ b/src/main/java/spoon/reflect/code/CtRHSReceiver.java @@ -16,12 +16,16 @@ */ package spoon.reflect.code; -import spoon.reflect.declaration.CtField; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; +import spoon.reflect.declaration.CtField; import static spoon.reflect.path.CtRole.ASSIGNMENT; + + + /** * Represents the right hand side of an assignment * @@ -38,5 +42,5 @@ public interface CtRHSReceiver { * Sets the right-hand side expression (RHS) of the "=" operator. */ @PropertySetter(role = ASSIGNMENT) - > T setAssignment(CtExpression assignment); + CtRHSReceiver setAssignment(CtExpression assignment); } diff --git a/src/main/java/spoon/reflect/code/CtReturn.java b/src/main/java/spoon/reflect/code/CtReturn.java index 3dd5510ca46..486fa512d7c 100644 --- a/src/main/java/spoon/reflect/code/CtReturn.java +++ b/src/main/java/spoon/reflect/code/CtReturn.java @@ -16,13 +16,18 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.template.TemplateParameter; import static spoon.reflect.path.CtRole.EXPRESSION; -/** + + + + +public/** * This code element represents a return statement. * * Example: @@ -36,7 +41,7 @@ * */ -public interface CtReturn extends CtCFlowBreak, TemplateParameter { +interface CtReturn extends CtCFlowBreak, TemplateParameter { /** * Gets the returned expression. @@ -48,7 +53,7 @@ public interface CtReturn extends CtCFlowBreak, TemplateParameter { * Sets the returned expression. */ @PropertySetter(role = EXPRESSION) - > T setReturnedExpression(CtExpression returnedExpression); + CtReturn setReturnedExpression(CtExpression returnedExpression); @Override CtReturn clone(); diff --git a/src/main/java/spoon/reflect/code/CtStatement.java b/src/main/java/spoon/reflect/code/CtStatement.java index fbf62bb8f93..12f540dc302 100644 --- a/src/main/java/spoon/reflect/code/CtStatement.java +++ b/src/main/java/spoon/reflect/code/CtStatement.java @@ -16,12 +16,16 @@ */ package spoon.reflect.code; -import spoon.reflect.declaration.ParentNotInitializedException; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; +import spoon.reflect.declaration.ParentNotInitializedException; import static spoon.reflect.path.CtRole.LABEL; + + + /** * This abstract code element represents all the statements, which can be part * of a block. @@ -33,23 +37,23 @@ public interface CtStatement extends CtCodeElement { /** * Inserts a statement after the current statement. */ - T insertAfter(CtStatement statement) throws ParentNotInitializedException; + CtStatement insertAfter(CtStatement statement) throws ParentNotInitializedException; /** * Inserts a statement list before the current statement. */ - T insertAfter(CtStatementList statements) throws ParentNotInitializedException; + CtStatement insertAfter(CtStatementList statements) throws ParentNotInitializedException; /** * Inserts a statement given as parameter before the current statement * (this). */ - T insertBefore(CtStatement statement) throws ParentNotInitializedException; + CtStatement insertBefore(CtStatement statement) throws ParentNotInitializedException; /** * Inserts a statement list before the current statement. */ - T insertBefore(CtStatementList statements) throws ParentNotInitializedException; + CtStatement insertBefore(CtStatementList statements) throws ParentNotInitializedException; /** * Gets the label of this statement if defined. @@ -63,7 +67,7 @@ public interface CtStatement extends CtCodeElement { * Sets the label of this statement. */ @PropertySetter(role = LABEL) - T setLabel(String label); + CtStatement setLabel(String label); @Override CtStatement clone(); diff --git a/src/main/java/spoon/reflect/code/CtStatementList.java b/src/main/java/spoon/reflect/code/CtStatementList.java index 31bc8748d72..32c304d223c 100644 --- a/src/main/java/spoon/reflect/code/CtStatementList.java +++ b/src/main/java/spoon/reflect/code/CtStatementList.java @@ -16,15 +16,18 @@ */ package spoon.reflect.code; + +import java.util.List; import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.reflect.visitor.Filter; import spoon.support.DerivedProperty; -import java.util.List; - import static spoon.reflect.path.CtRole.STATEMENT; + + + /** * This code element represents a list of statements. It is not a valid Java * program element and is never used directly, on contrary to @@ -41,72 +44,72 @@ public interface CtStatementList extends CtCodeElement, Iterable { * Sets the statement list. */ @PropertySetter(role = STATEMENT) - T setStatements(List statements); + CtStatementList setStatements(List statements); /** * Adds a statement at the end of the list. */ @PropertySetter(role = STATEMENT) - T addStatement(CtStatement statement); + CtStatementList addStatement(CtStatement statement); /** * Inserts the given statement at a specific position in the list of statements * Shifts the statement currently at that position (if any) and any subsequent statements to the right (adds one to their indices). */ @PropertySetter(role = STATEMENT) - T addStatement(int index, CtStatement statement); + CtStatementList addStatement(int index, CtStatement statement); /** * Inserts the given statement at the beginning of the block. */ @PropertySetter(role = STATEMENT) - T insertBegin(CtStatement statement); + CtStatementList insertBegin(CtStatement statement); /** * Inserts the given statement list at the beginning of the block. */ @PropertySetter(role = STATEMENT) - T insertBegin(CtStatementList statements); + CtStatementList insertBegin(CtStatementList statements); /** * Inserts the given statement at the end of the block. */ @PropertySetter(role = STATEMENT) - T insertEnd(CtStatement statement); + CtStatementList insertEnd(CtStatement statement); /** * Inserts the given statements at the end of the block. */ @PropertySetter(role = STATEMENT) - T insertEnd(CtStatementList statements); + CtStatementList insertEnd(CtStatementList statements); /** * Inserts the given statement before a set of insertion points given by a * filter. */ @DerivedProperty - T insertBefore(Filter insertionPoints, CtStatement statement); + CtStatementList insertBefore(Filter insertionPoints, CtStatement statement); /** * Inserts the given statement list before a set of insertion points given * by a filter. */ @DerivedProperty - T insertBefore(Filter insertionPoints, CtStatementList statements); + CtStatementList insertBefore(Filter insertionPoints, CtStatementList statements); /** * Inserts the given statement after a set of insertion points given by a * filter. */ @DerivedProperty - T insertAfter(Filter insertionPoints, CtStatement statement); + CtStatementList insertAfter(Filter insertionPoints, CtStatement statement); /** * Inserts the given statement list after a set of insertion points given by * a filter. */ @DerivedProperty - T insertAfter(Filter insertionPoints, CtStatementList statements); + CtStatementList insertAfter(Filter insertionPoints, CtStatementList statements); /** * Gets the ith statement of this block. diff --git a/src/main/java/spoon/reflect/code/CtSuperAccess.java b/src/main/java/spoon/reflect/code/CtSuperAccess.java index c8f9d7c9b92..75822d3449f 100644 --- a/src/main/java/spoon/reflect/code/CtSuperAccess.java +++ b/src/main/java/spoon/reflect/code/CtSuperAccess.java @@ -16,9 +16,13 @@ */ package spoon.reflect.code; + import spoon.reflect.reference.CtTypeReference; import spoon.support.DerivedProperty; + + + /** * This code element defines an access to super. * diff --git a/src/main/java/spoon/reflect/code/CtSwitch.java b/src/main/java/spoon/reflect/code/CtSwitch.java index 587c036635f..603cd599331 100644 --- a/src/main/java/spoon/reflect/code/CtSwitch.java +++ b/src/main/java/spoon/reflect/code/CtSwitch.java @@ -16,14 +16,17 @@ */ package spoon.reflect.code; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; import java.util.List; +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; import static spoon.reflect.path.CtRole.CASE; import static spoon.reflect.path.CtRole.EXPRESSION; + + + /** * This code element defines a switch statement. * @@ -57,7 +60,7 @@ public interface CtSwitch extends CtStatement { * Integer, or an enum type */ @PropertySetter(role = EXPRESSION) - > T setSelector(CtExpression selector); + CtSwitch setSelector(CtExpression selector); /** * Gets the list of cases defined for this switch. @@ -69,13 +72,13 @@ public interface CtSwitch extends CtStatement { * Sets the list of cases defined for this switch. */ @PropertySetter(role = CASE) - > T setCases(List> cases); + CtSwitch setCases(List> cases); /** * Adds a case; */ @PropertySetter(role = CASE) - > T addCase(CtCase c); + CtSwitch addCase(CtCase c); /** * Removes a case; diff --git a/src/main/java/spoon/reflect/code/CtSynchronized.java b/src/main/java/spoon/reflect/code/CtSynchronized.java index 3a202a01b35..6af88abbc62 100644 --- a/src/main/java/spoon/reflect/code/CtSynchronized.java +++ b/src/main/java/spoon/reflect/code/CtSynchronized.java @@ -16,6 +16,7 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; @@ -23,6 +24,9 @@ import static spoon.reflect.path.CtRole.EXPRESSION; + + + /** * This code element defines a synchronized statement. * @@ -47,7 +51,7 @@ public interface CtSynchronized extends CtStatement { * Sets the expression that defines the monitored. */ @PropertySetter(role = EXPRESSION) - T setExpression(CtExpression expression); + CtSynchronized setExpression(CtExpression expression); /** * Gets the synchronized block. @@ -59,7 +63,7 @@ public interface CtSynchronized extends CtStatement { * Sets the synchronized block. */ @PropertySetter(role = BODY) - T setBlock(CtBlock block); + CtSynchronized setBlock(CtBlock block); @Override CtSynchronized clone(); diff --git a/src/main/java/spoon/reflect/code/CtTargetedExpression.java b/src/main/java/spoon/reflect/code/CtTargetedExpression.java index de5529748a9..63fd3af664f 100644 --- a/src/main/java/spoon/reflect/code/CtTargetedExpression.java +++ b/src/main/java/spoon/reflect/code/CtTargetedExpression.java @@ -16,12 +16,16 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import static spoon.reflect.path.CtRole.TARGET; + + + /** * This abstract code element defines an expression which contains a target * expression. In Java, it is generally of the form: diff --git a/src/main/java/spoon/reflect/code/CtThisAccess.java b/src/main/java/spoon/reflect/code/CtThisAccess.java index 0619436ed12..eb984efb5b6 100644 --- a/src/main/java/spoon/reflect/code/CtThisAccess.java +++ b/src/main/java/spoon/reflect/code/CtThisAccess.java @@ -16,6 +16,9 @@ */ package spoon.reflect.code; + + + /** * This code element defines an access to this. * diff --git a/src/main/java/spoon/reflect/code/CtThrow.java b/src/main/java/spoon/reflect/code/CtThrow.java index 65079ae70dc..fc55223b814 100644 --- a/src/main/java/spoon/reflect/code/CtThrow.java +++ b/src/main/java/spoon/reflect/code/CtThrow.java @@ -16,12 +16,16 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.template.TemplateParameter; import static spoon.reflect.path.CtRole.EXPRESSION; + + + /** * This code element defines a throw statement. * @@ -42,7 +46,7 @@ public interface CtThrow extends CtCFlowBreak, TemplateParameter { * Sets the thrown expression (must be a throwable). */ @PropertySetter(role = EXPRESSION) - T setThrownExpression(CtExpression thrownExpression); + CtThrow setThrownExpression(CtExpression thrownExpression); @Override CtThrow clone(); diff --git a/src/main/java/spoon/reflect/code/CtTry.java b/src/main/java/spoon/reflect/code/CtTry.java index 99d7f9abbde..875dab2f242 100644 --- a/src/main/java/spoon/reflect/code/CtTry.java +++ b/src/main/java/spoon/reflect/code/CtTry.java @@ -16,16 +16,19 @@ */ package spoon.reflect.code; + +import java.util.List; import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.template.TemplateParameter; -import java.util.List; - import static spoon.reflect.path.CtRole.BODY; import static spoon.reflect.path.CtRole.CATCH; import static spoon.reflect.path.CtRole.FINALIZER; + + + /** * This code element defines a try statement. * @@ -48,13 +51,13 @@ public interface CtTry extends CtStatement, TemplateParameter, CtBodyHolde * Sets the catchers of this try. */ @PropertySetter(role = CATCH) - T setCatchers(List catchers); + CtTry setCatchers(List catchers); /** * Adds a catch block. */ @PropertySetter(role = CATCH) - T addCatcher(CtCatch catcher); + CtTry addCatcher(CtCatch catcher); /** * Removes a catch block. @@ -81,7 +84,7 @@ public interface CtTry extends CtStatement, TemplateParameter, CtBodyHolde * finally part). */ @PropertySetter(role = FINALIZER) - T setFinalizer(CtBlock finalizer); + CtTry setFinalizer(CtBlock finalizer); @Override CtTry clone(); diff --git a/src/main/java/spoon/reflect/code/CtTryWithResource.java b/src/main/java/spoon/reflect/code/CtTryWithResource.java index 1325c4065a5..78f2015a6f0 100644 --- a/src/main/java/spoon/reflect/code/CtTryWithResource.java +++ b/src/main/java/spoon/reflect/code/CtTryWithResource.java @@ -16,13 +16,16 @@ */ package spoon.reflect.code; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; import java.util.List; +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; import static spoon.reflect.path.CtRole.TRY_RESOURCE; + + + /** * This code element defines a try with resource statement. * @@ -48,13 +51,13 @@ public interface CtTryWithResource extends CtTry { * from Java 7 with the try-with-resource statement. */ @PropertySetter(role = TRY_RESOURCE) - T setResources(List> resources); + CtTryWithResource setResources(List> resources); /** * Adds a resource. */ @PropertySetter(role = TRY_RESOURCE) - T addResource(CtLocalVariable resource); + CtTryWithResource addResource(CtLocalVariable resource); /** * Removes a resource. diff --git a/src/main/java/spoon/reflect/code/CtTypeAccess.java b/src/main/java/spoon/reflect/code/CtTypeAccess.java index 390bed85d26..cdcd1f844f5 100644 --- a/src/main/java/spoon/reflect/code/CtTypeAccess.java +++ b/src/main/java/spoon/reflect/code/CtTypeAccess.java @@ -16,15 +16,18 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; -import spoon.reflect.declaration.CtTypedElement; import spoon.reflect.reference.CtTypeReference; import spoon.support.DerivedProperty; import spoon.support.UnsettableProperty; import static spoon.reflect.path.CtRole.ACCESSED_TYPE; + + + /** * This code element represents a type reference usable as an expression. * It is used in particular for static accesses, Java 8 method references, instanceof binary expressions and ".class". @@ -69,7 +72,7 @@ public interface CtTypeAccess extends CtExpression { * CtTypeReference. */ @PropertySetter(role = ACCESSED_TYPE) - > C setAccessedType(CtTypeReference accessedType); + CtTypeAccess setAccessedType(CtTypeReference accessedType); /** * Returns always VOID. @@ -82,7 +85,7 @@ public interface CtTypeAccess extends CtExpression { @Override @UnsettableProperty - C setType(CtTypeReference type); + CtTypeAccess setType(CtTypeReference type); @Override CtTypeAccess clone(); diff --git a/src/main/java/spoon/reflect/code/CtUnaryOperator.java b/src/main/java/spoon/reflect/code/CtUnaryOperator.java index 9ad5a0286ec..27d5f8aa270 100644 --- a/src/main/java/spoon/reflect/code/CtUnaryOperator.java +++ b/src/main/java/spoon/reflect/code/CtUnaryOperator.java @@ -16,6 +16,7 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; @@ -23,6 +24,9 @@ import static spoon.reflect.path.CtRole.OPERATOR_KIND; + + + /** * This code element represents a unary operator. * For example : @@ -46,13 +50,13 @@ public interface CtUnaryOperator extends CtExpression, CtStatement { * Sets the expression to which the operator is applied. */ @PropertySetter(role = EXPRESSION) - C setOperand(CtExpression expression); + CtUnaryOperator setOperand(CtExpression expression); /** * Sets the kind of this operator. */ @PropertySetter(role = OPERATOR_KIND) - C setKind(UnaryOperatorKind kind); + CtUnaryOperator setKind(UnaryOperatorKind kind); /** * Gets the kind of this operator. diff --git a/src/main/java/spoon/reflect/code/CtVariableAccess.java b/src/main/java/spoon/reflect/code/CtVariableAccess.java index 81159ae4a44..62ede12090f 100644 --- a/src/main/java/spoon/reflect/code/CtVariableAccess.java +++ b/src/main/java/spoon/reflect/code/CtVariableAccess.java @@ -16,14 +16,18 @@ */ package spoon.reflect.code; + +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; import spoon.reflect.reference.CtTypeReference; import spoon.reflect.reference.CtVariableReference; import spoon.support.DerivedProperty; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; import static spoon.reflect.path.CtRole.VARIABLE; + + + /** * This code element defines an access to a variable (read and write). * @@ -43,7 +47,7 @@ public interface CtVariableAccess extends CtExpression { * Sets the reference to the accessed variable. */ @PropertySetter(role = VARIABLE) - > C setVariable(CtVariableReference variable); + CtVariableAccess setVariable(CtVariableReference variable); @Override CtVariableAccess clone(); diff --git a/src/main/java/spoon/reflect/code/CtVariableRead.java b/src/main/java/spoon/reflect/code/CtVariableRead.java index 3ea8799b1ad..5e885ef5e4e 100644 --- a/src/main/java/spoon/reflect/code/CtVariableRead.java +++ b/src/main/java/spoon/reflect/code/CtVariableRead.java @@ -16,6 +16,9 @@ */ package spoon.reflect.code; + + + /** * This code element defines an read access to a variable. * diff --git a/src/main/java/spoon/reflect/code/CtVariableWrite.java b/src/main/java/spoon/reflect/code/CtVariableWrite.java index a3b00c4df41..962039c63bd 100644 --- a/src/main/java/spoon/reflect/code/CtVariableWrite.java +++ b/src/main/java/spoon/reflect/code/CtVariableWrite.java @@ -16,6 +16,9 @@ */ package spoon.reflect.code; + + + /** * This code element defines a write to a variable. * diff --git a/src/main/java/spoon/reflect/code/CtWhile.java b/src/main/java/spoon/reflect/code/CtWhile.java index b6280f31528..afc1a68676a 100644 --- a/src/main/java/spoon/reflect/code/CtWhile.java +++ b/src/main/java/spoon/reflect/code/CtWhile.java @@ -16,11 +16,15 @@ */ package spoon.reflect.code; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import static spoon.reflect.path.CtRole.EXPRESSION; + + + /** * This code element defines a while loop. * @@ -44,7 +48,7 @@ public interface CtWhile extends CtLoop { * Sets the looping boolean test expression. */ @PropertySetter(role = EXPRESSION) - T setLoopingExpression(CtExpression expression); + CtWhile setLoopingExpression(CtExpression expression); @Override CtWhile clone(); diff --git a/src/main/java/spoon/reflect/code/UnaryOperatorKind.java b/src/main/java/spoon/reflect/code/UnaryOperatorKind.java index e3bac868863..c7b3f9c6515 100644 --- a/src/main/java/spoon/reflect/code/UnaryOperatorKind.java +++ b/src/main/java/spoon/reflect/code/UnaryOperatorKind.java @@ -16,6 +16,9 @@ */ package spoon.reflect.code; + + + /** * This enumeration defines all the kinds of unary operators. */ diff --git a/src/main/java/spoon/reflect/declaration/CtAnnotatedElementType.java b/src/main/java/spoon/reflect/declaration/CtAnnotatedElementType.java index 1a3c164f9ab..0e8ffc2f811 100644 --- a/src/main/java/spoon/reflect/declaration/CtAnnotatedElementType.java +++ b/src/main/java/spoon/reflect/declaration/CtAnnotatedElementType.java @@ -16,6 +16,9 @@ */ package spoon.reflect.declaration; + + + /** * This enum specifies the element type which is annotated by the annotation */ diff --git a/src/main/java/spoon/reflect/declaration/CtAnnotation.java b/src/main/java/spoon/reflect/declaration/CtAnnotation.java index 3ae6a8c5ba5..40750cd36f6 100644 --- a/src/main/java/spoon/reflect/declaration/CtAnnotation.java +++ b/src/main/java/spoon/reflect/declaration/CtAnnotation.java @@ -16,6 +16,12 @@ */ package spoon.reflect.declaration; + +import java.lang.annotation.Annotation; +import java.util.List; +import java.util.Map; +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; import spoon.reflect.code.CtExpression; import spoon.reflect.code.CtFieldAccess; import spoon.reflect.code.CtLiteral; @@ -24,17 +30,14 @@ import spoon.reflect.reference.CtTypeParameterReference; import spoon.reflect.reference.CtTypeReference; import spoon.support.DerivedProperty; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; import spoon.support.UnsettableProperty; -import java.lang.annotation.Annotation; -import java.util.List; -import java.util.Map; - import static spoon.reflect.path.CtRole.ANNOTATION_TYPE; import static spoon.reflect.path.CtRole.VALUE; + + + /** * This element represents an annotation on an element. * @@ -82,7 +85,7 @@ public interface CtAnnotation extends CtExpression, CtS * @return the value expression or null if not found. */ @PropertyGetter(role = VALUE) - T getValue(String key); + CtAnnotation getValue(String key); /** Returns the actual value of an annotation property */ @DerivedProperty @@ -134,7 +137,7 @@ public interface CtAnnotation extends CtExpression, CtS * reference to the type of this annotation */ @PropertySetter(role = ANNOTATION_TYPE) - > T setAnnotationType(CtTypeReference type); + CtAnnotation setAnnotationType(CtTypeReference type); /** * Set's this annotation's element names and their values. This is in the @@ -143,7 +146,7 @@ public interface CtAnnotation extends CtExpression, CtS * {@link spoon.reflect.reference.CtTypeReference}. */ @PropertySetter(role = VALUE) - > T setElementValues(Map values); + CtAnnotation setElementValues(Map values); /** * Set's this annotation's element names and their values. This is in the @@ -151,7 +154,7 @@ public interface CtAnnotation extends CtExpression, CtS * values. */ @PropertySetter(role = VALUE) - > T setValues(Map values); + CtAnnotation setValues(Map values); /** * Returns the element which is annotated by this annotation. @@ -159,7 +162,7 @@ public interface CtAnnotation extends CtExpression, CtS * @return annotated {@link spoon.reflect.declaration.CtElement} */ @DerivedProperty // the annotation is contained by the element not the other way around - CtElement getAnnotatedElement(); + CtAnnotation getAnnotatedElement(); /** * Returns the type of the element which is annotated by this annotation. @@ -173,38 +176,38 @@ public interface CtAnnotation extends CtExpression, CtS * Adds a new key-value pair for this annotation */ @PropertySetter(role = VALUE) - > T addValue(String elementName, Object value); + CtAnnotation addValue(String elementName, Object value); /** * Adds a new key-literal pair for this annotation. */ @PropertySetter(role = VALUE) - > T addValue(String elementName, CtLiteral value); + CtAnnotation addValue(String elementName, CtLiteral value); /** * Adds a new key-array pair for this annotation. */ @PropertySetter(role = VALUE) - > T addValue(String elementName, CtNewArray value); + CtAnnotation addValue(String elementName, CtNewArray value); /** * Adds a new key-field access pair for this annotation. */ @PropertySetter(role = VALUE) - > T addValue(String elementName, CtFieldAccess value); + CtAnnotation addValue(String elementName, CtFieldAccess value); /** * Adds a new key-annotation pair for this annotation. */ @PropertySetter(role = VALUE) - > T addValue(String elementName, CtAnnotation value); + CtAnnotation addValue(String elementName, CtAnnotation value); @Override CtAnnotation clone(); @Override @UnsettableProperty - > C setTypeCasts(List> types); + CtAnnotation setTypeCasts(List> types); static CtAnnotatedElementType getAnnotatedElementTypeForCtElement(CtElement element) { if (element == null) { diff --git a/src/main/java/spoon/reflect/declaration/CtAnnotationMethod.java b/src/main/java/spoon/reflect/declaration/CtAnnotationMethod.java index f8d57e60d5a..b9f5cdbb619 100644 --- a/src/main/java/spoon/reflect/declaration/CtAnnotationMethod.java +++ b/src/main/java/spoon/reflect/declaration/CtAnnotationMethod.java @@ -16,19 +16,21 @@ */ package spoon.reflect.declaration; -import spoon.reflect.code.CtBodyHolder; + +import java.util.List; +import java.util.Set; +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; import spoon.reflect.code.CtExpression; import spoon.reflect.code.CtStatement; import spoon.reflect.reference.CtTypeReference; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; import spoon.support.UnsettableProperty; -import java.util.List; -import java.util.Set; - import static spoon.reflect.path.CtRole.DEFAULT_EXPRESSION; + + + /** * This element defines an annotation method declared in an annotation type. */ @@ -43,24 +45,24 @@ public interface CtAnnotationMethod extends CtMethod { * Sets the default expression assigned to the annotation method. */ @PropertySetter(role = DEFAULT_EXPRESSION) - > C setDefaultExpression(CtExpression assignedExpression); + CtAnnotationMethod setDefaultExpression(CtExpression assignedExpression); @Override CtAnnotationMethod clone(); @Override @UnsettableProperty - T1 setBody(CtStatement body); + CtAnnotationMethod setBody(CtStatement body); @Override @UnsettableProperty - > T1 setThrownTypes(Set> thrownTypes); + CtAnnotationMethod setThrownTypes(Set> thrownTypes); @Override @UnsettableProperty - T setFormalCtTypeParameters(List formalTypeParameters); + CtAnnotationMethod setFormalCtTypeParameters(List formalTypeParameters); @Override @UnsettableProperty - > T1 setParameters(List> parameters); + CtAnnotationMethod setParameters(List> parameters); } diff --git a/src/main/java/spoon/reflect/declaration/CtAnnotationType.java b/src/main/java/spoon/reflect/declaration/CtAnnotationType.java index bd7e9ccfd53..a0efcf3835f 100644 --- a/src/main/java/spoon/reflect/declaration/CtAnnotationType.java +++ b/src/main/java/spoon/reflect/declaration/CtAnnotationType.java @@ -16,13 +16,16 @@ */ package spoon.reflect.declaration; -import spoon.reflect.reference.CtTypeReference; -import spoon.support.DerivedProperty; -import spoon.support.UnsettableProperty; import java.lang.annotation.Annotation; import java.util.List; import java.util.Set; +import spoon.reflect.reference.CtTypeReference; +import spoon.support.DerivedProperty; +import spoon.support.UnsettableProperty; + + + /** * This element defines an annotation type. @@ -40,28 +43,28 @@ public interface CtAnnotationType extends CtType { * The method passed as parameter must be a {@link CtAnnotationMethod}. */ @Override - > C addMethod(CtMethod method); + CtAnnotationType addMethod(CtMethod method); /** * {@inheritDoc} * The methods passed as parameter must be typed by {@link CtAnnotationMethod}. */ @Override - > C setMethods(Set> methods); + CtAnnotationType setMethods(Set> methods); @Override CtAnnotationType clone(); @Override @UnsettableProperty - T setFormalCtTypeParameters(List formalTypeParameters); + CtAnnotationType setFormalCtTypeParameters(List formalTypeParameters); @Override @UnsettableProperty - > C setSuperInterfaces(Set> interfaces); + CtAnnotationType setSuperInterfaces(Set> interfaces); @Override @UnsettableProperty - > C setSuperclass(CtTypeReference superClass); + CtAnnotationType setSuperclass(CtTypeReference superClass); } diff --git a/src/main/java/spoon/reflect/declaration/CtAnonymousExecutable.java b/src/main/java/spoon/reflect/declaration/CtAnonymousExecutable.java index e360661e563..2248a81005a 100644 --- a/src/main/java/spoon/reflect/declaration/CtAnonymousExecutable.java +++ b/src/main/java/spoon/reflect/declaration/CtAnonymousExecutable.java @@ -16,11 +16,14 @@ */ package spoon.reflect.declaration; -import spoon.reflect.reference.CtTypeReference; -import spoon.support.UnsettableProperty; import java.util.List; import java.util.Set; +import spoon.reflect.reference.CtTypeReference; +import spoon.support.UnsettableProperty; + + + /** * This element defines an anonymous executable block declaration in a class. @@ -33,26 +36,26 @@ public interface CtAnonymousExecutable extends CtExecutable, CtTypeMember @Override @UnsettableProperty - C setSimpleName(String simpleName); + CtAnonymousExecutable setSimpleName(String simpleName); @Override @UnsettableProperty - > T setThrownTypes(Set> thrownTypes); + CtAnonymousExecutable setThrownTypes(Set> thrownTypes); @Override @UnsettableProperty - > T setParameters(List> parameters); + CtAnonymousExecutable setParameters(List> parameters); @Override @UnsettableProperty - C setType(CtTypeReference type); + CtAnonymousExecutable setType(CtTypeReference type); @Override @UnsettableProperty - > T addParameter(CtParameter parameter); + CtAnonymousExecutable addParameter(CtParameter parameter); @Override @UnsettableProperty - > T addThrownType(CtTypeReference throwType); + CtAnonymousExecutable addThrownType(CtTypeReference throwType); } diff --git a/src/main/java/spoon/reflect/declaration/CtClass.java b/src/main/java/spoon/reflect/declaration/CtClass.java index 52a86f82b22..70c6d02d6ff 100644 --- a/src/main/java/spoon/reflect/declaration/CtClass.java +++ b/src/main/java/spoon/reflect/declaration/CtClass.java @@ -16,18 +16,21 @@ */ package spoon.reflect.declaration; + +import java.util.List; +import java.util.Set; +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; import spoon.reflect.code.CtStatement; import spoon.reflect.reference.CtTypeReference; import spoon.support.DerivedProperty; import spoon.support.UnsettableProperty; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; -import java.util.List; -import java.util.Set; - -import static spoon.reflect.path.CtRole.CONSTRUCTOR; import static spoon.reflect.path.CtRole.ANNONYMOUS_EXECUTABLE; +import static spoon.reflect.path.CtRole.CONSTRUCTOR; + + + /** * This element represents a class declaration. @@ -72,7 +75,7 @@ public interface CtClass extends CtType, CtStatement { * Sets the anonymous blocks of this class. */ @PropertySetter(role = ANNONYMOUS_EXECUTABLE) - > C setAnonymousExecutables(List e); + CtClass setAnonymousExecutables(List e); /** * Add an anonymous block to this class. @@ -81,7 +84,7 @@ public interface CtClass extends CtType, CtStatement { * @return true if this element changed as a result of the call */ @PropertySetter(role = ANNONYMOUS_EXECUTABLE) - > C addAnonymousExecutable(CtAnonymousExecutable e); + CtClass addAnonymousExecutable(CtAnonymousExecutable e); /** * Remove an anonymous block to this class. @@ -96,13 +99,13 @@ public interface CtClass extends CtType, CtStatement { * Sets the constructors for this class. */ @PropertySetter(role = CONSTRUCTOR) - > C setConstructors(Set> constructors); + CtClass setConstructors(Set> constructors); /** * Adds a constructor to this class. */ @PropertySetter(role = CONSTRUCTOR) - > C addConstructor(CtConstructor constructor); + CtClass addConstructor(CtConstructor constructor); /** * Removes a constructor from this class. @@ -137,5 +140,5 @@ public interface CtClass extends CtType, CtStatement { @Override @UnsettableProperty - C setLabel(String label); + CtClass setLabel(String label); } diff --git a/src/main/java/spoon/reflect/declaration/CtCodeSnippet.java b/src/main/java/spoon/reflect/declaration/CtCodeSnippet.java index ffa45a25f5c..e01e8975137 100644 --- a/src/main/java/spoon/reflect/declaration/CtCodeSnippet.java +++ b/src/main/java/spoon/reflect/declaration/CtCodeSnippet.java @@ -16,11 +16,15 @@ */ package spoon.reflect.declaration; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import static spoon.reflect.path.CtRole.SNIPPET; + + + /** * This interface represents snippets of source code that can be used in the AST * to represent complex code without having to build the corresponding program @@ -37,7 +41,7 @@ public interface CtCodeSnippet { * Sets the textual value of the code. */ @PropertySetter(role = SNIPPET) - C setValue(String value); + CtCodeSnippet setValue(String value); /** * Gets the textual value of the code. diff --git a/src/main/java/spoon/reflect/declaration/CtConstructor.java b/src/main/java/spoon/reflect/declaration/CtConstructor.java index 3519549022e..5f45e2426b1 100644 --- a/src/main/java/spoon/reflect/declaration/CtConstructor.java +++ b/src/main/java/spoon/reflect/declaration/CtConstructor.java @@ -16,12 +16,16 @@ */ package spoon.reflect.declaration; -import spoon.reflect.reference.CtTypeReference; + import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.reference.CtTypeReference; import spoon.support.UnsettableProperty; import static spoon.reflect.path.CtRole.NAME; + + + /** * This element defines a constructor declaration. */ @@ -39,9 +43,9 @@ public interface CtConstructor extends CtExecutable, CtTypeMember, CtForma @Override @UnsettableProperty - C setType(CtTypeReference type); + CtConstructor setType(CtTypeReference type); @Override @UnsettableProperty - C setSimpleName(String simpleName); + CtConstructor setSimpleName(String simpleName); } diff --git a/src/main/java/spoon/reflect/declaration/CtElement.java b/src/main/java/spoon/reflect/declaration/CtElement.java index 014720aeeda..550d00e48a8 100644 --- a/src/main/java/spoon/reflect/declaration/CtElement.java +++ b/src/main/java/spoon/reflect/declaration/CtElement.java @@ -16,7 +16,17 @@ */ package spoon.reflect.declaration; + +import java.io.Serializable; +import java.lang.annotation.Annotation; +import java.util.Collection; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; import spoon.processing.FactoryAccessor; +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; import spoon.reflect.code.CtComment; import spoon.reflect.cu.SourcePosition; import spoon.reflect.cu.SourcePositionHolder; @@ -28,22 +38,14 @@ import spoon.reflect.visitor.Root; import spoon.reflect.visitor.chain.CtQueryable; import spoon.support.DerivedProperty; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; - -import java.io.Serializable; -import java.lang.annotation.Annotation; -import java.util.Collection; -import java.util.Iterator; -import java.util.List; -import java.util.Map; -import java.util.Set; import static spoon.reflect.path.CtRole.ANNOTATION; -import static spoon.reflect.path.CtRole.COMMENT; import static spoon.reflect.path.CtRole.IS_IMPLICIT; import static spoon.reflect.path.CtRole.POSITION; + + + /** * This interface is the root interface for the metamodel elements (any program * element). @@ -157,7 +159,7 @@ CtAnnotation getAnnotation( * @return true if this element changed as a result of the call */ @PropertySetter(role = ANNOTATION) - E addAnnotation(CtAnnotation annotation); + CtElement addAnnotation(CtAnnotation annotation); /** * Remove an annotation for this element @@ -174,7 +176,7 @@ CtAnnotation getAnnotation( * {@link CtComment} or create a new javadoc {@link CtComment} if * no javadoc {@link CtComment} is available on this object. */ - E setDocComment(String docComment); + CtElement setDocComment(String docComment); /** * Sets the position in the Java source file. Note that this information is @@ -185,7 +187,7 @@ CtAnnotation getAnnotation( * of this element in the input source files */ @PropertySetter(role = POSITION) - E setPosition(SourcePosition position); + CtElement setPosition(SourcePosition position); /** * Gets the child elements annotated with the given annotation type's @@ -213,7 +215,7 @@ List getAnnotatedChildren( * Sets this element to be implicit. */ @PropertySetter(role = IS_IMPLICIT) - E setImplicit(boolean b); + CtElement setImplicit(boolean b); /** * Calculates and returns the set of all the types referenced by this @@ -236,13 +238,13 @@ List getAnnotatedChildren( * @param position * of this element and all children in the input source file */ - E setPositions(SourcePosition position); + CtElement setPositions(SourcePosition position); /** * Sets the annotations for this element. */ @PropertySetter(role = ANNOTATION) - E setAnnotations(List> annotation); + CtElement setAnnotations(List> annotation); /** * Gets the parent of current reference. @@ -304,12 +306,12 @@ List getAnnotatedChildren( /** * Saves a bunch of metadata inside an Element */ - E setAllMetadata(Map metadata); + CtElement setAllMetadata(Map metadata); /** * Saves metadata inside an Element. */ - E putMetadata(String key, Object val); + CtElement putMetadata(String key, Object val); /** * Retrieves metadata stored in an element. Returns null if it does not exist. @@ -330,7 +332,7 @@ List getAnnotatedChildren( * Set the comment list */ @PropertySetter(role = COMMENT) - E setComments(List comments); + CtElement setComments(List comments); /** * The list of comments @@ -345,14 +347,14 @@ List getAnnotatedChildren( * @param comment the comment */ @PropertySetter(role = COMMENT) - E addComment(CtComment comment); + CtElement addComment(CtComment comment); /** * Remove a comment * @param comment the comment to remove */ @PropertySetter(role = COMMENT) - E removeComment(CtComment comment); + CtElement removeComment(CtComment comment); /** * Clone the element which calls this method in a new object. @@ -378,7 +380,7 @@ List getAnnotatedChildren( * @param role the role of the field to be set * @param value to be assigned to this field. */ - E setValueByRole(CtRole role, T value); + < T> CtElement setValueByRole(CtRole role, T value); /** * Return the path from the model root to this CtElement, eg `.spoon.test.path.Foo.foo#body#statement[index=0]` diff --git a/src/main/java/spoon/reflect/declaration/CtEnum.java b/src/main/java/spoon/reflect/declaration/CtEnum.java index a2c5144fae3..293be91d4c4 100644 --- a/src/main/java/spoon/reflect/declaration/CtEnum.java +++ b/src/main/java/spoon/reflect/declaration/CtEnum.java @@ -16,15 +16,18 @@ */ package spoon.reflect.declaration; -import spoon.reflect.reference.CtTypeReference; + +import java.util.List; import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; +import spoon.reflect.reference.CtTypeReference; import spoon.support.UnsettableProperty; -import java.util.List; - import static spoon.reflect.path.CtRole.VALUE; + + + /** * This element represents an enumeration declaration. * @@ -43,7 +46,7 @@ public interface CtEnum> extends CtClass { * @return true if this element changed as a result of the call */ @PropertySetter(role = VALUE) - > C addEnumValue(CtEnumValue enumValue); + CtEnum addEnumValue(CtEnumValue enumValue); /** * Removes en enum value. @@ -77,16 +80,16 @@ public interface CtEnum> extends CtClass { *Sets all enum values of the enum. */ @PropertySetter(role = VALUE) - > C setEnumValues(List> enumValues); + CtEnum setEnumValues(List> enumValues); @Override CtEnum clone(); @Override @UnsettableProperty - T setFormalCtTypeParameters(List formalTypeParameters); + CtEnum setFormalCtTypeParameters(List formalTypeParameters); @Override @UnsettableProperty - > C setSuperclass(CtTypeReference superClass); + CtEnum setSuperclass(CtTypeReference superClass); } diff --git a/src/main/java/spoon/reflect/declaration/CtEnumValue.java b/src/main/java/spoon/reflect/declaration/CtEnumValue.java index 5bb150bfed1..68392e6c28a 100644 --- a/src/main/java/spoon/reflect/declaration/CtEnumValue.java +++ b/src/main/java/spoon/reflect/declaration/CtEnumValue.java @@ -16,10 +16,13 @@ */ package spoon.reflect.declaration; + import spoon.reflect.code.CtExpression; -import spoon.reflect.code.CtRHSReceiver; import spoon.support.UnsettableProperty; + + + /** * Corresponds to one enum value specified in an enumeration. * If the enum value implicitly calls a constructor (see example below), @@ -40,5 +43,5 @@ public interface CtEnumValue extends CtField { @Override @UnsettableProperty - > U setAssignment(CtExpression assignment); + CtEnumValue setAssignment(CtExpression assignment); } diff --git a/src/main/java/spoon/reflect/declaration/CtExecutable.java b/src/main/java/spoon/reflect/declaration/CtExecutable.java index 74f4e881b39..c180c3445a5 100644 --- a/src/main/java/spoon/reflect/declaration/CtExecutable.java +++ b/src/main/java/spoon/reflect/declaration/CtExecutable.java @@ -16,20 +16,23 @@ */ package spoon.reflect.declaration; + +import java.util.List; +import java.util.Set; +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; import spoon.reflect.code.CtBlock; import spoon.reflect.code.CtBodyHolder; import spoon.reflect.reference.CtExecutableReference; import spoon.reflect.reference.CtTypeReference; import spoon.support.DerivedProperty; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; - -import java.util.List; -import java.util.Set; import static spoon.reflect.path.CtRole.PARAMETER; import static spoon.reflect.path.CtRole.THROWN; + + + /** * This element represents an executable element such as a method, a * constructor, or an anonymous block. @@ -66,7 +69,7 @@ public interface CtExecutable extends CtNamedElement, CtTypedElement, CtBo * Sets the parameters. */ @PropertySetter(role = PARAMETER) - > T setParameters(List> parameters); + CtExecutable setParameters(List> parameters); /** * Add a parameter for this executable @@ -75,7 +78,7 @@ public interface CtExecutable extends CtNamedElement, CtTypedElement, CtBo * @return true if this element changed as a result of the call */ @PropertySetter(role = PARAMETER) - > T addParameter(CtParameter parameter); + CtExecutable addParameter(CtParameter parameter); /** * Remove a parameter for this executable @@ -96,7 +99,7 @@ public interface CtExecutable extends CtNamedElement, CtTypedElement, CtBo * Sets the thrown types. */ @PropertySetter(role = THROWN) - > T setThrownTypes(Set> thrownTypes); + CtExecutable setThrownTypes(Set> thrownTypes); /** * add a thrown type. @@ -105,7 +108,7 @@ public interface CtExecutable extends CtNamedElement, CtTypedElement, CtBo * @return true if this element changed as a result of the call */ @PropertySetter(role = THROWN) - > T addThrownType(CtTypeReference throwType); + CtExecutable addThrownType(CtTypeReference throwType); /** * remove a thrown type. diff --git a/src/main/java/spoon/reflect/declaration/CtField.java b/src/main/java/spoon/reflect/declaration/CtField.java index 767809b36a5..237b89b3d96 100644 --- a/src/main/java/spoon/reflect/declaration/CtField.java +++ b/src/main/java/spoon/reflect/declaration/CtField.java @@ -16,12 +16,16 @@ */ package spoon.reflect.declaration; + import spoon.reflect.code.CtExpression; import spoon.reflect.code.CtRHSReceiver; import spoon.reflect.reference.CtFieldReference; import spoon.support.DerivedProperty; import spoon.support.UnsettableProperty; + + + /** * This element defines a field declaration. */ @@ -50,7 +54,7 @@ public interface CtField extends CtVariable, CtTypeMember, CtRHSReceiver> U setAssignment(CtExpression assignment); + CtField setAssignment(CtExpression assignment); @Override CtField clone(); diff --git a/src/main/java/spoon/reflect/declaration/CtFormalTypeDeclarer.java b/src/main/java/spoon/reflect/declaration/CtFormalTypeDeclarer.java index 749711daec9..26782de33bb 100644 --- a/src/main/java/spoon/reflect/declaration/CtFormalTypeDeclarer.java +++ b/src/main/java/spoon/reflect/declaration/CtFormalTypeDeclarer.java @@ -16,13 +16,16 @@ */ package spoon.reflect.declaration; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; import java.util.List; +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; import static spoon.reflect.path.CtRole.TYPE_PARAMETER; + + + /** * This abstract element defines a declaration that accepts formal type * parameters (aka generics), such as a CtType (class A<E>), CtMethod or CtConstructor. @@ -39,13 +42,13 @@ public interface CtFormalTypeDeclarer extends CtTypeMember { * Sets the type parameters of this generic element. */ @PropertySetter(role = TYPE_PARAMETER) - T setFormalCtTypeParameters(List formalTypeParameters); + CtFormalTypeDeclarer setFormalCtTypeParameters(List formalTypeParameters); /** * Add a type parameter to this generic element. */ @PropertySetter(role = TYPE_PARAMETER) - T addFormalCtTypeParameter(CtTypeParameter formalTypeParameter); + CtFormalTypeDeclarer addFormalCtTypeParameter(CtTypeParameter formalTypeParameter); /** * Removes a type parameters from this generic element. diff --git a/src/main/java/spoon/reflect/declaration/CtImport.java b/src/main/java/spoon/reflect/declaration/CtImport.java index 788bb03b0bd..69b08943164 100644 --- a/src/main/java/spoon/reflect/declaration/CtImport.java +++ b/src/main/java/spoon/reflect/declaration/CtImport.java @@ -16,6 +16,7 @@ */ package spoon.reflect.declaration; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.reflect.reference.CtReference; @@ -23,6 +24,9 @@ import static spoon.reflect.path.CtRole.IMPORT_REFERENCE; + + + /** * This element represents an import declaration. * The given reference should be of type {@link spoon.reflect.reference.CtTypeReference}, @@ -58,7 +62,7 @@ public interface CtImport extends CtElement { * The import kind will be computed based on this reference. */ @PropertySetter(role = IMPORT_REFERENCE) - T setReference(CtReference reference); + CtImport setReference(CtReference reference); @Override CtImport clone(); diff --git a/src/main/java/spoon/reflect/declaration/CtImportKind.java b/src/main/java/spoon/reflect/declaration/CtImportKind.java index 2bc1fef8140..4767e5b8b1b 100644 --- a/src/main/java/spoon/reflect/declaration/CtImportKind.java +++ b/src/main/java/spoon/reflect/declaration/CtImportKind.java @@ -16,6 +16,9 @@ */ package spoon.reflect.declaration; + + + public enum CtImportKind { TYPE, ALL_TYPES, diff --git a/src/main/java/spoon/reflect/declaration/CtInterface.java b/src/main/java/spoon/reflect/declaration/CtInterface.java index 515f5e6a96e..a610ad3f36b 100644 --- a/src/main/java/spoon/reflect/declaration/CtInterface.java +++ b/src/main/java/spoon/reflect/declaration/CtInterface.java @@ -16,9 +16,13 @@ */ package spoon.reflect.declaration; + import spoon.reflect.reference.CtTypeReference; import spoon.support.UnsettableProperty; + + + /** * This element defines an interface declaration. */ @@ -28,5 +32,5 @@ public interface CtInterface extends CtType { @Override @UnsettableProperty - > C setSuperclass(CtTypeReference superClass); + CtInterface setSuperclass(CtTypeReference superClass); } diff --git a/src/main/java/spoon/reflect/declaration/CtMethod.java b/src/main/java/spoon/reflect/declaration/CtMethod.java index 06df7f6d6ef..70752ba48b3 100644 --- a/src/main/java/spoon/reflect/declaration/CtMethod.java +++ b/src/main/java/spoon/reflect/declaration/CtMethod.java @@ -16,15 +16,18 @@ */ package spoon.reflect.declaration; + +import java.util.Collection; import spoon.refactoring.Refactoring; import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; -import java.util.Collection; - import static spoon.reflect.path.CtRole.IS_DEFAULT; + + + /** * This element defines a method declaration. */ @@ -49,7 +52,7 @@ public interface CtMethod extends CtExecutable, CtTypeMember, CtFormalType * Sets the default value state of a method. */ @PropertySetter(role = IS_DEFAULT) - > C setDefaultMethod(boolean defaultMethod); + CtMethod setDefaultMethod(boolean defaultMethod); @Override CtMethod clone(); diff --git a/src/main/java/spoon/reflect/declaration/CtModifiable.java b/src/main/java/spoon/reflect/declaration/CtModifiable.java index c353d3bbe8b..a555828d42e 100644 --- a/src/main/java/spoon/reflect/declaration/CtModifiable.java +++ b/src/main/java/spoon/reflect/declaration/CtModifiable.java @@ -16,15 +16,18 @@ */ package spoon.reflect.declaration; + +import java.util.Set; import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.support.DerivedProperty; import spoon.support.reflect.CtExtendedModifier; -import java.util.Set; - import static spoon.reflect.path.CtRole.MODIFIER; + + + /** * This interface defines an element that accepts modifiers. */ @@ -53,7 +56,7 @@ public interface CtModifiable extends CtElement { * Sets the modifiers. */ @PropertySetter(role = MODIFIER) - T setModifiers(Set modifiers); + CtModifiable setModifiers(Set modifiers); /** * add a modifier @@ -61,7 +64,7 @@ public interface CtModifiable extends CtElement { * @param modifier */ @PropertySetter(role = MODIFIER) - T addModifier(ModifierKind modifier); + CtModifiable addModifier(ModifierKind modifier); /** * remove a modifier @@ -69,13 +72,13 @@ public interface CtModifiable extends CtElement { * @param modifier */ @PropertySetter(role = MODIFIER) - T removeModifier(ModifierKind modifier); + CtModifiable removeModifier(ModifierKind modifier); /** * Sets the visibility of this modifiable element (replaces old visibility). */ @PropertySetter(role = MODIFIER) - T setVisibility(ModifierKind visibility); + CtModifiable setVisibility(ModifierKind visibility); /** * Gets the visibility of this modifiable element. @@ -84,7 +87,7 @@ public interface CtModifiable extends CtElement { ModifierKind getVisibility(); Set getExtendedModifiers(); - T setExtendedModifiers(Set extendedModifiers); + CtModifiable setExtendedModifiers(Set extendedModifiers); /** * Returns true if it contains a public modifier (see {@link #hasModifier(ModifierKind)}) diff --git a/src/main/java/spoon/reflect/declaration/CtModule.java b/src/main/java/spoon/reflect/declaration/CtModule.java index 3a041477287..077f29ce4a3 100644 --- a/src/main/java/spoon/reflect/declaration/CtModule.java +++ b/src/main/java/spoon/reflect/declaration/CtModule.java @@ -16,13 +16,13 @@ */ package spoon.reflect.declaration; + +import java.util.List; import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.reflect.reference.CtModuleReference; import spoon.support.DerivedProperty; -import java.util.List; - import static spoon.reflect.path.CtRole.EXPORTED_PACKAGE; import static spoon.reflect.path.CtRole.MODIFIER; import static spoon.reflect.path.CtRole.MODULE_DIRECTIVE; @@ -32,6 +32,9 @@ import static spoon.reflect.path.CtRole.SERVICE_TYPE; import static spoon.reflect.path.CtRole.SUB_PACKAGE; + + + /** * Represents a Java module as defined in Java 9. * @@ -69,22 +72,22 @@ public interface CtModule extends CtNamedElement { boolean isOpenModule(); @PropertySetter(role = MODIFIER) - T setIsOpenModule(boolean openModule); + CtModule setIsOpenModule(boolean openModule); @PropertySetter(role = MODULE_DIRECTIVE) - T setModuleDirectives(List moduleDirectives); + CtModule setModuleDirectives(List moduleDirectives); @PropertySetter(role = MODULE_DIRECTIVE) - T addModuleDirective(CtModuleDirective moduleDirective); + CtModule addModuleDirective(CtModuleDirective moduleDirective); @PropertySetter(role = MODULE_DIRECTIVE) - T addModuleDirectiveAt(int position, CtModuleDirective moduleDirective); + CtModule addModuleDirectiveAt(int position, CtModuleDirective moduleDirective); @PropertyGetter(role = MODULE_DIRECTIVE) List getModuleDirectives(); @PropertySetter(role = MODULE_DIRECTIVE) - T removeModuleDirective(CtModuleDirective moduleDirective); + CtModule removeModuleDirective(CtModuleDirective moduleDirective); @PropertyGetter(role = SERVICE_TYPE) @DerivedProperty @@ -92,15 +95,15 @@ public interface CtModule extends CtNamedElement { @PropertySetter(role = SERVICE_TYPE) @DerivedProperty - T setUsedServices(List usedServices); + CtModule setUsedServices(List usedServices); @PropertySetter(role = SERVICE_TYPE) @DerivedProperty - T addUsedService(CtUsedService usedService); + CtModule addUsedService(CtUsedService usedService); @PropertySetter(role = SERVICE_TYPE) @DerivedProperty - T removeUsedService(CtUsedService usedService); + CtModule removeUsedService(CtUsedService usedService); @PropertyGetter(role = EXPORTED_PACKAGE) @DerivedProperty @@ -108,15 +111,15 @@ public interface CtModule extends CtNamedElement { @PropertySetter(role = EXPORTED_PACKAGE) @DerivedProperty - T setExportedPackages(List exportedPackages); + CtModule setExportedPackages(List exportedPackages); @PropertySetter(role = EXPORTED_PACKAGE) @DerivedProperty - T addExportedPackage(CtPackageExport exportedPackage); + CtModule addExportedPackage(CtPackageExport exportedPackage); @PropertySetter(role = EXPORTED_PACKAGE) @DerivedProperty - T removeExportedPackage(CtPackageExport exportedPackage); + CtModule removeExportedPackage(CtPackageExport exportedPackage); @PropertyGetter(role = OPENED_PACKAGE) @DerivedProperty @@ -124,15 +127,15 @@ public interface CtModule extends CtNamedElement { @PropertySetter(role = OPENED_PACKAGE) @DerivedProperty - T setOpenedPackages(List openedPackages); + CtModule setOpenedPackages(List openedPackages); @PropertySetter(role = OPENED_PACKAGE) @DerivedProperty - T addOpenedPackage(CtPackageExport openedPackage); + CtModule addOpenedPackage(CtPackageExport openedPackage); @PropertySetter(role = OPENED_PACKAGE) @DerivedProperty - T removeOpenedPackage(CtPackageExport openedPackage); + CtModule removeOpenedPackage(CtPackageExport openedPackage); @PropertyGetter(role = REQUIRED_MODULE) @DerivedProperty @@ -140,15 +143,15 @@ public interface CtModule extends CtNamedElement { @PropertySetter(role = REQUIRED_MODULE) @DerivedProperty - T setRequiredModules(List requiredModules); + CtModule setRequiredModules(List requiredModules); @PropertySetter(role = REQUIRED_MODULE) @DerivedProperty - T addRequiredModule(CtModuleRequirement requiredModule); + CtModule addRequiredModule(CtModuleRequirement requiredModule); @PropertySetter(role = REQUIRED_MODULE) @DerivedProperty - T removeRequiredModule(CtModuleRequirement requiredModule); + CtModule removeRequiredModule(CtModuleRequirement requiredModule); @PropertyGetter(role = PROVIDED_SERVICE) @DerivedProperty @@ -156,15 +159,15 @@ public interface CtModule extends CtNamedElement { @PropertySetter(role = PROVIDED_SERVICE) @DerivedProperty - T setProvidedServices(List providedServices); + CtModule setProvidedServices(List providedServices); @PropertySetter(role = PROVIDED_SERVICE) @DerivedProperty - T addProvidedService(CtProvidedService providedService); + CtModule addProvidedService(CtProvidedService providedService); @PropertySetter(role = PROVIDED_SERVICE) @DerivedProperty - T removeProvidedService(CtProvidedService providedService); + CtModule removeProvidedService(CtProvidedService providedService); /** * returns the root package of the unnamed module @@ -174,7 +177,7 @@ public interface CtModule extends CtNamedElement { CtPackage getRootPackage(); @PropertySetter(role = SUB_PACKAGE) - T setRootPackage(CtPackage rootPackage); + CtModule setRootPackage(CtPackage rootPackage); @DerivedProperty @Override diff --git a/src/main/java/spoon/reflect/declaration/CtModuleDirective.java b/src/main/java/spoon/reflect/declaration/CtModuleDirective.java index c2bc91ed0ea..5e9a31d5f57 100644 --- a/src/main/java/spoon/reflect/declaration/CtModuleDirective.java +++ b/src/main/java/spoon/reflect/declaration/CtModuleDirective.java @@ -16,6 +16,9 @@ */ package spoon.reflect.declaration; + + + /** * Represents a directive of a {@link CtModule} * diff --git a/src/main/java/spoon/reflect/declaration/CtModuleRequirement.java b/src/main/java/spoon/reflect/declaration/CtModuleRequirement.java index 0aa9688e726..44a29fcd07d 100644 --- a/src/main/java/spoon/reflect/declaration/CtModuleRequirement.java +++ b/src/main/java/spoon/reflect/declaration/CtModuleRequirement.java @@ -16,12 +16,15 @@ */ package spoon.reflect.declaration; + +import java.util.Set; import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.reflect.path.CtRole; import spoon.reflect.reference.CtModuleReference; -import java.util.Set; + + /** * Represents a require module in a Java module definition @@ -49,13 +52,13 @@ enum RequiresModifier { Set getRequiresModifiers(); @PropertySetter(role = CtRole.MODIFIER) - T setRequiresModifiers(Set requiresModifiers); + CtModuleRequirement setRequiresModifiers(Set requiresModifiers); @PropertyGetter(role = CtRole.MODULE_REF) CtModuleReference getModuleReference(); @PropertySetter(role = CtRole.MODULE_REF) - T setModuleReference(CtModuleReference moduleReference); + CtModuleRequirement setModuleReference(CtModuleReference moduleReference); @Override CtModuleRequirement clone(); diff --git a/src/main/java/spoon/reflect/declaration/CtMultiTypedElement.java b/src/main/java/spoon/reflect/declaration/CtMultiTypedElement.java index 5a268962de9..1415b99782c 100644 --- a/src/main/java/spoon/reflect/declaration/CtMultiTypedElement.java +++ b/src/main/java/spoon/reflect/declaration/CtMultiTypedElement.java @@ -16,14 +16,17 @@ */ package spoon.reflect.declaration; -import spoon.reflect.reference.CtTypeReference; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; import java.util.List; +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; +import spoon.reflect.reference.CtTypeReference; import static spoon.reflect.path.CtRole.MULTI_TYPE; + + + /** * Defined an element with several types. */ @@ -32,7 +35,7 @@ public interface CtMultiTypedElement extends CtElement { * Adds a type for the element. */ @PropertySetter(role = MULTI_TYPE) - T addMultiType(CtTypeReference ref); + CtMultiTypedElement addMultiType(CtTypeReference ref); /** * Removes a type for the element. @@ -50,5 +53,5 @@ public interface CtMultiTypedElement extends CtElement { * Adds a type for the element. */ @PropertySetter(role = MULTI_TYPE) - T setMultiTypes(List> types); + CtMultiTypedElement setMultiTypes(List> types); } diff --git a/src/main/java/spoon/reflect/declaration/CtNamedElement.java b/src/main/java/spoon/reflect/declaration/CtNamedElement.java index dbc35e9d04a..ed3e3d02ca1 100644 --- a/src/main/java/spoon/reflect/declaration/CtNamedElement.java +++ b/src/main/java/spoon/reflect/declaration/CtNamedElement.java @@ -16,13 +16,17 @@ */ package spoon.reflect.declaration; -import spoon.reflect.reference.CtReference; -import spoon.support.DerivedProperty; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; +import spoon.reflect.reference.CtReference; +import spoon.support.DerivedProperty; import static spoon.reflect.path.CtRole.NAME; + + + /** * Declares an element that has a name (a class, a method, a variable, etc). * Hence, all subclasses of CtNamedElement are in package "declaration". @@ -40,7 +44,7 @@ public interface CtNamedElement extends CtElement { * Sets the simple (unqualified) name of this element. */ @PropertySetter(role = NAME) - T setSimpleName(String simpleName); + CtNamedElement setSimpleName(String simpleName); /** * Returns the corresponding reference. diff --git a/src/main/java/spoon/reflect/declaration/CtPackage.java b/src/main/java/spoon/reflect/declaration/CtPackage.java index ebb07461e95..0d17214774d 100644 --- a/src/main/java/spoon/reflect/declaration/CtPackage.java +++ b/src/main/java/spoon/reflect/declaration/CtPackage.java @@ -16,15 +16,18 @@ */ package spoon.reflect.declaration; -import spoon.reflect.reference.CtPackageReference; -import spoon.support.DerivedProperty; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; import java.util.Set; +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; +import spoon.reflect.reference.CtPackageReference; +import spoon.support.DerivedProperty; -import static spoon.reflect.path.CtRole.SUB_PACKAGE; import static spoon.reflect.path.CtRole.CONTAINED_TYPE; +import static spoon.reflect.path.CtRole.SUB_PACKAGE; + + + /** * This element defines a package declaration. The packages are represented by a @@ -108,7 +111,7 @@ public interface CtPackage extends CtNamedElement, CtShadowable { * Adds a type to this package. */ @PropertySetter(role = CONTAINED_TYPE) - T addType(CtType type); + CtPackage addType(CtType type); /** * Removes a type from this package. @@ -123,7 +126,7 @@ public interface CtPackage extends CtNamedElement, CtShadowable { * new set of child packages */ @PropertySetter(role = SUB_PACKAGE) - T setPackages(Set pack); + CtPackage setPackages(Set pack); /** * add a subpackage @@ -132,7 +135,7 @@ public interface CtPackage extends CtNamedElement, CtShadowable { * @return true if this element changed as a result of the call */ @PropertySetter(role = SUB_PACKAGE) - T addPackage(CtPackage pack); + CtPackage addPackage(CtPackage pack); /** * remove a subpackage @@ -150,7 +153,7 @@ public interface CtPackage extends CtNamedElement, CtShadowable { * new Set of types */ @PropertySetter(role = CONTAINED_TYPE) - T setTypes(Set> types); + CtPackage setTypes(Set> types); @Override CtPackage clone(); diff --git a/src/main/java/spoon/reflect/declaration/CtPackageExport.java b/src/main/java/spoon/reflect/declaration/CtPackageExport.java index 78c00442272..5ae88f97eae 100644 --- a/src/main/java/spoon/reflect/declaration/CtPackageExport.java +++ b/src/main/java/spoon/reflect/declaration/CtPackageExport.java @@ -16,15 +16,19 @@ */ package spoon.reflect.declaration; + +import java.util.List; import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.reflect.path.CtRole; import spoon.reflect.reference.CtModuleReference; import spoon.reflect.reference.CtPackageReference; -import java.util.List; -/** + + + +public/** * Represents an exported or opened package in a Java module * * The exports directive specifies the name of a package to be exported by the current module. @@ -49,10 +53,10 @@ * opens com.example.foo.quux; * */ -public interface CtPackageExport extends CtModuleDirective { +interface CtPackageExport extends CtModuleDirective { @PropertySetter(role = CtRole.OPENED_PACKAGE) - T setOpenedPackage(boolean openedPackage); + CtPackageExport setOpenedPackage(boolean openedPackage); @PropertyGetter(role = CtRole.OPENED_PACKAGE) boolean isOpenedPackage(); @@ -61,16 +65,16 @@ public interface CtPackageExport extends CtModuleDirective { CtPackageReference getPackageReference(); @PropertySetter(role = CtRole.PACKAGE_REF) - T setPackageReference(CtPackageReference packageReference); + CtPackageExport setPackageReference(CtPackageReference packageReference); @PropertyGetter(role = CtRole.MODULE_REF) List getTargetExport(); @PropertySetter(role = CtRole.MODULE_REF) - T setTargetExport(List targetExport); + CtPackageExport setTargetExport(List targetExport); @PropertySetter(role = CtRole.MODULE_REF) - T addTargetExport(CtModuleReference targetExport); + CtPackageExport addTargetExport(CtModuleReference targetExport); @Override CtPackageExport clone(); diff --git a/src/main/java/spoon/reflect/declaration/CtParameter.java b/src/main/java/spoon/reflect/declaration/CtParameter.java index 931d93a6004..0525ad373b8 100644 --- a/src/main/java/spoon/reflect/declaration/CtParameter.java +++ b/src/main/java/spoon/reflect/declaration/CtParameter.java @@ -16,15 +16,19 @@ */ package spoon.reflect.declaration; + +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; import spoon.reflect.code.CtExpression; import spoon.reflect.reference.CtParameterReference; import spoon.support.DerivedProperty; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; import spoon.support.UnsettableProperty; import static spoon.reflect.path.CtRole.IS_VARARGS; + + + /** * This element defines an executable parameter declaration. * @@ -54,7 +58,7 @@ public interface CtParameter extends CtVariable, CtShadowable { * Sets this parameter to have varargs. */ @PropertySetter(role = IS_VARARGS) - > C setVarArgs(boolean varArgs); + CtParameter setVarArgs(boolean varArgs); /** overriding the return type */ @Override @@ -66,5 +70,5 @@ public interface CtParameter extends CtVariable, CtShadowable { @Override @UnsettableProperty - > C setDefaultExpression(CtExpression assignedExpression); + CtParameter setDefaultExpression(CtExpression assignedExpression); } diff --git a/src/main/java/spoon/reflect/declaration/CtProvidedService.java b/src/main/java/spoon/reflect/declaration/CtProvidedService.java index b5ccb2c891e..7fe1e437faa 100644 --- a/src/main/java/spoon/reflect/declaration/CtProvidedService.java +++ b/src/main/java/spoon/reflect/declaration/CtProvidedService.java @@ -16,14 +16,18 @@ */ package spoon.reflect.declaration; + +import java.util.List; import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.reflect.path.CtRole; import spoon.reflect.reference.CtTypeReference; -import java.util.List; -/** + + + +public/** * Represents a provided service in a {@link CtModule}. * The provides directive specifies a service for which the with clause specifies one or more service providers to java.util.ServiceLoader. * The service must be a class type, an interface type, or an annotation type. It is a compile-time error if a provides directive specifies an enum type as the service. @@ -40,22 +44,22 @@ * provides com.example.foo.spi.Itf with com.example.foo.Impl; * */ -public interface CtProvidedService extends CtModuleDirective { +interface CtProvidedService extends CtModuleDirective { @PropertyGetter(role = CtRole.SERVICE_TYPE) CtTypeReference getServiceType(); @PropertySetter(role = CtRole.SERVICE_TYPE) - T setServiceType(CtTypeReference providingType); + CtProvidedService setServiceType(CtTypeReference providingType); @PropertyGetter(role = CtRole.IMPLEMENTATION_TYPE) List getImplementationTypes(); @PropertySetter(role = CtRole.IMPLEMENTATION_TYPE) - T setImplementationTypes(List usedTypes); + CtProvidedService setImplementationTypes(List usedTypes); @PropertySetter(role = CtRole.IMPLEMENTATION_TYPE) - T addImplementationType(CtTypeReference usedType); + CtProvidedService addImplementationType(CtTypeReference usedType); @Override CtProvidedService clone(); diff --git a/src/main/java/spoon/reflect/declaration/CtShadowable.java b/src/main/java/spoon/reflect/declaration/CtShadowable.java index 6af471f00a2..ba80fd7717e 100644 --- a/src/main/java/spoon/reflect/declaration/CtShadowable.java +++ b/src/main/java/spoon/reflect/declaration/CtShadowable.java @@ -16,12 +16,16 @@ */ package spoon.reflect.declaration; -import spoon.reflect.reference.CtTypeReference; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; +import spoon.reflect.reference.CtTypeReference; import static spoon.reflect.path.CtRole.IS_SHADOW; + + + /** A shadow element is an element that is in the Spoon model, but does not exist in the actual source code. * The goal of shadow elements is to simplify transformations. */ @@ -42,5 +46,5 @@ public interface CtShadowable { * {@link #isShadow()}. */ @PropertySetter(role = IS_SHADOW) - E setShadow(boolean isShadow); + CtShadowable setShadow(boolean isShadow); } diff --git a/src/main/java/spoon/reflect/declaration/CtType.java b/src/main/java/spoon/reflect/declaration/CtType.java index aa9f6c4d9f4..10b95352ee0 100644 --- a/src/main/java/spoon/reflect/declaration/CtType.java +++ b/src/main/java/spoon/reflect/declaration/CtType.java @@ -16,22 +16,25 @@ */ package spoon.reflect.declaration; -import spoon.reflect.reference.CtTypeReference; -import spoon.support.DerivedProperty; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; import java.util.List; import java.util.Set; +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; +import spoon.reflect.reference.CtTypeReference; +import spoon.support.DerivedProperty; -import static spoon.reflect.path.CtRole.METHOD; import static spoon.reflect.path.CtRole.FIELD; import static spoon.reflect.path.CtRole.INTERFACE; +import static spoon.reflect.path.CtRole.METHOD; import static spoon.reflect.path.CtRole.NAME; import static spoon.reflect.path.CtRole.NESTED_TYPE; import static spoon.reflect.path.CtRole.SUPER_TYPE; import static spoon.reflect.path.CtRole.TYPE_MEMBER; + + + /** * This abstract element defines a super-type for classes and interfaces, which * can declare methods. @@ -138,7 +141,7 @@ public interface CtType extends CtNamedElement, CtTypeInformation, CtTypeMemb * @return true if the field is added. */ @PropertySetter(role = FIELD) - > C addFieldAtTop(CtField field); + CtType addFieldAtTop(CtField field); /** * add a field at the end of the field list. @@ -147,7 +150,7 @@ public interface CtType extends CtNamedElement, CtTypeInformation, CtTypeMemb * @return true if this element changed as a result of the call */ @PropertySetter(role = FIELD) - > C addField(CtField field); + CtType addField(CtField field); /** * add a field at a given position. @@ -156,13 +159,13 @@ public interface CtType extends CtNamedElement, CtTypeInformation, CtTypeMemb * @return true if this element changed as a result of the call */ @PropertySetter(role = FIELD) - > C addField(int index, CtField field); + CtType addField(int index, CtField field); /** * Sets all fields in the type. */ @PropertySetter(role = FIELD) - > C setFields(List> fields); + CtType setFields(List> fields); /** * remove a Field @@ -180,7 +183,7 @@ public interface CtType extends CtNamedElement, CtTypeInformation, CtTypeMemb * @return true if this element changed as a result of the call */ @PropertySetter(role = NESTED_TYPE) - > C addNestedType(CtType nestedType); + CtType addNestedType(CtType nestedType); /** * Remove a nested type. @@ -195,7 +198,7 @@ public interface CtType extends CtNamedElement, CtTypeInformation, CtTypeMemb * Sets all nested types. */ @PropertySetter(role = NESTED_TYPE) - > C setNestedTypes(Set> nestedTypes); + CtType setNestedTypes(Set> nestedTypes); /** * Replace all the code snippets that are found in this type by the corresponding Spoon AST. @@ -276,13 +279,13 @@ public interface CtType extends CtNamedElement, CtTypeInformation, CtTypeMemb * Sets the methods of this type. */ @PropertySetter(role = METHOD) - > C setMethods(Set> methods); + CtType setMethods(Set> methods); /** * Adds a method to this type. */ @PropertySetter(role = METHOD) - > C addMethod(CtMethod method); + CtType addMethod(CtMethod method); /** * Removes a method from this type. @@ -294,20 +297,20 @@ public interface CtType extends CtNamedElement, CtTypeInformation, CtTypeMemb * Sets the superclass type. */ @PropertySetter(role = SUPER_TYPE) - > C setSuperclass(CtTypeReference superClass); + CtType setSuperclass(CtTypeReference superClass); /** * Sets the super interfaces of this type. */ @PropertySetter(role = INTERFACE) - > C setSuperInterfaces(Set> interfaces); + CtType setSuperInterfaces(Set> interfaces); /** * @param interfac * @return true if this element changed as a result of the call */ @PropertySetter(role = INTERFACE) - > C addSuperInterface(CtTypeReference interfac); + CtType addSuperInterface(CtTypeReference interfac); /** * @param interfac @@ -326,14 +329,14 @@ public interface CtType extends CtNamedElement, CtTypeInformation, CtTypeMemb * Adds a type member at the end of all type member of the type. */ @PropertySetter(role = TYPE_MEMBER) - > C addTypeMember(CtTypeMember member); + CtType addTypeMember(CtTypeMember member); /** * Adds a type member at a given position. Think to use this method if the order is * important for you. */ @PropertySetter(role = TYPE_MEMBER) - > C addTypeMemberAt(int position, CtTypeMember member); + CtType addTypeMemberAt(int position, CtTypeMember member); /** * Removes the type member. @@ -345,7 +348,7 @@ public interface CtType extends CtNamedElement, CtTypeInformation, CtTypeMemb * Removes all types members with these new members. */ @PropertySetter(role = TYPE_MEMBER) - > C setTypeMembers(List members); + CtType setTypeMembers(List members); @Override CtType clone(); diff --git a/src/main/java/spoon/reflect/declaration/CtTypeInformation.java b/src/main/java/spoon/reflect/declaration/CtTypeInformation.java index f63cb1a72ac..fdc9f4c79bd 100644 --- a/src/main/java/spoon/reflect/declaration/CtTypeInformation.java +++ b/src/main/java/spoon/reflect/declaration/CtTypeInformation.java @@ -16,19 +16,22 @@ */ package spoon.reflect.declaration; + +import java.util.Collection; +import java.util.Set; +import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.reference.CtExecutableReference; import spoon.reflect.reference.CtFieldReference; import spoon.reflect.reference.CtTypeReference; import spoon.support.DerivedProperty; -import spoon.reflect.annotations.PropertyGetter; - -import java.util.Collection; -import java.util.Set; import static spoon.reflect.path.CtRole.INTERFACE; import static spoon.reflect.path.CtRole.MODIFIER; import static spoon.reflect.path.CtRole.SUPER_TYPE; + + + /** * Returns information that can be obtained both at compile-time and run-time * diff --git a/src/main/java/spoon/reflect/declaration/CtTypeMember.java b/src/main/java/spoon/reflect/declaration/CtTypeMember.java index f04b7300cb2..48221df9ef9 100644 --- a/src/main/java/spoon/reflect/declaration/CtTypeMember.java +++ b/src/main/java/spoon/reflect/declaration/CtTypeMember.java @@ -16,8 +16,12 @@ */ package spoon.reflect.declaration; + import spoon.support.DerivedProperty; + + + /** * This interface represents a member of a class (field, method, * nested class or static/instance initializer). diff --git a/src/main/java/spoon/reflect/declaration/CtTypeParameter.java b/src/main/java/spoon/reflect/declaration/CtTypeParameter.java index 904e7c762f0..bae207f5fad 100644 --- a/src/main/java/spoon/reflect/declaration/CtTypeParameter.java +++ b/src/main/java/spoon/reflect/declaration/CtTypeParameter.java @@ -16,13 +16,16 @@ */ package spoon.reflect.declaration; + +import java.util.List; +import java.util.Set; import spoon.reflect.reference.CtTypeParameterReference; import spoon.reflect.reference.CtTypeReference; import spoon.support.DerivedProperty; import spoon.support.UnsettableProperty; -import java.util.List; -import java.util.Set; + + /** * This element defines a declaration of a type parameter (aka generics). @@ -46,45 +49,45 @@ public interface CtTypeParameter extends CtType { @Override @UnsettableProperty - T setFormalCtTypeParameters(List formalTypeParameters); + CtTypeParameter setFormalCtTypeParameters(List formalTypeParameters); @Override @UnsettableProperty - > C setSuperInterfaces(Set> interfaces); + CtTypeParameter setSuperInterfaces(Set> interfaces); @Override @UnsettableProperty - > C addSuperInterface(CtTypeReference interfac); + CtTypeParameter addSuperInterface(CtTypeReference interfac); @Override @UnsettableProperty - > C setTypeMembers(List members); + CtTypeParameter setTypeMembers(List members); @Override @UnsettableProperty - > C setFields(List> fields); + CtTypeParameter setFields(List> fields); @Override @UnsettableProperty - > C setMethods(Set> methods); + CtTypeParameter setMethods(Set> methods); @Override @UnsettableProperty - > C addMethod(CtMethod method); + CtTypeParameter addMethod(CtMethod method); @Override @UnsettableProperty - > C setNestedTypes(Set> nestedTypes); + CtTypeParameter setNestedTypes(Set> nestedTypes); @Override @UnsettableProperty - > C addNestedType(CtType nestedType); + CtTypeParameter addNestedType(CtType nestedType); @Override @UnsettableProperty - > C addFieldAtTop(CtField field); + CtTypeParameter addFieldAtTop(CtField field); @Override @UnsettableProperty - T setModifiers(Set modifiers); + CtTypeParameter setModifiers(Set modifiers); } diff --git a/src/main/java/spoon/reflect/declaration/CtTypedElement.java b/src/main/java/spoon/reflect/declaration/CtTypedElement.java index 2b7585aab78..737807f7f8a 100644 --- a/src/main/java/spoon/reflect/declaration/CtTypedElement.java +++ b/src/main/java/spoon/reflect/declaration/CtTypedElement.java @@ -16,12 +16,16 @@ */ package spoon.reflect.declaration; -import spoon.reflect.reference.CtTypeReference; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; +import spoon.reflect.reference.CtTypeReference; import static spoon.reflect.path.CtRole.TYPE; + + + /** * This abstract element defines a typed element. */ @@ -36,5 +40,5 @@ public interface CtTypedElement extends CtElement { * Sets this element's type. */ @PropertySetter(role = TYPE) - C setType(CtTypeReference type); + CtTypedElement setType(CtTypeReference type); } diff --git a/src/main/java/spoon/reflect/declaration/CtUsedService.java b/src/main/java/spoon/reflect/declaration/CtUsedService.java index 0040523fe24..8e6d7b91a99 100644 --- a/src/main/java/spoon/reflect/declaration/CtUsedService.java +++ b/src/main/java/spoon/reflect/declaration/CtUsedService.java @@ -16,11 +16,15 @@ */ package spoon.reflect.declaration; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.reflect.path.CtRole; import spoon.reflect.reference.CtTypeReference; + + + /** * Represents the declaration of a used service in a {@link CtModule} * @@ -40,7 +44,7 @@ public interface CtUsedService extends CtModuleDirective { CtTypeReference getServiceType(); @PropertySetter(role = CtRole.SERVICE_TYPE) - T setServiceType(CtTypeReference providingType); + CtUsedService setServiceType(CtTypeReference providingType); @Override CtUsedService clone(); diff --git a/src/main/java/spoon/reflect/declaration/CtVariable.java b/src/main/java/spoon/reflect/declaration/CtVariable.java index 73c4477e41e..3b49341b927 100644 --- a/src/main/java/spoon/reflect/declaration/CtVariable.java +++ b/src/main/java/spoon/reflect/declaration/CtVariable.java @@ -16,14 +16,18 @@ */ package spoon.reflect.declaration; + +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; import spoon.reflect.code.CtExpression; import spoon.reflect.reference.CtVariableReference; import spoon.support.DerivedProperty; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; import static spoon.reflect.path.CtRole.DEFAULT_EXPRESSION; + + + /** * This abstract element defines a variable declaration. */ @@ -49,5 +53,5 @@ public interface CtVariable extends CtNamedElement, CtTypedElement, CtModi * declared. */ @PropertySetter(role = DEFAULT_EXPRESSION) - > C setDefaultExpression(CtExpression assignedExpression); + CtVariable setDefaultExpression(CtExpression assignedExpression); } diff --git a/src/main/java/spoon/reflect/declaration/ModifierKind.java b/src/main/java/spoon/reflect/declaration/ModifierKind.java index f0535319918..dfb384b62a0 100644 --- a/src/main/java/spoon/reflect/declaration/ModifierKind.java +++ b/src/main/java/spoon/reflect/declaration/ModifierKind.java @@ -16,6 +16,12 @@ */ package spoon.reflect.declaration; + +import java.util.Locale; + + + + /** * Represents a modifier on the declaration of a program element such as a * class, method, or field. diff --git a/src/main/java/spoon/reflect/declaration/ParentNotInitializedException.java b/src/main/java/spoon/reflect/declaration/ParentNotInitializedException.java index dfc404742b3..b24537f784f 100644 --- a/src/main/java/spoon/reflect/declaration/ParentNotInitializedException.java +++ b/src/main/java/spoon/reflect/declaration/ParentNotInitializedException.java @@ -16,8 +16,12 @@ */ package spoon.reflect.declaration; + import spoon.SpoonException; + + + /** * This exception is thrown when the parent of an element has not been correctly * initialized. diff --git a/src/main/java/spoon/reflect/reference/CtActualTypeContainer.java b/src/main/java/spoon/reflect/reference/CtActualTypeContainer.java index 21a2c9980d3..2ba0f964f2f 100644 --- a/src/main/java/spoon/reflect/reference/CtActualTypeContainer.java +++ b/src/main/java/spoon/reflect/reference/CtActualTypeContainer.java @@ -16,11 +16,14 @@ */ package spoon.reflect.reference; + +import java.util.List; import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.reflect.path.CtRole; -import java.util.List; + + /** @@ -37,12 +40,12 @@ public interface CtActualTypeContainer { * Sets the type arguments. */ @PropertySetter(role = CtRole.TYPE_ARGUMENT) - T setActualTypeArguments(List> actualTypeArguments); + CtActualTypeContainer setActualTypeArguments(List> actualTypeArguments); /** * Adds a type argument. */ - T addActualTypeArgument(CtTypeReference actualTypeArgument); + CtActualTypeContainer addActualTypeArgument(CtTypeReference actualTypeArgument); /** * Removes a type argument. diff --git a/src/main/java/spoon/reflect/reference/CtArrayTypeReference.java b/src/main/java/spoon/reflect/reference/CtArrayTypeReference.java index 747a768471c..b331fef0d70 100644 --- a/src/main/java/spoon/reflect/reference/CtArrayTypeReference.java +++ b/src/main/java/spoon/reflect/reference/CtArrayTypeReference.java @@ -16,6 +16,7 @@ */ package spoon.reflect.reference; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.reflect.path.CtRole; @@ -23,6 +24,9 @@ import spoon.support.UnsettableProperty; + + + /** * This interface defines a reference to an array. */ @@ -42,13 +46,13 @@ public interface CtArrayTypeReference extends CtTypeReference { * this method returns a type reference to "int". */ @DerivedProperty - CtTypeReference getArrayType(); + CtArrayTypeReference getArrayType(); /** * Sets the type of the elements contained in this array. */ @PropertySetter(role = CtRole.TYPE) - > C setComponentType(CtTypeReference componentType); + CtArrayTypeReference setComponentType(CtTypeReference componentType); /** * Returns the number of dimensions of this array type. This corresponds to @@ -71,7 +75,7 @@ public interface CtArrayTypeReference extends CtTypeReference { */ @UnsettableProperty @Override - T setSimpleName(String simpleName); + CtArrayTypeReference setSimpleName(String simpleName); @Override CtArrayTypeReference clone(); diff --git a/src/main/java/spoon/reflect/reference/CtCatchVariableReference.java b/src/main/java/spoon/reflect/reference/CtCatchVariableReference.java index 32aef6bbf77..1910b17af52 100644 --- a/src/main/java/spoon/reflect/reference/CtCatchVariableReference.java +++ b/src/main/java/spoon/reflect/reference/CtCatchVariableReference.java @@ -16,9 +16,13 @@ */ package spoon.reflect.reference; + import spoon.reflect.code.CtCatchVariable; import spoon.support.DerivedProperty; + + + /** * This interface defines a reference to {@link spoon.reflect.code.CtCatchVariable}. */ diff --git a/src/main/java/spoon/reflect/reference/CtExecutableReference.java b/src/main/java/spoon/reflect/reference/CtExecutableReference.java index 77fb9503ed2..7d56a5a3002 100644 --- a/src/main/java/spoon/reflect/reference/CtExecutableReference.java +++ b/src/main/java/spoon/reflect/reference/CtExecutableReference.java @@ -16,15 +16,18 @@ */ package spoon.reflect.reference; + +import java.lang.reflect.Constructor; +import java.lang.reflect.Method; +import java.util.List; import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.reflect.declaration.CtExecutable; import spoon.reflect.path.CtRole; import spoon.support.DerivedProperty; -import java.lang.reflect.Constructor; -import java.lang.reflect.Method; -import java.util.List; + + /** @@ -99,7 +102,7 @@ public interface CtExecutableReference extends CtReference, CtActualTypeConta * Sets parameters of the executable. */ @PropertySetter(role = CtRole.ARGUMENT_TYPE) - > C setParameters(List> parameters); + CtExecutableReference setParameters(List> parameters); /** * Returns true if this executable overrides the given @@ -140,19 +143,19 @@ public interface CtExecutableReference extends CtReference, CtActualTypeConta * Sets the declaring type. */ @PropertySetter(role = CtRole.DECLARING_TYPE) - > C setDeclaringType(CtTypeReference declaringType); + CtExecutableReference setDeclaringType(CtTypeReference declaringType); /** * Sets this executable reference to be static or not. */ @PropertySetter(role = CtRole.IS_STATIC) - > C setStatic(boolean b); + CtExecutableReference setStatic(boolean b); /** * Sets the type of the variable. */ @PropertySetter(role = CtRole.TYPE) - > C setType(CtTypeReference type); + CtExecutableReference setType(CtTypeReference type); /** * Tells if the referenced executable is final. diff --git a/src/main/java/spoon/reflect/reference/CtFieldReference.java b/src/main/java/spoon/reflect/reference/CtFieldReference.java index 222176baa75..e4cc9d72812 100644 --- a/src/main/java/spoon/reflect/reference/CtFieldReference.java +++ b/src/main/java/spoon/reflect/reference/CtFieldReference.java @@ -16,13 +16,16 @@ */ package spoon.reflect.reference; + +import java.lang.reflect.Member; import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.reflect.declaration.CtField; import spoon.reflect.path.CtRole; import spoon.support.DerivedProperty; -import java.lang.reflect.Member; + + /** @@ -78,19 +81,19 @@ public interface CtFieldReference extends CtVariableReference { * Sets the type in which the field is declared. */ @PropertySetter(role = CtRole.DECLARING_TYPE) - > C setDeclaringType(CtTypeReference declaringType); + CtFieldReference setDeclaringType(CtTypeReference declaringType); /** * Forces a reference to a final element. */ @PropertySetter(role = CtRole.IS_FINAL) - > C setFinal(boolean b); + CtFieldReference setFinal(boolean b); /** * Forces a reference to a static element. */ @PropertySetter(role = CtRole.IS_STATIC) - > C setStatic(boolean b); + CtFieldReference setStatic(boolean b); @Override CtFieldReference clone(); diff --git a/src/main/java/spoon/reflect/reference/CtIntersectionTypeReference.java b/src/main/java/spoon/reflect/reference/CtIntersectionTypeReference.java index bc9bf0322ba..9ae5a686956 100644 --- a/src/main/java/spoon/reflect/reference/CtIntersectionTypeReference.java +++ b/src/main/java/spoon/reflect/reference/CtIntersectionTypeReference.java @@ -16,13 +16,16 @@ */ package spoon.reflect.reference; -import spoon.reflect.annotations.PropertyGetter; -import spoon.reflect.annotations.PropertySetter; import java.util.List; +import spoon.reflect.annotations.PropertyGetter; +import spoon.reflect.annotations.PropertySetter; import static spoon.reflect.path.CtRole.BOUND; + + + /** * This interface defines a reference to an intersection type in generics or in casts. */ @@ -40,13 +43,13 @@ public interface CtIntersectionTypeReference extends CtTypeReference { * Sets the bounds of the intersection type. */ @PropertySetter(role = BOUND) - C setBounds(List> bounds); + CtIntersectionTypeReference setBounds(List> bounds); /** * Adds a bound. */ @PropertySetter(role = BOUND) - C addBound(CtTypeReference bound); + CtIntersectionTypeReference addBound(CtTypeReference bound); /** * Removes a bound. diff --git a/src/main/java/spoon/reflect/reference/CtLocalVariableReference.java b/src/main/java/spoon/reflect/reference/CtLocalVariableReference.java index 0478c92eaf8..b640bdc2288 100644 --- a/src/main/java/spoon/reflect/reference/CtLocalVariableReference.java +++ b/src/main/java/spoon/reflect/reference/CtLocalVariableReference.java @@ -16,9 +16,13 @@ */ package spoon.reflect.reference; + import spoon.reflect.code.CtLocalVariable; import spoon.support.DerivedProperty; + + + /** * This interface defines a reference to * {@link spoon.reflect.code.CtLocalVariable}. diff --git a/src/main/java/spoon/reflect/reference/CtModuleReference.java b/src/main/java/spoon/reflect/reference/CtModuleReference.java index 08541c6f8dc..bbc22aae443 100644 --- a/src/main/java/spoon/reflect/reference/CtModuleReference.java +++ b/src/main/java/spoon/reflect/reference/CtModuleReference.java @@ -16,9 +16,13 @@ */ package spoon.reflect.reference; + import spoon.reflect.declaration.CtModule; import spoon.support.DerivedProperty; + + + /** * Represents a reference to a {@link CtModule} */ diff --git a/src/main/java/spoon/reflect/reference/CtPackageReference.java b/src/main/java/spoon/reflect/reference/CtPackageReference.java index 4617ef1ee21..35a9fd58497 100644 --- a/src/main/java/spoon/reflect/reference/CtPackageReference.java +++ b/src/main/java/spoon/reflect/reference/CtPackageReference.java @@ -16,9 +16,13 @@ */ package spoon.reflect.reference; + import spoon.reflect.declaration.CtPackage; import spoon.support.DerivedProperty; + + + /** * This interface defines a reference to a * {@link spoon.reflect.declaration.CtPackage}. diff --git a/src/main/java/spoon/reflect/reference/CtParameterReference.java b/src/main/java/spoon/reflect/reference/CtParameterReference.java index c5f1f3822c8..caae764b539 100644 --- a/src/main/java/spoon/reflect/reference/CtParameterReference.java +++ b/src/main/java/spoon/reflect/reference/CtParameterReference.java @@ -16,10 +16,14 @@ */ package spoon.reflect.reference; + import spoon.reflect.declaration.CtParameter; import spoon.support.DerivedProperty; + + + /** * This interface defines a reference to a * {@link spoon.reflect.declaration.CtParameter} of a method. diff --git a/src/main/java/spoon/reflect/reference/CtReference.java b/src/main/java/spoon/reflect/reference/CtReference.java index 21cde0e2554..f3eba49b9ff 100644 --- a/src/main/java/spoon/reflect/reference/CtReference.java +++ b/src/main/java/spoon/reflect/reference/CtReference.java @@ -16,6 +16,8 @@ */ package spoon.reflect.reference; + +import java.util.List; import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.reflect.code.CtComment; @@ -24,7 +26,8 @@ import spoon.support.DerivedProperty; import spoon.support.UnsettableProperty; -import java.util.List; + + /** @@ -48,7 +51,7 @@ public interface CtReference extends CtElement { * Sets the name of referenced element. */ @PropertySetter(role = CtRole.NAME) - T setSimpleName(String simpleName); + CtReference setSimpleName(String simpleName); /** * Returns the declaration that corresponds to the referenced element only @@ -65,5 +68,5 @@ public interface CtReference extends CtElement { /** comments are not possible for references */ @Override @UnsettableProperty - E setComments(List comments); + CtReference setComments(List comments); } diff --git a/src/main/java/spoon/reflect/reference/CtTypeParameterReference.java b/src/main/java/spoon/reflect/reference/CtTypeParameterReference.java index e0498fcc5f4..0cd99c3d696 100644 --- a/src/main/java/spoon/reflect/reference/CtTypeParameterReference.java +++ b/src/main/java/spoon/reflect/reference/CtTypeParameterReference.java @@ -16,11 +16,14 @@ */ package spoon.reflect.reference; + +import java.util.List; import spoon.reflect.declaration.CtTypeParameter; import spoon.support.DerivedProperty; import spoon.support.UnsettableProperty; -import java.util.List; + + /** @@ -56,7 +59,7 @@ public interface CtTypeParameterReference extends CtTypeReference { @Override @UnsettableProperty - T setActualTypeArguments(List> actualTypeArguments); + CtTypeParameterReference setActualTypeArguments(List> actualTypeArguments); /** * Returns true if this has the default bounding type that is java.lang.Object (which basically means that there is no bound) diff --git a/src/main/java/spoon/reflect/reference/CtTypeReference.java b/src/main/java/spoon/reflect/reference/CtTypeReference.java index e9d044dc4b4..ef3a649a3e0 100644 --- a/src/main/java/spoon/reflect/reference/CtTypeReference.java +++ b/src/main/java/spoon/reflect/reference/CtTypeReference.java @@ -16,6 +16,8 @@ */ package spoon.reflect.reference; + +import java.util.Set; import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.reflect.declaration.CtShadowable; @@ -27,9 +29,8 @@ import spoon.support.DerivedProperty; import spoon.support.SpoonClassNotFoundException; -import java.util.Set; -import static spoon.reflect.path.CtRole.PACKAGE_REF; + /** * This interface defines a reference to a @@ -122,13 +123,13 @@ public interface CtTypeReference extends CtReference, CtActualTypeContainer, * referenced type is not a inner type. */ @PropertySetter(role = CtRole.DECLARING_TYPE) - > C setDeclaringType(CtTypeReference type); + CtTypeReference setDeclaringType(CtTypeReference type); /** * Sets the reference to the declaring package. */ @PropertySetter(role = PACKAGE_REF) - > C setPackage(CtPackageReference pack); + CtTypeReference setPackage(CtPackageReference pack); /** * Casts the type reference in {@link CtIntersectionTypeReference}. diff --git a/src/main/java/spoon/reflect/reference/CtUnboundVariableReference.java b/src/main/java/spoon/reflect/reference/CtUnboundVariableReference.java index 0c3c503d748..58c2ab1f5c3 100644 --- a/src/main/java/spoon/reflect/reference/CtUnboundVariableReference.java +++ b/src/main/java/spoon/reflect/reference/CtUnboundVariableReference.java @@ -16,12 +16,14 @@ */ package spoon.reflect.reference; -import spoon.reflect.declaration.CtAnnotation; -import spoon.reflect.declaration.CtElement; -import spoon.support.UnsettableProperty; import java.lang.annotation.Annotation; import java.util.List; +import spoon.reflect.declaration.CtAnnotation; +import spoon.support.UnsettableProperty; + + + /** * This interface defines a reference to an unbound @@ -33,5 +35,5 @@ public interface CtUnboundVariableReference extends CtVariableReference { @Override @UnsettableProperty - E setAnnotations(List> annotation); + CtUnboundVariableReference setAnnotations(List> annotation); } diff --git a/src/main/java/spoon/reflect/reference/CtVariableReference.java b/src/main/java/spoon/reflect/reference/CtVariableReference.java index 555070856d8..4048464d776 100644 --- a/src/main/java/spoon/reflect/reference/CtVariableReference.java +++ b/src/main/java/spoon/reflect/reference/CtVariableReference.java @@ -16,6 +16,8 @@ */ package spoon.reflect.reference; + +import java.util.Set; import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.reflect.declaration.CtVariable; @@ -23,7 +25,8 @@ import spoon.reflect.path.CtRole; import spoon.support.DerivedProperty; -import java.util.Set; + + /** @@ -42,7 +45,7 @@ public interface CtVariableReference extends CtReference { * Sets the type of the variable. */ @PropertySetter(role = CtRole.TYPE) - > C setType(CtTypeReference type); + CtVariableReference setType(CtTypeReference type); /** * Tries to get the declaration of the reference. diff --git a/src/main/java/spoon/reflect/reference/CtWildcardReference.java b/src/main/java/spoon/reflect/reference/CtWildcardReference.java index b0967328204..946efbea7b9 100644 --- a/src/main/java/spoon/reflect/reference/CtWildcardReference.java +++ b/src/main/java/spoon/reflect/reference/CtWildcardReference.java @@ -16,11 +16,15 @@ */ package spoon.reflect.reference; + import spoon.reflect.annotations.PropertyGetter; import spoon.reflect.annotations.PropertySetter; import spoon.reflect.path.CtRole; import spoon.support.UnsettableProperty; + + + /** * Represents a wildcard in generic type annotations, i.e. the "?" (e.g. the "?" in Collection<?> or Collection<? extends List>). */ @@ -30,7 +34,7 @@ public interface CtWildcardReference extends CtTypeParameterReference { @Override @UnsettableProperty - C setSimpleName(String simpleName); + CtWildcardReference setSimpleName(String simpleName); /** * Returns {@code true} if the bounds are in extends clause. @@ -43,7 +47,7 @@ public interface CtWildcardReference extends CtTypeParameterReference { * Set to {@code true} to write extends clause for bounds types. */ @PropertySetter(role = CtRole.IS_UPPER) - T setUpper(boolean upper); + CtWildcardReference setUpper(boolean upper); /** * A type parameter can have an extends clause which declare @@ -63,5 +67,5 @@ public interface CtWildcardReference extends CtTypeParameterReference { * Sets the extends clause of the type parameter. */ @PropertySetter(role = CtRole.BOUNDING_TYPE) - T setBoundingType(CtTypeReference superType); + CtWildcardReference setBoundingType(CtTypeReference superType); } diff --git a/src/main/java/spoon/support/reflect/code/CtAnnotationFieldAccessImpl.java b/src/main/java/spoon/support/reflect/code/CtAnnotationFieldAccessImpl.java index 5fbc055956a..109236d4dd8 100644 --- a/src/main/java/spoon/support/reflect/code/CtAnnotationFieldAccessImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtAnnotationFieldAccessImpl.java @@ -16,9 +16,13 @@ */ package spoon.support.reflect.code; + import spoon.reflect.code.CtAnnotationFieldAccess; import spoon.reflect.visitor.CtVisitor; + + + public class CtAnnotationFieldAccessImpl extends CtFieldAccessImpl implements CtAnnotationFieldAccess { private static final long serialVersionUID = 1L; diff --git a/src/main/java/spoon/support/reflect/code/CtArrayAccessImpl.java b/src/main/java/spoon/support/reflect/code/CtArrayAccessImpl.java index 64a592a828a..cd91021f427 100644 --- a/src/main/java/spoon/support/reflect/code/CtArrayAccessImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtArrayAccessImpl.java @@ -16,12 +16,16 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtArrayAccess; import spoon.reflect.code.CtExpression; import static spoon.reflect.path.CtRole.EXPRESSION; + + + public abstract class CtArrayAccessImpl> extends CtTargetedExpressionImpl implements CtArrayAccess { private static final long serialVersionUID = 1L; @@ -34,13 +38,13 @@ public CtExpression getIndexExpression() { } @Override - public > C setIndexExpression(CtExpression expression) { + public CtArrayAccessImpl setIndexExpression(CtExpression expression) { if (expression != null) { expression.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, EXPRESSION, expression, this.expression); this.expression = expression; - return (C) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtArrayReadImpl.java b/src/main/java/spoon/support/reflect/code/CtArrayReadImpl.java index cc333ea8433..a4fab319bfd 100644 --- a/src/main/java/spoon/support/reflect/code/CtArrayReadImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtArrayReadImpl.java @@ -16,10 +16,14 @@ */ package spoon.support.reflect.code; + import spoon.reflect.code.CtArrayRead; import spoon.reflect.code.CtExpression; import spoon.reflect.visitor.CtVisitor; + + + public class CtArrayReadImpl extends CtArrayAccessImpl> implements CtArrayRead { private static final long serialVersionUID = 1L; diff --git a/src/main/java/spoon/support/reflect/code/CtArrayWriteImpl.java b/src/main/java/spoon/support/reflect/code/CtArrayWriteImpl.java index b37f6ab7e47..9893a38b0d9 100644 --- a/src/main/java/spoon/support/reflect/code/CtArrayWriteImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtArrayWriteImpl.java @@ -16,10 +16,14 @@ */ package spoon.support.reflect.code; + import spoon.reflect.code.CtArrayWrite; import spoon.reflect.code.CtExpression; import spoon.reflect.visitor.CtVisitor; + + + public class CtArrayWriteImpl extends CtArrayAccessImpl> implements CtArrayWrite { private static final long serialVersionUID = 1L; diff --git a/src/main/java/spoon/support/reflect/code/CtAssertImpl.java b/src/main/java/spoon/support/reflect/code/CtAssertImpl.java index b33a907f192..68e4750d3c3 100644 --- a/src/main/java/spoon/support/reflect/code/CtAssertImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtAssertImpl.java @@ -16,6 +16,7 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtAssert; import spoon.reflect.code.CtExpression; @@ -24,6 +25,9 @@ import static spoon.reflect.path.CtRole.CONDITION; import static spoon.reflect.path.CtRole.EXPRESSION; + + + public class CtAssertImpl extends CtStatementImpl implements CtAssert { private static final long serialVersionUID = 1L; @@ -44,13 +48,13 @@ public CtExpression getAssertExpression() { } @Override - public > A setAssertExpression(CtExpression asserted) { + public CtAssertImpl setAssertExpression(CtExpression asserted) { if (asserted != null) { asserted.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CONDITION, asserted, this.asserted); this.asserted = asserted; - return (A) this; + return this; } @Override @@ -59,13 +63,13 @@ public CtExpression getExpression() { } @Override - public > A setExpression(CtExpression value) { + public CtAssertImpl setExpression(CtExpression value) { if (value != null) { value.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, EXPRESSION, value, this.value); this.value = value; - return (A) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtAssignmentImpl.java b/src/main/java/spoon/support/reflect/code/CtAssignmentImpl.java index a81720e9f4e..d5d76712e64 100644 --- a/src/main/java/spoon/support/reflect/code/CtAssignmentImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtAssignmentImpl.java @@ -16,24 +16,25 @@ */ package spoon.support.reflect.code; + +import java.util.ArrayList; +import java.util.List; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtAssignment; import spoon.reflect.code.CtExpression; -import spoon.reflect.code.CtRHSReceiver; -import spoon.reflect.declaration.CtTypedElement; import spoon.reflect.reference.CtTypeReference; import spoon.reflect.visitor.CtVisitor; import spoon.support.reflect.declaration.CtElementImpl; -import java.util.ArrayList; -import java.util.List; - import static spoon.reflect.ModelElementContainerDefaultCapacities.CASTS_CONTAINER_DEFAULT_CAPACITY; import static spoon.reflect.path.CtRole.ASSIGNED; import static spoon.reflect.path.CtRole.ASSIGNMENT; import static spoon.reflect.path.CtRole.CAST; import static spoon.reflect.path.CtRole.TYPE; + + + public class CtAssignmentImpl extends CtStatementImpl implements CtAssignment { private static final long serialVersionUID = 1L; @@ -75,40 +76,40 @@ public List> getTypeCasts() { } @Override - public > C setAssigned(CtExpression assigned) { + public CtAssignmentImpl setAssigned(CtExpression assigned) { if (assigned != null) { assigned.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, ASSIGNED, assigned, this.assigned); this.assigned = assigned; - return (C) this; + return this; } @Override - public > C setAssignment(CtExpression assignment) { + public CtAssignmentImpl setAssignment(CtExpression assignment) { if (assignment != null) { assignment.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, ASSIGNMENT, assignment, this.assignment); this.assignment = assignment; - return (C) this; + return this; } @Override - public C setType(CtTypeReference type) { + public CtAssignmentImpl setType(CtTypeReference type) { if (type != null) { type.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, TYPE, type, this.type); this.type = type; - return (C) this; + return this; } @Override - public > C setTypeCasts(List> casts) { + public CtAssignmentImpl setTypeCasts(List> casts) { if (casts == null || casts.isEmpty()) { this.typeCasts = CtElementImpl.emptyList(); - return (C) this; + return this; } if (this.typeCasts == CtElementImpl.>emptyList()) { this.typeCasts = new ArrayList<>(CASTS_CONTAINER_DEFAULT_CAPACITY); @@ -118,13 +119,13 @@ public > C setTypeCasts(List> casts for (CtTypeReference cast : casts) { addTypeCast(cast); } - return (C) this; + return this; } @Override - public > C addTypeCast(CtTypeReference type) { + public CtAssignmentImpl addTypeCast(CtTypeReference type) { if (type == null) { - return (C) this; + return this; } if (typeCasts == CtElementImpl.>emptyList()) { typeCasts = new ArrayList<>(CASTS_CONTAINER_DEFAULT_CAPACITY); @@ -132,7 +133,7 @@ public > C addTypeCast(CtTypeReference type) { type.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, CAST, typeCasts, type); typeCasts.add(type); - return (C) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtBinaryOperatorImpl.java b/src/main/java/spoon/support/reflect/code/CtBinaryOperatorImpl.java index cc32372f8e0..d0d1d8e29cb 100644 --- a/src/main/java/spoon/support/reflect/code/CtBinaryOperatorImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtBinaryOperatorImpl.java @@ -16,6 +16,7 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.BinaryOperatorKind; import spoon.reflect.code.CtBinaryOperator; @@ -26,6 +27,9 @@ import static spoon.reflect.path.CtRole.OPERATOR_KIND; import static spoon.reflect.path.CtRole.RIGHT_OPERAND; + + + public class CtBinaryOperatorImpl extends CtExpressionImpl implements CtBinaryOperator { private static final long serialVersionUID = 1L; @@ -54,30 +58,30 @@ public CtExpression getRightHandOperand() { } @Override - public > C setLeftHandOperand(CtExpression expression) { + public CtBinaryOperatorImpl setLeftHandOperand(CtExpression expression) { if (expression != null) { expression.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, LEFT_OPERAND, expression, this.leftHandOperand); leftHandOperand = expression; - return (C) this; + return this; } @Override - public > C setRightHandOperand(CtExpression expression) { + public CtBinaryOperatorImpl setRightHandOperand(CtExpression expression) { if (expression != null) { expression.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, RIGHT_OPERAND, expression, this.rightHandOperand); rightHandOperand = expression; - return (C) this; + return this; } @Override - public > C setKind(BinaryOperatorKind kind) { + public CtBinaryOperatorImpl setKind(BinaryOperatorKind kind) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, OPERATOR_KIND, kind, this.kind); this.kind = kind; - return (C) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtBlockImpl.java b/src/main/java/spoon/support/reflect/code/CtBlockImpl.java index eb721d0be6e..32ab1dca409 100644 --- a/src/main/java/spoon/support/reflect/code/CtBlockImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtBlockImpl.java @@ -14,9 +14,12 @@ * The fact that you are presently reading this means that you have had * knowledge of the CeCILL-C license and that you accept its terms. */ - package spoon.support.reflect.code; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; import spoon.reflect.ModelElementContainerDefaultCapacities; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtBlock; @@ -32,9 +35,8 @@ import spoon.reflect.visitor.Query; import spoon.support.util.ModelList; -import java.util.ArrayList; -import java.util.Iterator; -import java.util.List; + + public class CtBlockImpl extends CtStatementImpl implements CtBlock { private static final long serialVersionUID = 1L; @@ -99,91 +101,91 @@ private boolean shouldInsertAfterSuper() { } @Override - public T insertBegin(CtStatementList statements) { + public CtBlockImpl insertBegin(CtStatementList statements) { if (this.shouldInsertAfterSuper()) { getStatements().get(0).insertAfter(statements); - return (T) this; + return this; } List copy = new ArrayList<>(statements.getStatements()); statements.setStatements(null); this.statements.addAll(0, copy); - return (T) this; + return this; } @Override - public T insertBegin(CtStatement statement) { + public CtBlockImpl insertBegin(CtStatement statement) { if (this.shouldInsertAfterSuper()) { getStatements().get(0).insertAfter(statement); - return (T) this; + return this; } this.statements.add(0, statement); - return (T) this; + return this; } @Override - public T insertEnd(CtStatement statement) { + public CtBlockImpl insertEnd(CtStatement statement) { addStatement(statement); - return (T) this; + return this; } @Override - public T insertEnd(CtStatementList statements) { + public CtBlockImpl insertEnd(CtStatementList statements) { List tobeInserted = new ArrayList<>(statements.getStatements()); //remove statements from the `statementsToBeInserted` before they are added to spoon model //note: one element MUST NOT be part of two models. statements.setStatements(null); this.statements.addAll(this.statements.size(), tobeInserted); - return (T) this; + return this; } @Override - public T insertAfter(Filter insertionPoints, CtStatement statement) { + public CtBlockImpl insertAfter(Filter insertionPoints, CtStatement statement) { for (CtStatement e : Query.getElements(this, insertionPoints)) { e.insertAfter(statement); } - return (T) this; + return this; } @Override - public T insertAfter(Filter insertionPoints, CtStatementList statements) { + public CtBlockImpl insertAfter(Filter insertionPoints, CtStatementList statements) { for (CtStatement e : Query.getElements(this, insertionPoints)) { e.insertAfter(statements); } - return (T) this; + return this; } @Override - public T insertBefore(Filter insertionPoints, CtStatement statement) { + public CtBlockImpl insertBefore(Filter insertionPoints, CtStatement statement) { for (CtStatement e : Query.getElements(this, insertionPoints)) { e.insertBefore(statement); } - return (T) this; + return this; } @Override - public T insertBefore(Filter insertionPoints, CtStatementList statements) { + public CtBlockImpl insertBefore(Filter insertionPoints, CtStatementList statements) { for (CtStatement e : Query.getElements(this, insertionPoints)) { e.insertBefore(statements); } - return (T) this; + return this; } @Override - public T setStatements(List statements) { + public CtBlockImpl setStatements(List statements) { this.statements.set(statements); - return (T) this; + return this; } @Override - public T addStatement(CtStatement statement) { + public CtBlockImpl addStatement(CtStatement statement) { this.statements.add(statement); - return (T) this; + return this; } @Override - public T addStatement(int index, CtStatement statement) { + public CtBlockImpl addStatement(int index, CtStatement statement) { this.statements.add(index, statement); - return (T) this; + return this; } diff --git a/src/main/java/spoon/support/reflect/code/CtBreakImpl.java b/src/main/java/spoon/support/reflect/code/CtBreakImpl.java index 476b6ecebd4..65844333995 100644 --- a/src/main/java/spoon/support/reflect/code/CtBreakImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtBreakImpl.java @@ -16,18 +16,20 @@ */ package spoon.support.reflect.code; + +import java.util.List; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtBreak; -import spoon.reflect.code.CtLabelledFlowBreak; import spoon.reflect.code.CtStatement; import spoon.reflect.declaration.CtElement; import spoon.reflect.visitor.CtVisitor; import spoon.reflect.visitor.filter.ParentFunction; -import java.util.List; - import static spoon.reflect.path.CtRole.TARGET_LABEL; + + + public class CtBreakImpl extends CtStatementImpl implements CtBreak { private static final long serialVersionUID = 1L; @@ -45,10 +47,10 @@ public String getTargetLabel() { } @Override - public T setTargetLabel(String targetLabel) { + public CtBreakImpl setTargetLabel(String targetLabel) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, TARGET_LABEL, targetLabel, this.targetLabel); this.targetLabel = targetLabel; - return (T) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtCaseImpl.java b/src/main/java/spoon/support/reflect/code/CtCaseImpl.java index a0aabb6315c..ccdb07b21b4 100644 --- a/src/main/java/spoon/support/reflect/code/CtCaseImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtCaseImpl.java @@ -16,6 +16,10 @@ */ package spoon.support.reflect.code; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; import spoon.reflect.ModelElementContainerDefaultCapacities; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtCase; @@ -28,9 +32,8 @@ import spoon.reflect.visitor.Query; import spoon.support.reflect.declaration.CtElementImpl; -import java.util.ArrayList; -import java.util.Iterator; -import java.util.List; + + public class CtCaseImpl extends CtStatementImpl implements CtCase { private static final long serialVersionUID = 1L; @@ -57,32 +60,32 @@ public List getStatements() { } @Override - public > T setCaseExpression(CtExpression caseExpression) { + public CtCaseImpl setCaseExpression(CtExpression caseExpression) { if (caseExpression != null) { caseExpression.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.CASE, caseExpression, this.caseExpression); this.caseExpression = caseExpression; - return (T) this; + return this; } @Override - public T setStatements(List statements) { + public CtCaseImpl setStatements(List statements) { if (statements == null || statements.isEmpty()) { this.statements = CtElementImpl.emptyList(); - return (T) this; + return this; } getFactory().getEnvironment().getModelChangeListener().onListDeleteAll(this, CtRole.STATEMENT, this.statements, new ArrayList<>(this.statements)); this.statements.clear(); for (CtStatement stmt : statements) { addStatement(stmt); } - return (T) this; + return this; } @Override - public T addStatement(CtStatement statement) { - return this.addStatement(this.statements.size(), statement); + public CtCaseImpl addStatement(CtStatement statement) { + return ((CtCaseImpl) (this.addStatement(this.statements.size(), statement))); } private void ensureModifiableStatementsList() { @@ -92,19 +95,19 @@ private void ensureModifiableStatementsList() { } @Override - public T addStatement(int index, CtStatement statement) { + public CtCaseImpl addStatement(int index, CtStatement statement) { if (statement == null) { - return (T) this; + return this; } this.ensureModifiableStatementsList(); statement.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, CtRole.STATEMENT, this.statements, index, statement); statements.add(index, statement); - return (T) this; + return this; } @Override - public T insertBegin(CtStatement statement) { + public CtCaseImpl insertBegin(CtStatement statement) { ensureModifiableStatementsList(); statement.setParent(this); this.addStatement(0, statement); @@ -112,11 +115,11 @@ public T insertBegin(CtStatement statement) { if (isImplicit() && this.statements.size() > 1) { setImplicit(false); } - return (T) this; + return this; } @Override - public T insertBegin(CtStatementList statements) { + public CtCaseImpl insertBegin(CtStatementList statements) { this.ensureModifiableStatementsList(); for (CtStatement statement : statements.getStatements()) { statement.setParent(this); @@ -125,18 +128,18 @@ public T insertBegin(CtStatementList statements) { if (isImplicit() && this.statements.size() > 1) { setImplicit(false); } - return (T) this; + return this; } @Override - public T insertEnd(CtStatement statement) { + public CtCaseImpl insertEnd(CtStatement statement) { ensureModifiableStatementsList(); addStatement(statement); - return (T) this; + return this; } @Override - public T insertEnd(CtStatementList statements) { + public CtCaseImpl insertEnd(CtStatementList statements) { List tobeInserted = new ArrayList<>(statements.getStatements()); //remove statements from the `statementsToBeInserted` before they are added to spoon model //note: one element MUST NOT be part of two models. @@ -144,39 +147,39 @@ public T insertEnd(CtStatementList statements) { for (CtStatement s : tobeInserted) { insertEnd(s); } - return (T) this; + return this; } @Override - public T insertBefore(Filter insertionPoints, CtStatement statement) { + public CtCaseImpl insertBefore(Filter insertionPoints, CtStatement statement) { for (CtStatement e : Query.getElements(this, insertionPoints)) { e.insertBefore(statement); } - return (T) this; + return this; } @Override - public T insertBefore(Filter insertionPoints, CtStatementList statements) { + public CtCaseImpl insertBefore(Filter insertionPoints, CtStatementList statements) { for (CtStatement e : Query.getElements(this, insertionPoints)) { e.insertBefore(statements); } - return (T) this; + return this; } @Override - public T insertAfter(Filter insertionPoints, CtStatement statement) { + public CtCaseImpl insertAfter(Filter insertionPoints, CtStatement statement) { for (CtStatement e : Query.getElements(this, insertionPoints)) { e.insertAfter(statement); } - return (T) this; + return this; } @Override - public T insertAfter(Filter insertionPoints, CtStatementList statements) { + public CtCaseImpl insertAfter(Filter insertionPoints, CtStatementList statements) { for (CtStatement e : Query.getElements(this, insertionPoints)) { e.insertAfter(statements); } - return (T) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtCatchImpl.java b/src/main/java/spoon/support/reflect/code/CtCatchImpl.java index 21961a284fd..0ca177ee230 100644 --- a/src/main/java/spoon/support/reflect/code/CtCatchImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtCatchImpl.java @@ -16,9 +16,9 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtBlock; -import spoon.reflect.code.CtBodyHolder; import spoon.reflect.code.CtCatch; import spoon.reflect.code.CtCatchVariable; import spoon.reflect.code.CtStatement; @@ -27,6 +27,9 @@ import static spoon.reflect.path.CtRole.BODY; import static spoon.reflect.path.CtRole.PARAMETER; + + + public class CtCatchImpl extends CtCodeElementImpl implements CtCatch { private static final long serialVersionUID = 1L; @@ -52,7 +55,7 @@ public CtCatchVariable getParameter() { } @Override - public T setBody(CtStatement statement) { + public CtCatchImpl setBody(CtStatement statement) { if (statement != null) { CtBlock body = getFactory().Code().getOrCreateCtBlock(statement); getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, BODY, body, this.body); @@ -65,17 +68,17 @@ public T setBody(CtStatement statement) { this.body = null; } - return (T) this; + return this; } @Override - public T setParameter(CtCatchVariable parameter) { + public CtCatchImpl setParameter(CtCatchVariable parameter) { if (parameter != null) { parameter.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, PARAMETER, parameter, this.parameter); this.parameter = parameter; - return (T) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtCatchVariableImpl.java b/src/main/java/spoon/support/reflect/code/CtCatchVariableImpl.java index b0010e63c5c..0abcfc2fa39 100644 --- a/src/main/java/spoon/support/reflect/code/CtCatchVariableImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtCatchVariableImpl.java @@ -16,15 +16,15 @@ */ package spoon.support.reflect.code; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Set; import spoon.reflect.ModelElementContainerDefaultCapacities; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtCatchVariable; import spoon.reflect.code.CtExpression; -import spoon.reflect.declaration.CtModifiable; -import spoon.reflect.declaration.CtMultiTypedElement; -import spoon.reflect.declaration.CtNamedElement; -import spoon.reflect.declaration.CtTypedElement; -import spoon.reflect.declaration.CtVariable; import spoon.reflect.declaration.ModifierKind; import spoon.reflect.path.CtRole; import spoon.reflect.reference.CtCatchVariableReference; @@ -37,10 +37,8 @@ import spoon.support.reflect.CtModifierHandler; import spoon.support.reflect.declaration.CtElementImpl; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.Set; + + public class CtCatchVariableImpl extends CtCodeElementImpl implements CtCatchVariable { private static final long serialVersionUID = 1L; @@ -111,28 +109,28 @@ public CtTypeReference getType() { @Override @UnsettableProperty - public > C setDefaultExpression(CtExpression defaultExpression) { + public CtCatchVariableImpl setDefaultExpression(CtExpression defaultExpression) { // unsettable property - return (C) this; + return this; } @Override - public C setSimpleName(String simpleName) { + public CtCatchVariableImpl setSimpleName(String simpleName) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.NAME, simpleName, this.name); this.name = simpleName; - return (C) this; + return this; } @Override - public C setType(CtTypeReference type) { + public CtCatchVariableImpl setType(CtTypeReference type) { setMultiTypes(type == null ? emptyList() : Collections.singletonList(type)); - return (C) this; + return this; } @Override - public T addMultiType(CtTypeReference type) { + public CtCatchVariableImpl addMultiType(CtTypeReference type) { if (type == null) { - return (T) this; + return this; } if (types == CtElementImpl.>emptyList()) { types = new ArrayList<>(ModelElementContainerDefaultCapacities.CATCH_VARIABLE_MULTI_TYPES_CONTAINER_DEFAULT_CAPACITY); @@ -140,7 +138,7 @@ public T addMultiType(CtTypeReference type) { type.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, CtRole.MULTI_TYPE, this.types, type); types.add(type); - return (T) this; + return this; } @Override @@ -158,11 +156,11 @@ public List> getMultiTypes() { } @Override - public T setMultiTypes(List> types) { + public CtCatchVariableImpl setMultiTypes(List> types) { getFactory().getEnvironment().getModelChangeListener().onListDeleteAll(this, CtRole.MULTI_TYPE, this.types, new ArrayList<>(this.types)); if (types == null || types.isEmpty()) { this.types = CtElementImpl.emptyList(); - return (T) this; + return this; } if (this.types == CtElementImpl.>emptyList()) { this.types = new ArrayList<>(); @@ -171,7 +169,7 @@ public T setMultiTypes(List> for (CtTypeReference t : types) { addMultiType(t); } - return (T) this; + return this; } @Override @@ -185,27 +183,27 @@ public boolean hasModifier(ModifierKind modifier) { } @Override - public C setModifiers(Set modifiers) { + public CtCatchVariableImpl setModifiers(Set modifiers) { modifierHandler.setModifiers(modifiers); - return (C) this; + return this; } @Override - public C addModifier(ModifierKind modifier) { + public CtCatchVariableImpl addModifier(ModifierKind modifier) { modifierHandler.addModifier(modifier); - return (C) this; + return this; } @Override - public C removeModifier(ModifierKind modifier) { + public CtCatchVariableImpl removeModifier(ModifierKind modifier) { modifierHandler.removeModifier(modifier); - return (C) this; + return this; } @Override - public C setVisibility(ModifierKind visibility) { + public CtCatchVariableImpl setVisibility(ModifierKind visibility) { modifierHandler.setVisibility(visibility); - return (C) this; + return this; } @Override @@ -228,9 +226,9 @@ public Set getExtendedModifiers() { } @Override - public C setExtendedModifiers(Set extendedModifiers) { + public CtCatchVariableImpl setExtendedModifiers(Set extendedModifiers) { this.modifierHandler.setExtendedModifiers(extendedModifiers); - return (C) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtCodeElementImpl.java b/src/main/java/spoon/support/reflect/code/CtCodeElementImpl.java index a8b840e0e97..e5a7b58da26 100644 --- a/src/main/java/spoon/support/reflect/code/CtCodeElementImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtCodeElementImpl.java @@ -16,10 +16,14 @@ */ package spoon.support.reflect.code; + import spoon.reflect.code.CtCodeElement; import spoon.support.reflect.declaration.CtElementImpl; import spoon.support.reflect.eval.VisitorPartialEvaluator; + + + public abstract class CtCodeElementImpl extends CtElementImpl implements CtCodeElement { private static final long serialVersionUID = 1L; diff --git a/src/main/java/spoon/support/reflect/code/CtCodeSnippetExpressionImpl.java b/src/main/java/spoon/support/reflect/code/CtCodeSnippetExpressionImpl.java index e5bd1edeb15..6b5b21f738c 100644 --- a/src/main/java/spoon/support/reflect/code/CtCodeSnippetExpressionImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtCodeSnippetExpressionImpl.java @@ -16,16 +16,19 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtCodeSnippetExpression; import spoon.reflect.code.CtExpression; -import spoon.reflect.declaration.CtCodeSnippet; import spoon.reflect.visitor.CtVisitor; import spoon.support.compiler.SnippetCompilationError; import spoon.support.compiler.SnippetCompilationHelper; import static spoon.reflect.path.CtRole.SNIPPET; + + + public class CtCodeSnippetExpressionImpl extends CtExpressionImpl implements CtCodeSnippetExpression { private static final long serialVersionUID = 1L; @@ -44,10 +47,10 @@ public String getValue() { } @Override - public C setValue(String value) { + public CtCodeSnippetExpressionImpl setValue(String value) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, SNIPPET, value, this.value); this.value = value; - return (C) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtCodeSnippetStatementImpl.java b/src/main/java/spoon/support/reflect/code/CtCodeSnippetStatementImpl.java index b174e66d070..75d8da96286 100644 --- a/src/main/java/spoon/support/reflect/code/CtCodeSnippetStatementImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtCodeSnippetStatementImpl.java @@ -16,16 +16,19 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtCodeSnippetStatement; import spoon.reflect.code.CtStatement; -import spoon.reflect.declaration.CtCodeSnippet; import spoon.reflect.visitor.CtVisitor; import spoon.support.compiler.SnippetCompilationError; import spoon.support.compiler.SnippetCompilationHelper; import static spoon.reflect.path.CtRole.SNIPPET; + + + public class CtCodeSnippetStatementImpl extends CtStatementImpl implements CtCodeSnippetStatement { private static final long serialVersionUID = 1L; @@ -44,10 +47,10 @@ public String getValue() { } @Override - public C setValue(String value) { + public CtCodeSnippetStatementImpl setValue(String value) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, SNIPPET, value, this.value); this.value = value; - return (C) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtCommentImpl.java b/src/main/java/spoon/support/reflect/code/CtCommentImpl.java index 276c97d8dff..f8e47f541f9 100644 --- a/src/main/java/spoon/support/reflect/code/CtCommentImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtCommentImpl.java @@ -16,13 +16,16 @@ */ package spoon.support.reflect.code; + +import java.util.Objects; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtComment; import spoon.reflect.code.CtJavaDoc; import spoon.reflect.path.CtRole; import spoon.reflect.visitor.CtVisitor; -import java.util.Objects; + + public class CtCommentImpl extends CtStatementImpl implements CtComment { private static final long serialVersionUID = 1L; @@ -46,10 +49,10 @@ public String getContent() { } @Override - public E setContent(String content) { + public CtCommentImpl setContent(String content) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.COMMENT_CONTENT, content, this.content); this.content = content; - return (E) this; + return this; } @Override @@ -58,10 +61,10 @@ public CommentType getCommentType() { } @Override - public E setCommentType(CommentType commentType) { + public CtCommentImpl setCommentType(CommentType commentType) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.TYPE, commentType, this.type); type = commentType; - return (E) this; + return this; } @Override @@ -105,9 +108,9 @@ public CtComment clone() { } @Override - public CtJavaDoc asJavaDoc() { + public CtCommentImpl asJavaDoc() { if (this instanceof CtJavaDoc) { - return (CtJavaDoc) this; + return this; } throw new IllegalStateException("not a javadoc comment"); } diff --git a/src/main/java/spoon/support/reflect/code/CtConditionalImpl.java b/src/main/java/spoon/support/reflect/code/CtConditionalImpl.java index 63c6eacff8a..90247a19efe 100644 --- a/src/main/java/spoon/support/reflect/code/CtConditionalImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtConditionalImpl.java @@ -16,6 +16,7 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtConditional; import spoon.reflect.code.CtExpression; @@ -25,6 +26,9 @@ import static spoon.reflect.path.CtRole.ELSE; import static spoon.reflect.path.CtRole.THEN; + + + public class CtConditionalImpl extends CtExpressionImpl implements CtConditional { private static final long serialVersionUID = 1L; @@ -58,33 +62,33 @@ public CtExpression getThenExpression() { } @Override - public > C setElseExpression(CtExpression elseExpression) { + public CtConditionalImpl setElseExpression(CtExpression elseExpression) { if (elseExpression != null) { elseExpression.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, ELSE, elseExpression, this.elseExpression); this.elseExpression = elseExpression; - return (C) this; + return this; } @Override - public > C setCondition(CtExpression condition) { + public CtConditionalImpl setCondition(CtExpression condition) { if (condition != null) { condition.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CONDITION, condition, this.condition); this.condition = condition; - return (C) this; + return this; } @Override - public > C setThenExpression(CtExpression thenExpression) { + public CtConditionalImpl setThenExpression(CtExpression thenExpression) { if (thenExpression != null) { thenExpression.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, THEN, thenExpression, this.thenExpression); this.thenExpression = thenExpression; - return (C) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtConstructorCallImpl.java b/src/main/java/spoon/support/reflect/code/CtConstructorCallImpl.java index b6fdfce7c79..4db89a776c9 100644 --- a/src/main/java/spoon/support/reflect/code/CtConstructorCallImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtConstructorCallImpl.java @@ -16,28 +16,28 @@ */ package spoon.support.reflect.code; + +import java.util.ArrayList; +import java.util.List; import spoon.reflect.annotations.MetamodelPropertyField; -import spoon.reflect.code.CtAbstractInvocation; import spoon.reflect.code.CtConstructorCall; import spoon.reflect.code.CtExpression; import spoon.reflect.code.CtStatement; import spoon.reflect.code.CtStatementList; -import spoon.reflect.declaration.CtTypedElement; -import spoon.reflect.reference.CtActualTypeContainer; import spoon.reflect.reference.CtExecutableReference; import spoon.reflect.reference.CtTypeReference; import spoon.reflect.visitor.CtVisitor; import spoon.support.DerivedProperty; import spoon.support.reflect.declaration.CtElementImpl; -import java.util.ArrayList; -import java.util.List; - import static spoon.reflect.ModelElementContainerDefaultCapacities.PARAMETERS_CONTAINER_DEFAULT_CAPACITY; import static spoon.reflect.path.CtRole.ARGUMENT; import static spoon.reflect.path.CtRole.EXECUTABLE_REF; import static spoon.reflect.path.CtRole.LABEL; + + + public class CtConstructorCallImpl extends CtTargetedExpressionImpl> implements CtConstructorCall { private static final long serialVersionUID = 1L; @@ -74,34 +74,34 @@ public String getLabel() { } @Override - public C insertAfter(CtStatement statement) { + public CtConstructorCallImpl insertAfter(CtStatement statement) { CtStatementImpl.insertAfter(this, statement); - return (C) this; + return this; } @Override - public C insertBefore(CtStatement statement) { + public CtConstructorCallImpl insertBefore(CtStatement statement) { CtStatementImpl.insertBefore(this, statement); - return (C) this; + return this; } @Override - public C insertAfter(CtStatementList statements) { + public CtConstructorCallImpl insertAfter(CtStatementList statements) { CtStatementImpl.insertAfter(this, statements); - return (C) this; + return this; } @Override - public C insertBefore(CtStatementList statements) { + public CtConstructorCallImpl insertBefore(CtStatementList statements) { CtStatementImpl.insertBefore(this, statements); - return (C) this; + return this; } @Override - public > C setArguments(List> arguments) { + public CtConstructorCallImpl setArguments(List> arguments) { if (arguments == null || arguments.isEmpty()) { this.arguments = CtElementImpl.emptyList(); - return (C) this; + return this; } if (this.arguments == CtElementImpl.>emptyList()) { this.arguments = new ArrayList<>(PARAMETERS_CONTAINER_DEFAULT_CAPACITY); @@ -111,12 +111,12 @@ public > C setArguments(List> for (CtExpression expr : arguments) { addArgument(expr); } - return (C) this; + return this; } - private > C addArgument(int position, CtExpression argument) { + private CtConstructorCallImpl addArgument(int position, CtExpression argument) { if (argument == null) { - return (C) this; + return this; } if (arguments == CtElementImpl.>emptyList()) { arguments = new ArrayList<>(PARAMETERS_CONTAINER_DEFAULT_CAPACITY); @@ -124,12 +124,12 @@ private > C addArgument(int position, CtExpres argument.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, ARGUMENT, this.arguments, position, argument); arguments.add(position, argument); - return (C) this; + return this; } @Override - public > C addArgument(CtExpression argument) { - return addArgument(arguments.size(), argument); + public CtConstructorCallImpl addArgument(CtExpression argument) { + return ((CtConstructorCallImpl) (addArgument(arguments.size(), argument))); } @Override @@ -142,20 +142,20 @@ public void removeArgument(CtExpression argument) { } @Override - public > C setExecutable(CtExecutableReference executable) { + public CtConstructorCallImpl setExecutable(CtExecutableReference executable) { if (executable != null) { executable.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, EXECUTABLE_REF, executable, this.executable); this.executable = executable; - return (C) this; + return this; } @Override - public C setLabel(String label) { + public CtConstructorCallImpl setLabel(String label) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, LABEL, label, this.label); this.label = label; - return (C) this; + return this; } @Override @@ -166,20 +166,20 @@ public List> getActualTypeArguments() { @Override @DerivedProperty - public T setActualTypeArguments(List> actualTypeArguments) { + public CtConstructorCallImpl setActualTypeArguments(List> actualTypeArguments) { if (getExecutable() != null) { getExecutable().setActualTypeArguments(actualTypeArguments); } - return (T) this; + return this; } @Override @DerivedProperty - public T addActualTypeArgument(CtTypeReference actualTypeArgument) { + public CtConstructorCallImpl addActualTypeArgument(CtTypeReference actualTypeArgument) { if (getExecutable() != null) { getExecutable().addActualTypeArgument(actualTypeArgument); } - return (T) this; + return this; } @Override @@ -199,14 +199,14 @@ public CtTypeReference getType() { @Override @DerivedProperty - public C setType(CtTypeReference type) { + public CtConstructorCallImpl setType(CtTypeReference type) { if (type != null) { type.setParent(this); } if (getExecutable() != null) { getExecutable().setType(type); } - return (C) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtContinueImpl.java b/src/main/java/spoon/support/reflect/code/CtContinueImpl.java index 200aa04ebe0..453e1c4d867 100644 --- a/src/main/java/spoon/support/reflect/code/CtContinueImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtContinueImpl.java @@ -16,18 +16,20 @@ */ package spoon.support.reflect.code; + +import java.util.List; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtContinue; -import spoon.reflect.code.CtLabelledFlowBreak; import spoon.reflect.code.CtStatement; import spoon.reflect.declaration.CtElement; import spoon.reflect.visitor.CtVisitor; import spoon.reflect.visitor.filter.ParentFunction; -import java.util.List; - import static spoon.reflect.path.CtRole.TARGET_LABEL; + + + public class CtContinueImpl extends CtStatementImpl implements CtContinue { private static final long serialVersionUID = 1L; @@ -45,10 +47,10 @@ public String getTargetLabel() { } @Override - public T setTargetLabel(String targetLabel) { + public CtContinueImpl setTargetLabel(String targetLabel) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, TARGET_LABEL, targetLabel, this.targetLabel); this.targetLabel = targetLabel; - return (T) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtDoImpl.java b/src/main/java/spoon/support/reflect/code/CtDoImpl.java index 3492cb545de..220da9a8cde 100644 --- a/src/main/java/spoon/support/reflect/code/CtDoImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtDoImpl.java @@ -16,6 +16,7 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtDo; import spoon.reflect.code.CtExpression; @@ -23,6 +24,9 @@ import static spoon.reflect.path.CtRole.EXPRESSION; + + + public class CtDoImpl extends CtLoopImpl implements CtDo { private static final long serialVersionUID = 1L; @@ -40,13 +44,13 @@ public CtExpression getLoopingExpression() { } @Override - public T setLoopingExpression(CtExpression expression) { + public CtDoImpl setLoopingExpression(CtExpression expression) { if (expression != null) { expression.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, EXPRESSION, expression, this.expression); this.expression = expression; - return (T) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtExecutableReferenceExpressionImpl.java b/src/main/java/spoon/support/reflect/code/CtExecutableReferenceExpressionImpl.java index 1b7dc40800b..24e3089b961 100644 --- a/src/main/java/spoon/support/reflect/code/CtExecutableReferenceExpressionImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtExecutableReferenceExpressionImpl.java @@ -16,6 +16,7 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtExecutableReferenceExpression; import spoon.reflect.code.CtExpression; @@ -24,6 +25,9 @@ import static spoon.reflect.path.CtRole.EXECUTABLE_REF; + + + public class CtExecutableReferenceExpressionImpl> extends CtTargetedExpressionImpl implements CtExecutableReferenceExpression { @MetamodelPropertyField(role = EXECUTABLE_REF) CtExecutableReference executable; @@ -39,13 +43,13 @@ public CtExecutableReference getExecutable() { } @Override - public > C setExecutable(CtExecutableReference executable) { + public CtExecutableReferenceExpressionImpl setExecutable(CtExecutableReference executable) { if (executable != null) { executable.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, EXECUTABLE_REF, executable, this.executable); this.executable = executable; - return (C) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtExpressionImpl.java b/src/main/java/spoon/support/reflect/code/CtExpressionImpl.java index 658a86351ec..be763581a9d 100644 --- a/src/main/java/spoon/support/reflect/code/CtExpressionImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtExpressionImpl.java @@ -16,19 +16,21 @@ */ package spoon.support.reflect.code; + +import java.util.ArrayList; +import java.util.List; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtExpression; -import spoon.reflect.declaration.CtTypedElement; import spoon.reflect.reference.CtTypeReference; import spoon.support.reflect.declaration.CtElementImpl; -import java.util.ArrayList; -import java.util.List; - import static spoon.reflect.ModelElementContainerDefaultCapacities.CASTS_CONTAINER_DEFAULT_CAPACITY; import static spoon.reflect.path.CtRole.CAST; import static spoon.reflect.path.CtRole.TYPE; + + + public abstract class CtExpressionImpl extends CtCodeElementImpl implements CtExpression { private static final long serialVersionUID = 1L; @@ -49,21 +51,21 @@ public List> getTypeCasts() { } @Override - public C setType(CtTypeReference type) { + public CtExpressionImpl setType(CtTypeReference type) { if (type != null) { type.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, TYPE, type, this.type); this.type = type; - return (C) this; + return this; } @Override - public > C setTypeCasts(List> casts) { + public CtExpressionImpl setTypeCasts(List> casts) { getFactory().getEnvironment().getModelChangeListener().onListDeleteAll(this, CAST, this.typeCasts, new ArrayList<>(this.typeCasts)); if (casts == null || casts.isEmpty()) { this.typeCasts = CtElementImpl.emptyList(); - return (C) this; + return this; } if (this.typeCasts == CtElementImpl.>emptyList()) { this.typeCasts = new ArrayList<>(CASTS_CONTAINER_DEFAULT_CAPACITY); @@ -72,13 +74,13 @@ public > C setTypeCasts(List> casts for (CtTypeReference cast : casts) { addTypeCast(cast); } - return (C) this; + return this; } @Override - public > C addTypeCast(CtTypeReference type) { + public CtExpressionImpl addTypeCast(CtTypeReference type) { if (type == null) { - return (C) this; + return this; } if (typeCasts == CtElementImpl.>emptyList()) { typeCasts = new ArrayList<>(CASTS_CONTAINER_DEFAULT_CAPACITY); @@ -86,7 +88,7 @@ public > C addTypeCast(CtTypeReference type) { type.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, CAST, this.typeCasts, type); typeCasts.add(type); - return (C) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtFieldAccessImpl.java b/src/main/java/spoon/support/reflect/code/CtFieldAccessImpl.java index 6000c2b4106..9f6ce5df07f 100644 --- a/src/main/java/spoon/support/reflect/code/CtFieldAccessImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtFieldAccessImpl.java @@ -16,6 +16,7 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtExpression; import spoon.reflect.code.CtFieldAccess; @@ -24,6 +25,9 @@ import static spoon.reflect.path.CtRole.TARGET; + + + public abstract class CtFieldAccessImpl extends CtVariableAccessImpl implements CtFieldAccess { private static final long serialVersionUID = 1L; diff --git a/src/main/java/spoon/support/reflect/code/CtFieldReadImpl.java b/src/main/java/spoon/support/reflect/code/CtFieldReadImpl.java index 9fd39b6efc4..71bd4bef78f 100644 --- a/src/main/java/spoon/support/reflect/code/CtFieldReadImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtFieldReadImpl.java @@ -16,9 +16,13 @@ */ package spoon.support.reflect.code; + import spoon.reflect.code.CtFieldRead; import spoon.reflect.visitor.CtVisitor; + + + public class CtFieldReadImpl extends CtFieldAccessImpl implements CtFieldRead { private static final long serialVersionUID = 1L; diff --git a/src/main/java/spoon/support/reflect/code/CtFieldWriteImpl.java b/src/main/java/spoon/support/reflect/code/CtFieldWriteImpl.java index 1210ad38f9c..d6680cb835c 100644 --- a/src/main/java/spoon/support/reflect/code/CtFieldWriteImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtFieldWriteImpl.java @@ -16,9 +16,13 @@ */ package spoon.support.reflect.code; + import spoon.reflect.code.CtFieldWrite; import spoon.reflect.visitor.CtVisitor; + + + public class CtFieldWriteImpl extends CtFieldAccessImpl implements CtFieldWrite { private static final long serialVersionUID = 1L; diff --git a/src/main/java/spoon/support/reflect/code/CtForEachImpl.java b/src/main/java/spoon/support/reflect/code/CtForEachImpl.java index 32ce30a24ba..1d9f819ea69 100644 --- a/src/main/java/spoon/support/reflect/code/CtForEachImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtForEachImpl.java @@ -16,6 +16,7 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtExpression; import spoon.reflect.code.CtForEach; @@ -25,6 +26,9 @@ import static spoon.reflect.path.CtRole.EXPRESSION; import static spoon.reflect.path.CtRole.FOREACH_VARIABLE; + + + public class CtForEachImpl extends CtLoopImpl implements CtForEach { private static final long serialVersionUID = 1L; @@ -50,23 +54,23 @@ public CtLocalVariable getVariable() { } @Override - public T setExpression(CtExpression expression) { + public CtForEachImpl setExpression(CtExpression expression) { if (expression != null) { expression.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, EXPRESSION, expression, this.expression); this.expression = expression; - return (T) this; + return this; } @Override - public T setVariable(CtLocalVariable variable) { + public CtForEachImpl setVariable(CtLocalVariable variable) { if (variable != null) { variable.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, FOREACH_VARIABLE, variable, this.variable); this.variable = variable; - return (T) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtForImpl.java b/src/main/java/spoon/support/reflect/code/CtForImpl.java index 127463a84d5..7c7ecb3c95c 100644 --- a/src/main/java/spoon/support/reflect/code/CtForImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtForImpl.java @@ -16,6 +16,9 @@ */ package spoon.support.reflect.code; + +import java.util.ArrayList; +import java.util.List; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtExpression; import spoon.reflect.code.CtFor; @@ -23,15 +26,15 @@ import spoon.reflect.visitor.CtVisitor; import spoon.support.reflect.declaration.CtElementImpl; -import java.util.ArrayList; -import java.util.List; - import static spoon.reflect.ModelElementContainerDefaultCapacities.FOR_INIT_STATEMENTS_CONTAINER_DEFAULT_CAPACITY; import static spoon.reflect.ModelElementContainerDefaultCapacities.FOR_UPDATE_STATEMENTS_CONTAINER_DEFAULT_CAPACITY; import static spoon.reflect.path.CtRole.EXPRESSION; import static spoon.reflect.path.CtRole.FOR_INIT; import static spoon.reflect.path.CtRole.FOR_UPDATE; + + + public class CtForImpl extends CtLoopImpl implements CtFor { private static final long serialVersionUID = 1L; @@ -55,13 +58,13 @@ public CtExpression getExpression() { } @Override - public T setExpression(CtExpression expression) { + public CtForImpl setExpression(CtExpression expression) { if (expression != null) { expression.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, EXPRESSION, expression, this.expression); this.expression = expression; - return (T) this; + return this; } @Override @@ -70,9 +73,9 @@ public List getForInit() { } @Override - public T addForInit(CtStatement statement) { + public CtForImpl addForInit(CtStatement statement) { if (statement == null) { - return (T) this; + return this; } if (forInit == CtElementImpl.emptyList()) { forInit = new ArrayList<>(FOR_INIT_STATEMENTS_CONTAINER_DEFAULT_CAPACITY); @@ -80,21 +83,21 @@ public T addForInit(CtStatement statement) { statement.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, FOR_INIT, this.forInit, statement); forInit.add(statement); - return (T) this; + return this; } @Override - public T setForInit(List statements) { + public CtForImpl setForInit(List statements) { if (statements == null || statements.isEmpty()) { this.forInit = CtElementImpl.emptyList(); - return (T) this; + return this; } getFactory().getEnvironment().getModelChangeListener().onListDeleteAll(this, FOR_INIT, this.forInit, new ArrayList<>(this.forInit)); this.forInit.clear(); for (CtStatement stmt : statements) { addForInit(stmt); } - return (T) this; + return this; } @Override @@ -112,9 +115,9 @@ public List getForUpdate() { } @Override - public T addForUpdate(CtStatement statement) { + public CtForImpl addForUpdate(CtStatement statement) { if (statement == null) { - return (T) this; + return this; } if (forUpdate == CtElementImpl.emptyList()) { forUpdate = new ArrayList<>(FOR_UPDATE_STATEMENTS_CONTAINER_DEFAULT_CAPACITY); @@ -122,21 +125,21 @@ public T addForUpdate(CtStatement statement) { statement.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, FOR_UPDATE, this.forUpdate, statement); forUpdate.add(statement); - return (T) this; + return this; } @Override - public T setForUpdate(List statements) { + public CtForImpl setForUpdate(List statements) { if (statements == null || statements.isEmpty()) { this.forUpdate = CtElementImpl.emptyList(); - return (T) this; + return this; } getFactory().getEnvironment().getModelChangeListener().onListDeleteAll(this, FOR_UPDATE, this.forUpdate, new ArrayList<>(this.forUpdate)); this.forUpdate.clear(); for (CtStatement stmt : statements) { addForUpdate(stmt); } - return (T) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtIfImpl.java b/src/main/java/spoon/support/reflect/code/CtIfImpl.java index 19c632786f2..55b94bdb106 100644 --- a/src/main/java/spoon/support/reflect/code/CtIfImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtIfImpl.java @@ -16,8 +16,8 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; -import spoon.reflect.code.CtCodeElement; import spoon.reflect.code.CtExpression; import spoon.reflect.code.CtIf; import spoon.reflect.code.CtStatement; @@ -28,6 +28,9 @@ import static spoon.reflect.path.CtRole.ELSE; import static spoon.reflect.path.CtRole.THEN; + + + public class CtIfImpl extends CtStatementImpl implements CtIf { private static final long serialVersionUID = 1L; @@ -63,34 +66,34 @@ public S getThenStatement() { } @Override - public T setCondition(CtExpression condition) { + public CtIfImpl setCondition(CtExpression condition) { if (condition != null) { condition.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CONDITION, condition, this.condition); this.condition = condition; - return (T) this; + return this; } @Override - public T setElseStatement(CtStatement elseStatement) { + public CtIfImpl setElseStatement(CtStatement elseStatement) { if (elseStatement != null) { elseStatement.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, ELSE, elseStatement, this.elseStatement); this.elseStatement = elseStatement; - return (T) this; + return this; } @Override - public T setThenStatement(CtStatement thenStatement) { + public CtIfImpl setThenStatement(CtStatement thenStatement) { // then branch might be null: `if (condition) ;` if (thenStatement != null) { thenStatement.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, THEN, thenStatement, this.thenStatement); this.thenStatement = thenStatement; - return (T) this; + return this; } @Override @@ -103,7 +106,7 @@ public Void S() { return null; } - public CtCodeElement getSubstitution(CtType targetType) { - return clone(); + public CtIfImpl getSubstitution(CtType targetType) { + return ((CtIfImpl) (clone())); } } diff --git a/src/main/java/spoon/support/reflect/code/CtInvocationImpl.java b/src/main/java/spoon/support/reflect/code/CtInvocationImpl.java index 38e2f744091..bfffe1c0421 100644 --- a/src/main/java/spoon/support/reflect/code/CtInvocationImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtInvocationImpl.java @@ -16,28 +16,28 @@ */ package spoon.support.reflect.code; + +import java.util.ArrayList; +import java.util.List; import spoon.reflect.annotations.MetamodelPropertyField; -import spoon.reflect.code.CtAbstractInvocation; import spoon.reflect.code.CtExpression; import spoon.reflect.code.CtInvocation; import spoon.reflect.code.CtStatement; import spoon.reflect.code.CtStatementList; -import spoon.reflect.declaration.CtTypedElement; -import spoon.reflect.reference.CtActualTypeContainer; import spoon.reflect.reference.CtExecutableReference; import spoon.reflect.reference.CtTypeReference; import spoon.reflect.visitor.CtVisitor; import spoon.support.DerivedProperty; import spoon.support.reflect.declaration.CtElementImpl; -import java.util.ArrayList; -import java.util.List; - import static spoon.reflect.ModelElementContainerDefaultCapacities.PARAMETERS_CONTAINER_DEFAULT_CAPACITY; import static spoon.reflect.path.CtRole.ARGUMENT; import static spoon.reflect.path.CtRole.EXECUTABLE_REF; import static spoon.reflect.path.CtRole.LABEL; + + + public class CtInvocationImpl extends CtTargetedExpressionImpl> implements CtInvocation { private static final long serialVersionUID = 1L; @@ -60,9 +60,9 @@ public List> getArguments() { return arguments; } - private > C addArgument(int position, CtExpression argument) { + private CtInvocationImpl addArgument(int position, CtExpression argument) { if (argument == null) { - return (C) this; + return this; } if (arguments == CtElementImpl.>emptyList()) { arguments = new ArrayList<>(PARAMETERS_CONTAINER_DEFAULT_CAPACITY); @@ -70,12 +70,12 @@ private > C addArgument(int position, CtExpres argument.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, ARGUMENT, this.arguments, position, argument); arguments.add(position, argument); - return (C) this; + return this; } @Override - public > C addArgument(CtExpression argument) { - return addArgument(arguments.size(), argument); + public CtInvocationImpl addArgument(CtExpression argument) { + return ((CtInvocationImpl) (addArgument(arguments.size(), argument))); } @Override @@ -98,34 +98,34 @@ public CtExecutableReference getExecutable() { } @Override - public C insertAfter(CtStatement statement) { + public CtInvocationImpl insertAfter(CtStatement statement) { CtStatementImpl.insertAfter(this, statement); - return (C) this; + return this; } @Override - public C insertBefore(CtStatement statement) { + public CtInvocationImpl insertBefore(CtStatement statement) { CtStatementImpl.insertBefore(this, statement); - return (C) this; + return this; } @Override - public C insertAfter(CtStatementList statements) { + public CtInvocationImpl insertAfter(CtStatementList statements) { CtStatementImpl.insertAfter(this, statements); - return (C) this; + return this; } @Override - public C insertBefore(CtStatementList statements) { + public CtInvocationImpl insertBefore(CtStatementList statements) { CtStatementImpl.insertBefore(this, statements); - return (C) this; + return this; } @Override - public > C setArguments(List> arguments) { + public CtInvocationImpl setArguments(List> arguments) { if (arguments == null || arguments.isEmpty()) { this.arguments = CtElementImpl.emptyList(); - return (C) this; + return this; } if (this.arguments == CtElementImpl.>emptyList()) { this.arguments = new ArrayList<>(PARAMETERS_CONTAINER_DEFAULT_CAPACITY); @@ -135,17 +135,17 @@ public > C setArguments(List> for (CtExpression expr : arguments) { addArgument(expr); } - return (C) this; + return this; } @Override - public > C setExecutable(CtExecutableReference executable) { + public CtInvocationImpl setExecutable(CtExecutableReference executable) { if (executable != null) { executable.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, EXECUTABLE_REF, executable, this.executable); this.executable = executable; - return (C) this; + return this; } @Override @@ -154,10 +154,10 @@ public String getLabel() { } @Override - public C setLabel(String label) { + public CtInvocationImpl setLabel(String label) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, LABEL, label, this.label); this.label = label; - return (C) this; + return this; } @Override @@ -168,14 +168,14 @@ public CtTypeReference getType() { @Override @DerivedProperty - public C setType(CtTypeReference type) { + public CtInvocationImpl setType(CtTypeReference type) { if (type != null) { type.setParent(this); } if (getExecutable() != null) { getExecutable().setType(type); } - return (C) this; + return this; } @Override @@ -184,19 +184,19 @@ public List> getActualTypeArguments() { } @Override - public T setActualTypeArguments(List> actualTypeArguments) { + public CtInvocationImpl setActualTypeArguments(List> actualTypeArguments) { if (getExecutable() != null) { getExecutable().setActualTypeArguments(actualTypeArguments); } - return (T) this; + return this; } @Override - public T addActualTypeArgument(CtTypeReference actualTypeArgument) { + public CtInvocationImpl addActualTypeArgument(CtTypeReference actualTypeArgument) { if (getExecutable() != null) { getExecutable().addActualTypeArgument(actualTypeArgument); } - return (T) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtJavaDocImpl.java b/src/main/java/spoon/support/reflect/code/CtJavaDocImpl.java index 3cc4c56d6d0..d184fdd6a8e 100644 --- a/src/main/java/spoon/support/reflect/code/CtJavaDocImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtJavaDocImpl.java @@ -16,7 +16,10 @@ */ package spoon.support.reflect.code; + +import java.util.List; import spoon.reflect.annotations.MetamodelPropertyField; +import spoon.reflect.code.CtComment; import spoon.reflect.code.CtJavaDoc; import spoon.reflect.code.CtJavaDocTag; import spoon.reflect.declaration.CtElement; @@ -24,7 +27,10 @@ import spoon.reflect.visitor.CtVisitor; import spoon.support.util.ModelList; -import java.util.List; +import static spoon.reflect.code.CtComment.CommentType.JAVADOC; + + + public class CtJavaDocImpl extends CtCommentImpl implements CtJavaDoc { @@ -54,33 +60,33 @@ public List getTags() { } @Override - public E setTags(List tags) { + public CtJavaDocImpl setTags(List tags) { this.tags.set(tags); - return (E) this; + return this; } @Override - public E addTag(CtJavaDocTag tag) { + public CtJavaDocImpl addTag(CtJavaDocTag tag) { this.tags.add(tag); - return (E) this; + return this; } @Override - public E addTag(int index, CtJavaDocTag tag) { + public CtJavaDocImpl addTag(int index, CtJavaDocTag tag) { this.tags.add(index, tag); - return (E) this; + return this; } @Override - public E removeTag(int index) { + public CtJavaDocImpl removeTag(int index) { this.tags.remove(index); - return (E) this; + return this; } @Override - public E removeTag(CtJavaDocTag tag) { + public CtJavaDocImpl removeTag(CtJavaDocTag tag) { this.tags.remove(tag); - return (E) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtJavaDocTagImpl.java b/src/main/java/spoon/support/reflect/code/CtJavaDocTagImpl.java index 16faa4c502d..4efc195c65f 100644 --- a/src/main/java/spoon/support/reflect/code/CtJavaDocTagImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtJavaDocTagImpl.java @@ -16,14 +16,19 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtJavaDocTag; import spoon.reflect.visitor.CtVisitor; import spoon.support.reflect.declaration.CtElementImpl; +import static spoon.reflect.code.CtJavaDocTag.TagType.tagFromName; import static spoon.reflect.path.CtRole.COMMENT_CONTENT; -import static spoon.reflect.path.CtRole.JAVADOC_TAG_VALUE; import static spoon.reflect.path.CtRole.DOCUMENTATION_TYPE; +import static spoon.reflect.path.CtRole.JAVADOC_TAG_VALUE; + + + public class CtJavaDocTagImpl extends CtElementImpl implements CtJavaDocTag { @@ -40,16 +45,16 @@ public TagType getType() { } @Override - public E setType(String type) { + public CtJavaDocTagImpl setType(String type) { this.setType(CtJavaDocTag.TagType.tagFromName(type)); - return (E) this; + return this; } @Override - public E setType(TagType type) { + public CtJavaDocTagImpl setType(TagType type) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, DOCUMENTATION_TYPE, type, this.type); this.type = type; - return (E) this; + return this; } @Override @@ -58,10 +63,10 @@ public String getContent() { } @Override - public E setContent(String content) { + public CtJavaDocTagImpl setContent(String content) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, COMMENT_CONTENT, content, this.content); this.content = content; - return (E) this; + return this; } @Override @@ -70,10 +75,10 @@ public String getParam() { } @Override - public E setParam(String param) { + public CtJavaDocTagImpl setParam(String param) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, JAVADOC_TAG_VALUE, param, this.param); this.param = param; - return (E) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtLambdaImpl.java b/src/main/java/spoon/support/reflect/code/CtLambdaImpl.java index e910abfed57..763bc5fa5da 100644 --- a/src/main/java/spoon/support/reflect/code/CtLambdaImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtLambdaImpl.java @@ -16,19 +16,22 @@ */ package spoon.support.reflect.code; + +import java.util.ArrayList; +import java.util.List; +import java.util.Set; +import java.util.function.Predicate; import spoon.SpoonException; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtBlock; -import spoon.reflect.code.CtBodyHolder; import spoon.reflect.code.CtExpression; import spoon.reflect.code.CtLambda; import spoon.reflect.code.CtStatement; import spoon.reflect.declaration.CtMethod; -import spoon.reflect.declaration.CtNamedElement; import spoon.reflect.declaration.CtParameter; import spoon.reflect.declaration.CtType; -import spoon.reflect.declaration.CtExecutable; import spoon.reflect.declaration.ModifierKind; +import spoon.reflect.factory.MethodFactory; import spoon.reflect.reference.CtExecutableReference; import spoon.reflect.reference.CtTypeReference; import spoon.reflect.visitor.CtVisitor; @@ -37,10 +40,6 @@ import spoon.support.util.QualifiedNameBasedSortedSet; import spoon.support.visitor.SignaturePrinter; -import java.util.ArrayList; -import java.util.List; -import java.util.Set; - import static spoon.reflect.ModelElementContainerDefaultCapacities.PARAMETERS_CONTAINER_DEFAULT_CAPACITY; import static spoon.reflect.path.CtRole.BODY; import static spoon.reflect.path.CtRole.EXPRESSION; @@ -48,6 +47,9 @@ import static spoon.reflect.path.CtRole.PARAMETER; import static spoon.reflect.path.CtRole.THROWN; + + + public class CtLambdaImpl extends CtExpressionImpl implements CtLambda { @MetamodelPropertyField(role = NAME) String simpleName = ""; @@ -71,10 +73,10 @@ public String getSimpleName() { } @Override - public C setSimpleName(String simpleName) { + public CtLambdaImpl setSimpleName(String simpleName) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, NAME, simpleName, this.simpleName); this.simpleName = simpleName; - return (C) this; + return this; } @Override @@ -84,7 +86,7 @@ public CtBlock getBody() { } @Override - public C setBody(CtStatement statement) { + public CtLambdaImpl setBody(CtStatement statement) { if (statement != null) { CtBlock body = getFactory().Code().getOrCreateCtBlock(statement); getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, BODY, body, this.body); @@ -100,7 +102,7 @@ public C setBody(CtStatement statement) { this.body = null; } - return (C) this; + return this; } @SuppressWarnings("unchecked") @@ -147,10 +149,10 @@ public List> getParameters() { } @Override - public > C setParameters(List> params) { + public CtLambdaImpl setParameters(List> params) { if (params == null || params.isEmpty()) { this.parameters = CtElementImpl.emptyList(); - return (C) this; + return this; } if (this.parameters == CtElementImpl.>emptyList()) { this.parameters = new ArrayList<>(PARAMETERS_CONTAINER_DEFAULT_CAPACITY); @@ -160,13 +162,13 @@ public > C setParameters(List> params) for (CtParameter p : params) { addParameter(p); } - return (C) this; + return this; } @Override - public > C addParameter(CtParameter parameter) { + public CtLambdaImpl addParameter(CtParameter parameter) { if (parameter == null) { - return (C) this; + return this; } if (parameters == CtElementImpl.>emptyList()) { parameters = new ArrayList<>(PARAMETERS_CONTAINER_DEFAULT_CAPACITY); @@ -174,7 +176,7 @@ public > C addParameter(CtParameter parameter) { parameter.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, PARAMETER, this.parameters, parameter); parameters.add(parameter); - return (C) this; + return this; } @Override @@ -193,14 +195,14 @@ public Set> getThrownTypes() { @Override @UnsettableProperty - public > C setThrownTypes(Set> thrownTypes) { - return (C) this; + public CtLambdaImpl setThrownTypes(Set> thrownTypes) { + return this; } @Override - public > C addThrownType(CtTypeReference throwType) { + public CtLambdaImpl addThrownType(CtTypeReference throwType) { if (throwType == null) { - return (C) this; + return this; } if (thrownTypes == CtElementImpl.>emptySet()) { thrownTypes = new QualifiedNameBasedSortedSet<>(); @@ -208,7 +210,7 @@ public > C addThrownType(CtTypeReference getExpression() { } @Override - public > C setExpression(CtExpression expression) { + public CtLambdaImpl setExpression(CtExpression expression) { if (body != null && expression != null) { throw new SpoonException("A lambda can't have two bodies."); } else { @@ -248,7 +250,7 @@ public > C setExpression(CtExpression expression) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, EXPRESSION, expression, this.expression); this.expression = expression; } - return (C) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtLiteralImpl.java b/src/main/java/spoon/support/reflect/code/CtLiteralImpl.java index cd7b3d20c0a..0b3d823b56d 100644 --- a/src/main/java/spoon/support/reflect/code/CtLiteralImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtLiteralImpl.java @@ -16,13 +16,15 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtLiteral; import spoon.reflect.declaration.CtElement; import spoon.reflect.path.CtRole; import spoon.reflect.visitor.CtVisitor; -import static spoon.reflect.path.CtRole.EXPRESSION; + + public class CtLiteralImpl extends CtExpressionImpl implements CtLiteral { private static final long serialVersionUID = 1L; @@ -41,13 +43,13 @@ public T getValue() { } @Override - public > C setValue(T value) { + public CtLiteralImpl setValue(T value) { if (this.value instanceof CtElement) { ((CtElement) this.value).setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, EXPRESSION, value, this.value); this.value = value; - return (C) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtLocalVariableImpl.java b/src/main/java/spoon/support/reflect/code/CtLocalVariableImpl.java index 3270a6b24a5..36546acedac 100644 --- a/src/main/java/spoon/support/reflect/code/CtLocalVariableImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtLocalVariableImpl.java @@ -16,14 +16,11 @@ */ package spoon.support.reflect.code; + +import java.util.Set; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtExpression; import spoon.reflect.code.CtLocalVariable; -import spoon.reflect.code.CtRHSReceiver; -import spoon.reflect.declaration.CtModifiable; -import spoon.reflect.declaration.CtNamedElement; -import spoon.reflect.declaration.CtTypedElement; -import spoon.reflect.declaration.CtVariable; import spoon.reflect.declaration.ModifierKind; import spoon.reflect.path.CtRole; import spoon.reflect.reference.CtLocalVariableReference; @@ -34,7 +31,8 @@ import spoon.support.reflect.CtExtendedModifier; import spoon.support.reflect.CtModifierHandler; -import java.util.Set; + + public class CtLocalVariableImpl extends CtStatementImpl implements CtLocalVariable { private static final long serialVersionUID = 1L; @@ -80,30 +78,30 @@ public CtTypeReference getType() { } @Override - public > C setDefaultExpression(CtExpression defaultExpression) { + public CtLocalVariableImpl setDefaultExpression(CtExpression defaultExpression) { if (defaultExpression != null) { defaultExpression.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.DEFAULT_EXPRESSION, defaultExpression, this.defaultExpression); this.defaultExpression = defaultExpression; - return (C) this; + return this; } @Override - public C setSimpleName(String simpleName) { + public CtLocalVariableImpl setSimpleName(String simpleName) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.NAME, simpleName, this.name); this.name = simpleName; - return (C) this; + return this; } @Override - public C setType(CtTypeReference type) { + public CtLocalVariableImpl setType(CtTypeReference type) { if (type != null) { type.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.TYPE, type, this.type); this.type = type; - return (C) this; + return this; } @Override @@ -117,27 +115,27 @@ public boolean hasModifier(ModifierKind modifier) { } @Override - public C setModifiers(Set modifiers) { + public CtLocalVariableImpl setModifiers(Set modifiers) { modifierHandler.setModifiers(modifiers); - return (C) this; + return this; } @Override - public C addModifier(ModifierKind modifier) { + public CtLocalVariableImpl addModifier(ModifierKind modifier) { modifierHandler.addModifier(modifier); - return (C) this; + return this; } @Override - public C removeModifier(ModifierKind modifier) { + public CtLocalVariableImpl removeModifier(ModifierKind modifier) { modifierHandler.removeModifier(modifier); - return (C) this; + return this; } @Override - public C setVisibility(ModifierKind visibility) { + public CtLocalVariableImpl setVisibility(ModifierKind visibility) { modifierHandler.setVisibility(visibility); - return (C) this; + return this; } @Override @@ -160,9 +158,9 @@ public Set getExtendedModifiers() { } @Override - public T setExtendedModifiers(Set extendedModifiers) { + public CtLocalVariableImpl setExtendedModifiers(Set extendedModifiers) { this.modifierHandler.setExtendedModifiers(extendedModifiers); - return (T) this; + return this; } @Override @@ -173,9 +171,9 @@ public CtExpression getAssignment() { @Override @UnsettableProperty - public > C setAssignment(CtExpression assignment) { + public CtLocalVariableImpl setAssignment(CtExpression assignment) { setDefaultExpression(assignment); - return (C) this; + return this; } @Override @@ -184,10 +182,10 @@ public boolean isInferred() { } @Override - public > U setInferred(boolean inferred) { + public CtLocalVariableImpl setInferred(boolean inferred) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.IS_INFERRED, inferred, this.inferred); this.inferred = inferred; - return (U) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtLoopImpl.java b/src/main/java/spoon/support/reflect/code/CtLoopImpl.java index 39dd2e192e4..d1857737195 100644 --- a/src/main/java/spoon/support/reflect/code/CtLoopImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtLoopImpl.java @@ -16,16 +16,18 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtBlock; -import spoon.reflect.code.CtBodyHolder; -import spoon.reflect.code.CtCodeElement; import spoon.reflect.code.CtLoop; import spoon.reflect.code.CtStatement; import spoon.reflect.declaration.CtType; import static spoon.reflect.path.CtRole.BODY; + + + public abstract class CtLoopImpl extends CtStatementImpl implements CtLoop { private static final long serialVersionUID = 1L; @@ -39,7 +41,7 @@ public CtStatement getBody() { @SuppressWarnings("unchecked") @Override - public T setBody(CtStatement statement) { + public CtLoopImpl setBody(CtStatement statement) { if (statement != null) { CtBlock body = getFactory().Code().getOrCreateCtBlock(statement); getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, BODY, body, this.body); @@ -51,7 +53,7 @@ public T setBody(CtStatement statement) { getFactory().getEnvironment().getModelChangeListener().onObjectDelete(this, BODY, this.body); this.body = null; } - return (T) this; + return this; } @Override @@ -64,7 +66,7 @@ public Void S() { return null; } - public CtCodeElement getSubstitution(CtType targetType) { - return clone(); + public CtLoopImpl getSubstitution(CtType targetType) { + return ((CtLoopImpl) (clone())); } } diff --git a/src/main/java/spoon/support/reflect/code/CtNewArrayImpl.java b/src/main/java/spoon/support/reflect/code/CtNewArrayImpl.java index 488a0abb292..190587936bb 100644 --- a/src/main/java/spoon/support/reflect/code/CtNewArrayImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtNewArrayImpl.java @@ -16,19 +16,22 @@ */ package spoon.support.reflect.code; + +import java.util.ArrayList; +import java.util.List; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtExpression; import spoon.reflect.code.CtNewArray; import spoon.reflect.visitor.CtVisitor; import spoon.support.reflect.declaration.CtElementImpl; -import java.util.ArrayList; -import java.util.List; - import static spoon.reflect.ModelElementContainerDefaultCapacities.NEW_ARRAY_DEFAULT_EXPRESSIONS_CONTAINER_DEFAULT_CAPACITY; import static spoon.reflect.path.CtRole.DIMENSION; import static spoon.reflect.path.CtRole.EXPRESSION; + + + public class CtNewArrayImpl extends CtExpressionImpl implements CtNewArray { private static final long serialVersionUID = 1L; @@ -54,23 +57,23 @@ public List> getElements() { } @Override - public > C setDimensionExpressions(List> dimensionExpressions) { + public CtNewArrayImpl setDimensionExpressions(List> dimensionExpressions) { if (dimensionExpressions == null || dimensionExpressions.isEmpty()) { this.dimensionExpressions = CtElementImpl.emptyList(); - return (C) this; + return this; } getFactory().getEnvironment().getModelChangeListener().onListDeleteAll(this, DIMENSION, this.dimensionExpressions, new ArrayList<>(this.dimensionExpressions)); this.dimensionExpressions.clear(); for (CtExpression expr : dimensionExpressions) { addDimensionExpression(expr); } - return (C) this; + return this; } @Override - public > C addDimensionExpression(CtExpression dimension) { + public CtNewArrayImpl addDimensionExpression(CtExpression dimension) { if (dimension == null) { - return (C) this; + return this; } if (dimensionExpressions == CtElementImpl.>emptyList()) { dimensionExpressions = new ArrayList<>(NEW_ARRAY_DEFAULT_EXPRESSIONS_CONTAINER_DEFAULT_CAPACITY); @@ -78,7 +81,7 @@ public > C addDimensionExpression(CtExpression dimension.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, DIMENSION, this.dimensionExpressions, dimension); dimensionExpressions.add(dimension); - return (C) this; + return this; } @Override @@ -91,23 +94,23 @@ public boolean removeDimensionExpression(CtExpression dimension) { } @Override - public > C setElements(List> expressions) { + public CtNewArrayImpl setElements(List> expressions) { if (expressions == null || expressions.isEmpty()) { this.expressions = CtElementImpl.emptyList(); - return (C) this; + return this; } getFactory().getEnvironment().getModelChangeListener().onListDeleteAll(this, EXPRESSION, this.expressions, new ArrayList<>(this.expressions)); this.expressions.clear(); for (CtExpression expr : expressions) { addElement(expr); } - return (C) this; + return this; } @Override - public > C addElement(CtExpression expression) { + public CtNewArrayImpl addElement(CtExpression expression) { if (expression == null) { - return (C) this; + return this; } if (expressions == CtElementImpl.>emptyList()) { this.expressions = new ArrayList<>(); @@ -115,7 +118,7 @@ public > C addElement(CtExpression expression) { expression.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, EXPRESSION, this.expressions, expression); expressions.add(expression); - return (C) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtNewClassImpl.java b/src/main/java/spoon/support/reflect/code/CtNewClassImpl.java index 04e59f9786f..88e29f74c1c 100644 --- a/src/main/java/spoon/support/reflect/code/CtNewClassImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtNewClassImpl.java @@ -16,6 +16,7 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtNewClass; import spoon.reflect.declaration.CtClass; @@ -23,6 +24,9 @@ import static spoon.reflect.path.CtRole.NESTED_TYPE; + + + public class CtNewClassImpl extends CtConstructorCallImpl implements CtNewClass { private static final long serialVersionUID = 1L; @@ -40,13 +44,13 @@ public CtClass getAnonymousClass() { } @Override - public N setAnonymousClass(CtClass anonymousClass) { + public CtNewClassImpl setAnonymousClass(CtClass anonymousClass) { if (anonymousClass != null) { anonymousClass.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, NESTED_TYPE, anonymousClass, this.anonymousClass); this.anonymousClass = anonymousClass; - return (N) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtOperatorAssignmentImpl.java b/src/main/java/spoon/support/reflect/code/CtOperatorAssignmentImpl.java index 796c0c7e7aa..9457104ed71 100644 --- a/src/main/java/spoon/support/reflect/code/CtOperatorAssignmentImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtOperatorAssignmentImpl.java @@ -16,6 +16,7 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.BinaryOperatorKind; import spoon.reflect.code.CtOperatorAssignment; @@ -23,6 +24,9 @@ import static spoon.reflect.path.CtRole.OPERATOR_KIND; + + + public class CtOperatorAssignmentImpl extends CtAssignmentImpl implements CtOperatorAssignment { private static final long serialVersionUID = 1L; @@ -40,10 +44,10 @@ public BinaryOperatorKind getKind() { } @Override - public > C setKind(BinaryOperatorKind kind) { + public CtOperatorAssignmentImpl setKind(BinaryOperatorKind kind) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, OPERATOR_KIND, kind, this.kind); this.kind = kind; - return (C) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtReturnImpl.java b/src/main/java/spoon/support/reflect/code/CtReturnImpl.java index 7b6cc843f1c..2628394a192 100644 --- a/src/main/java/spoon/support/reflect/code/CtReturnImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtReturnImpl.java @@ -16,8 +16,8 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; -import spoon.reflect.code.CtCodeElement; import spoon.reflect.code.CtExpression; import spoon.reflect.code.CtReturn; import spoon.reflect.declaration.CtType; @@ -25,6 +25,9 @@ import static spoon.reflect.path.CtRole.EXPRESSION; + + + public class CtReturnImpl extends CtStatementImpl implements CtReturn { private static final long serialVersionUID = 1L; @@ -42,13 +45,13 @@ public CtExpression getReturnedExpression() { } @Override - public > T setReturnedExpression(CtExpression expression) { + public CtReturnImpl setReturnedExpression(CtExpression expression) { if (expression != null) { expression.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, EXPRESSION, expression, this.returnedExpression); this.returnedExpression = expression; - return (T) this; + return this; } @Override @@ -61,7 +64,7 @@ public Void S() { return null; } - public CtCodeElement getSubstitution(CtType targetType) { - return clone(); + public CtReturnImpl getSubstitution(CtType targetType) { + return ((CtReturnImpl) (clone())); } } diff --git a/src/main/java/spoon/support/reflect/code/CtStatementImpl.java b/src/main/java/spoon/support/reflect/code/CtStatementImpl.java index 673fd1fba76..904b087297b 100644 --- a/src/main/java/spoon/support/reflect/code/CtStatementImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtStatementImpl.java @@ -16,6 +16,9 @@ */ package spoon.support.reflect.code; + +import java.util.ArrayList; +import java.util.List; import spoon.SpoonException; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtBlock; @@ -33,11 +36,11 @@ import spoon.reflect.reference.CtExecutableReference; import spoon.reflect.visitor.CtInheritanceScanner; -import java.util.ArrayList; -import java.util.List; - import static spoon.reflect.path.CtRole.LABEL; + + + public abstract class CtStatementImpl extends CtCodeElementImpl implements CtStatement { private static final long serialVersionUID = 1L; @@ -254,27 +257,27 @@ public int indexOfReference(List statements, CtElement target) { } @Override - public T insertBefore(CtStatement statement) throws ParentNotInitializedException { + public CtStatementImpl insertBefore(CtStatement statement) throws ParentNotInitializedException { insertBefore(this, statement); - return (T) this; + return this; } @Override - public T insertBefore(CtStatementList statements) throws ParentNotInitializedException { + public CtStatementImpl insertBefore(CtStatementList statements) throws ParentNotInitializedException { insertBefore(this, statements); - return (T) this; + return this; } @Override - public T insertAfter(CtStatement statement) throws ParentNotInitializedException { + public CtStatementImpl insertAfter(CtStatement statement) throws ParentNotInitializedException { insertAfter(this, statement); - return (T) this; + return this; } @Override - public T insertAfter(CtStatementList statements) throws ParentNotInitializedException { + public CtStatementImpl insertAfter(CtStatementList statements) throws ParentNotInitializedException { insertAfter(this, statements); - return (T) this; + return this; } @MetamodelPropertyField(role = LABEL) @@ -286,10 +289,10 @@ public String getLabel() { } @Override - public T setLabel(String label) { + public CtStatementImpl setLabel(String label) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, LABEL, label, this.label); this.label = label; - return (T) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtStatementListImpl.java b/src/main/java/spoon/support/reflect/code/CtStatementListImpl.java index 55c6ade6698..fbf1b46b6f9 100644 --- a/src/main/java/spoon/support/reflect/code/CtStatementListImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtStatementListImpl.java @@ -16,24 +16,26 @@ */ package spoon.support.reflect.code; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtStatement; import spoon.reflect.code.CtStatementList; import spoon.reflect.cu.SourcePosition; -import spoon.reflect.declaration.CtElement; import spoon.reflect.declaration.CtType; import spoon.reflect.visitor.CtVisitor; import spoon.reflect.visitor.Filter; import spoon.reflect.visitor.Query; import spoon.support.reflect.declaration.CtElementImpl; -import java.util.ArrayList; -import java.util.Iterator; -import java.util.List; - import static spoon.reflect.ModelElementContainerDefaultCapacities.BLOCK_STATEMENTS_CONTAINER_DEFAULT_CAPACITY; import static spoon.reflect.path.CtRole.STATEMENT; + + + public class CtStatementListImpl extends CtCodeElementImpl implements CtStatementList { private static final long serialVersionUID = 1L; @@ -51,28 +53,28 @@ public List getStatements() { } @Override - public T setStatements(List stmts) { + public CtStatementListImpl setStatements(List stmts) { if (stmts == null || stmts.isEmpty()) { this.statements = CtElementImpl.emptyList(); - return (T) this; + return this; } getFactory().getEnvironment().getModelChangeListener().onListDeleteAll(this, STATEMENT, this.statements, new ArrayList<>(this.statements)); this.statements.clear(); for (CtStatement stmt : stmts) { addStatement(stmt); } - return (T) this; + return this; } @Override - public T addStatement(CtStatement statement) { - return this.addStatement(this.statements.size(), statement); + public CtStatementListImpl addStatement(CtStatement statement) { + return ((CtStatementListImpl) (this.addStatement(this.statements.size(), statement))); } @Override - public T addStatement(int index, CtStatement statement) { + public CtStatementListImpl addStatement(int index, CtStatement statement) { if (statement == null) { - return (T) this; + return this; } if (this.statements == CtElementImpl.emptyList()) { this.statements = new ArrayList<>(BLOCK_STATEMENTS_CONTAINER_DEFAULT_CAPACITY); @@ -80,7 +82,7 @@ public T addStatement(int index, CtStatement stateme statement.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, STATEMENT, this.statements, index, statement); this.statements.add(index, statement); - return (T) this; + return this; } private void ensureModifiableStatementsList() { @@ -90,7 +92,7 @@ private void ensureModifiableStatementsList() { } @Override - public T insertBegin(CtStatementList statements) { + public CtStatementListImpl insertBegin(CtStatementList statements) { ensureModifiableStatementsList(); for (CtStatement statement : statements.getStatements()) { statement.setParent(this); @@ -99,11 +101,11 @@ public T insertBegin(CtStatementList statements) { if (isImplicit() && this.statements.size() > 1) { setImplicit(false); } - return (T) this; + return this; } @Override - public T insertBegin(CtStatement statement) { + public CtStatementListImpl insertBegin(CtStatement statement) { ensureModifiableStatementsList(); statement.setParent(this); this.addStatement(0, statement); @@ -111,18 +113,18 @@ public T insertBegin(CtStatement statement) { if (isImplicit() && this.statements.size() > 1) { setImplicit(false); } - return (T) this; + return this; } @Override - public T insertEnd(CtStatement statement) { + public CtStatementListImpl insertEnd(CtStatement statement) { ensureModifiableStatementsList(); addStatement(statement); - return (T) this; + return this; } @Override - public T insertEnd(CtStatementList statements) { + public CtStatementListImpl insertEnd(CtStatementList statements) { List tobeInserted = new ArrayList<>(statements.getStatements()); //remove statements from the `statementsToBeInserted` before they are added to spoon model //note: one element MUST NOT be part of two models. @@ -130,39 +132,39 @@ public T insertEnd(CtStatementList statements) { for (CtStatement s : tobeInserted) { insertEnd(s); } - return (T) this; + return this; } @Override - public T insertAfter(Filter insertionPoints, CtStatement statement) { + public CtStatementListImpl insertAfter(Filter insertionPoints, CtStatement statement) { for (CtStatement e : Query.getElements(this, insertionPoints)) { e.insertAfter(statement); } - return (T) this; + return this; } @Override - public T insertAfter(Filter insertionPoints, CtStatementList statements) { + public CtStatementListImpl insertAfter(Filter insertionPoints, CtStatementList statements) { for (CtStatement e : Query.getElements(this, insertionPoints)) { e.insertAfter(statements); } - return (T) this; + return this; } @Override - public T insertBefore(Filter insertionPoints, CtStatement statement) { + public CtStatementListImpl insertBefore(Filter insertionPoints, CtStatement statement) { for (CtStatement e : Query.getElements(this, insertionPoints)) { e.insertBefore(statement); } - return (T) this; + return this; } @Override - public T insertBefore(Filter insertionPoints, CtStatementList statements) { + public CtStatementListImpl insertBefore(Filter insertionPoints, CtStatementList statements) { for (CtStatement e : Query.getElements(this, insertionPoints)) { e.insertBefore(statements); } - return (T) this; + return this; } @Override @@ -185,11 +187,11 @@ public void removeStatement(CtStatement statement) { } @Override - public E setPosition(SourcePosition position) { + public CtStatementListImpl setPosition(SourcePosition position) { for (CtStatement s : statements) { s.setPosition(position); } - return (E) this; + return this; } @Override @@ -202,7 +204,7 @@ public CtStatementList clone() { return (CtStatementList) super.clone(); } - public CtStatementList getSubstitution(CtType targetType) { - return clone(); + public CtStatementListImpl getSubstitution(CtType targetType) { + return ((CtStatementListImpl) (clone())); } } diff --git a/src/main/java/spoon/support/reflect/code/CtSuperAccessImpl.java b/src/main/java/spoon/support/reflect/code/CtSuperAccessImpl.java index f7c8a8e07de..3f91ea2c8cf 100644 --- a/src/main/java/spoon/support/reflect/code/CtSuperAccessImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtSuperAccessImpl.java @@ -16,6 +16,7 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtExpression; import spoon.reflect.code.CtSuperAccess; @@ -24,6 +25,9 @@ import static spoon.reflect.path.CtRole.TARGET; + + + public class CtSuperAccessImpl extends CtVariableReadImpl implements CtSuperAccess { private static final long serialVersionUID = 1L; diff --git a/src/main/java/spoon/support/reflect/code/CtSwitchImpl.java b/src/main/java/spoon/support/reflect/code/CtSwitchImpl.java index 1398d4b208c..d7a88d39c29 100644 --- a/src/main/java/spoon/support/reflect/code/CtSwitchImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtSwitchImpl.java @@ -16,6 +16,9 @@ */ package spoon.support.reflect.code; + +import java.util.ArrayList; +import java.util.List; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtCase; import spoon.reflect.code.CtExpression; @@ -23,13 +26,13 @@ import spoon.reflect.visitor.CtVisitor; import spoon.support.reflect.declaration.CtElementImpl; -import java.util.ArrayList; -import java.util.List; - import static spoon.reflect.ModelElementContainerDefaultCapacities.SWITCH_CASES_CONTAINER_DEFAULT_CAPACITY; import static spoon.reflect.path.CtRole.CASE; import static spoon.reflect.path.CtRole.EXPRESSION; + + + public class CtSwitchImpl extends CtStatementImpl implements CtSwitch { private static final long serialVersionUID = 1L; @@ -55,33 +58,33 @@ public CtExpression getSelector() { } @Override - public > T setCases(List> cases) { + public CtSwitchImpl setCases(List> cases) { if (cases == null || cases.isEmpty()) { this.cases = CtElementImpl.emptyList(); - return (T) this; + return this; } getFactory().getEnvironment().getModelChangeListener().onListDeleteAll(this, CASE, this.cases, new ArrayList<>(this.cases)); this.cases.clear(); for (CtCase aCase : cases) { addCase(aCase); } - return (T) this; + return this; } @Override - public > T setSelector(CtExpression selector) { + public CtSwitchImpl setSelector(CtExpression selector) { if (selector != null) { selector.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, EXPRESSION, selector, this.expression); this.expression = selector; - return (T) this; + return this; } @Override - public > T addCase(CtCase c) { + public CtSwitchImpl addCase(CtCase c) { if (c == null) { - return (T) this; + return this; } if (cases == CtElementImpl.>emptyList()) { cases = new ArrayList<>(SWITCH_CASES_CONTAINER_DEFAULT_CAPACITY); @@ -89,7 +92,7 @@ public > T addCase(CtCase c) { c.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, CASE, this.cases, c); cases.add(c); - return (T) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtSynchronizedImpl.java b/src/main/java/spoon/support/reflect/code/CtSynchronizedImpl.java index fe0d318830e..b521391e306 100644 --- a/src/main/java/spoon/support/reflect/code/CtSynchronizedImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtSynchronizedImpl.java @@ -16,6 +16,7 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtBlock; import spoon.reflect.code.CtExpression; @@ -25,6 +26,9 @@ import static spoon.reflect.path.CtRole.BODY; import static spoon.reflect.path.CtRole.EXPRESSION; + + + public class CtSynchronizedImpl extends CtStatementImpl implements CtSynchronized { private static final long serialVersionUID = 1L; @@ -50,23 +54,23 @@ public CtExpression getExpression() { } @Override - public T setBlock(CtBlock block) { + public CtSynchronizedImpl setBlock(CtBlock block) { if (block != null) { block.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, BODY, block, this.block); this.block = block; - return (T) this; + return this; } @Override - public T setExpression(CtExpression expression) { + public CtSynchronizedImpl setExpression(CtExpression expression) { if (expression != null) { expression.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, EXPRESSION, expression, this.expression); this.expression = expression; - return (T) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtTargetedExpressionImpl.java b/src/main/java/spoon/support/reflect/code/CtTargetedExpressionImpl.java index 4aa314837a6..62e376d4c7a 100644 --- a/src/main/java/spoon/support/reflect/code/CtTargetedExpressionImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtTargetedExpressionImpl.java @@ -16,12 +16,16 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtExpression; import spoon.reflect.code.CtTargetedExpression; import static spoon.reflect.path.CtRole.TARGET; + + + public abstract class CtTargetedExpressionImpl> extends CtExpressionImpl implements CtTargetedExpression { private static final long serialVersionUID = 1L; diff --git a/src/main/java/spoon/support/reflect/code/CtThisAccessImpl.java b/src/main/java/spoon/support/reflect/code/CtThisAccessImpl.java index 2bbfca3fbd6..97feee418e3 100644 --- a/src/main/java/spoon/support/reflect/code/CtThisAccessImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtThisAccessImpl.java @@ -16,10 +16,14 @@ */ package spoon.support.reflect.code; + import spoon.reflect.code.CtExpression; import spoon.reflect.code.CtThisAccess; import spoon.reflect.visitor.CtVisitor; + + + public class CtThisAccessImpl extends CtTargetedExpressionImpl> implements CtThisAccess { private static final long serialVersionUID = 1L; diff --git a/src/main/java/spoon/support/reflect/code/CtThrowImpl.java b/src/main/java/spoon/support/reflect/code/CtThrowImpl.java index 6dc7f9a2855..b7e4bd133ee 100644 --- a/src/main/java/spoon/support/reflect/code/CtThrowImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtThrowImpl.java @@ -16,8 +16,8 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; -import spoon.reflect.code.CtCodeElement; import spoon.reflect.code.CtExpression; import spoon.reflect.code.CtThrow; import spoon.reflect.declaration.CtType; @@ -25,6 +25,9 @@ import static spoon.reflect.path.CtRole.EXPRESSION; + + + public class CtThrowImpl extends CtStatementImpl implements CtThrow { private static final long serialVersionUID = 1L; @@ -42,13 +45,13 @@ public CtExpression getThrownExpression() { } @Override - public T setThrownExpression(CtExpression expression) { + public CtThrowImpl setThrownExpression(CtExpression expression) { if (expression != null) { expression.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, EXPRESSION, expression, this.throwExpression); this.throwExpression = expression; - return (T) this; + return this; } @Override @@ -61,8 +64,8 @@ public Void S() { return null; } - public CtCodeElement getSubstitution(CtType targetType) { - return clone(); + public CtThrowImpl getSubstitution(CtType targetType) { + return ((CtThrowImpl) (clone())); } } diff --git a/src/main/java/spoon/support/reflect/code/CtTryImpl.java b/src/main/java/spoon/support/reflect/code/CtTryImpl.java index 48a8d13aa95..11ef250d00d 100644 --- a/src/main/java/spoon/support/reflect/code/CtTryImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtTryImpl.java @@ -16,25 +16,26 @@ */ package spoon.support.reflect.code; + +import java.util.ArrayList; +import java.util.List; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtBlock; -import spoon.reflect.code.CtBodyHolder; import spoon.reflect.code.CtCatch; -import spoon.reflect.code.CtCodeElement; import spoon.reflect.code.CtStatement; import spoon.reflect.code.CtTry; import spoon.reflect.declaration.CtType; import spoon.reflect.visitor.CtVisitor; import spoon.support.reflect.declaration.CtElementImpl; -import java.util.ArrayList; -import java.util.List; - import static spoon.reflect.ModelElementContainerDefaultCapacities.CATCH_CASES_CONTAINER_DEFAULT_CAPACITY; import static spoon.reflect.path.CtRole.BODY; import static spoon.reflect.path.CtRole.CATCH; import static spoon.reflect.path.CtRole.FINALIZER; + + + public class CtTryImpl extends CtStatementImpl implements CtTry { private static final long serialVersionUID = 1L; @@ -58,23 +59,23 @@ public List getCatchers() { } @Override - public T setCatchers(List catchers) { + public CtTryImpl setCatchers(List catchers) { if (catchers == null || catchers.isEmpty()) { this.catchers = CtElementImpl.emptyList(); - return (T) this; + return this; } getFactory().getEnvironment().getModelChangeListener().onListDeleteAll(this, CATCH, this.catchers, new ArrayList<>(this.catchers)); this.catchers.clear(); for (CtCatch c : catchers) { addCatcher(c); } - return (T) this; + return this; } @Override - public T addCatcher(CtCatch catcher) { + public CtTryImpl addCatcher(CtCatch catcher) { if (catcher == null) { - return (T) this; + return this; } if (catchers == CtElementImpl.emptyList()) { catchers = new ArrayList<>(CATCH_CASES_CONTAINER_DEFAULT_CAPACITY); @@ -82,7 +83,7 @@ public T addCatcher(CtCatch catcher) { catcher.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, CATCH, this.catchers, catcher); catchers.add(catcher); - return (T) this; + return this; } @Override @@ -100,13 +101,13 @@ public CtBlock getFinalizer() { } @Override - public T setFinalizer(CtBlock finalizer) { + public CtTryImpl setFinalizer(CtBlock finalizer) { if (finalizer != null) { finalizer.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, FINALIZER, finalizer, this.finalizer); this.finalizer = finalizer; - return (T) this; + return this; } @Override @@ -115,7 +116,7 @@ public CtBlock getBody() { } @Override - public T setBody(CtStatement statement) { + public CtTryImpl setBody(CtStatement statement) { if (statement != null) { CtBlock body = getFactory().Code().getOrCreateCtBlock(statement); getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, BODY, body, this.body); @@ -128,7 +129,7 @@ public T setBody(CtStatement statement) { this.body = null; } - return (T) this; + return this; } @Override @@ -141,8 +142,8 @@ public Void S() { return null; } - public CtCodeElement getSubstitution(CtType targetType) { - return clone(); + public CtTryImpl getSubstitution(CtType targetType) { + return ((CtTryImpl) (clone())); } } diff --git a/src/main/java/spoon/support/reflect/code/CtTryWithResourceImpl.java b/src/main/java/spoon/support/reflect/code/CtTryWithResourceImpl.java index 052ed42ac4f..3ce28e66844 100644 --- a/src/main/java/spoon/support/reflect/code/CtTryWithResourceImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtTryWithResourceImpl.java @@ -16,18 +16,21 @@ */ package spoon.support.reflect.code; + +import java.util.ArrayList; +import java.util.List; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtLocalVariable; import spoon.reflect.code.CtTryWithResource; import spoon.reflect.visitor.CtVisitor; import spoon.support.reflect.declaration.CtElementImpl; -import java.util.ArrayList; -import java.util.List; - import static spoon.reflect.ModelElementContainerDefaultCapacities.RESOURCES_CONTAINER_DEFAULT_CAPACITY; import static spoon.reflect.path.CtRole.TRY_RESOURCE; + + + public class CtTryWithResourceImpl extends CtTryImpl implements CtTryWithResource { private static final long serialVersionUID = 1L; @@ -45,23 +48,23 @@ public List> getResources() { } @Override - public T setResources(List> resources) { + public CtTryWithResourceImpl setResources(List> resources) { if (resources == null || resources.isEmpty()) { this.resources = CtElementImpl.emptyList(); - return (T) this; + return this; } getFactory().getEnvironment().getModelChangeListener().onListDeleteAll(this, TRY_RESOURCE, this.resources, new ArrayList<>(this.resources)); this.resources.clear(); for (CtLocalVariable l : resources) { addResource(l); } - return (T) this; + return this; } @Override - public T addResource(CtLocalVariable resource) { + public CtTryWithResourceImpl addResource(CtLocalVariable resource) { if (resource == null) { - return (T) this; + return this; } if (resources == CtElementImpl.>emptyList()) { resources = new ArrayList<>(RESOURCES_CONTAINER_DEFAULT_CAPACITY); @@ -69,7 +72,7 @@ public T addResource(CtLocalVariable resource) resource.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, TRY_RESOURCE, this.resources, resource); resources.add(resource); - return (T) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtTypeAccessImpl.java b/src/main/java/spoon/support/reflect/code/CtTypeAccessImpl.java index 2bccad4c588..2f5a8ffb502 100644 --- a/src/main/java/spoon/support/reflect/code/CtTypeAccessImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtTypeAccessImpl.java @@ -16,15 +16,19 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtTypeAccess; -import spoon.reflect.declaration.CtTypedElement; +import spoon.reflect.factory.TypeFactory; import spoon.reflect.reference.CtTypeReference; import spoon.reflect.visitor.CtVisitor; import spoon.support.UnsettableProperty; import static spoon.reflect.path.CtRole.ACCESSED_TYPE; + + + public class CtTypeAccessImpl extends CtExpressionImpl implements CtTypeAccess { @MetamodelPropertyField(role = ACCESSED_TYPE) @@ -41,13 +45,13 @@ public CtTypeReference getAccessedType() { } @Override - public > C setAccessedType(CtTypeReference accessedType) { + public CtTypeAccessImpl setAccessedType(CtTypeReference accessedType) { if (accessedType != null) { accessedType.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, ACCESSED_TYPE, accessedType, this.type); type = accessedType; - return (C) this; + return this; } @Override @@ -57,9 +61,9 @@ public CtTypeReference getType() { @Override @UnsettableProperty - public C setType(CtTypeReference type) { + public CtTypeAccessImpl setType(CtTypeReference type) { // type is used in setAccessedType now. - return (C) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtUnaryOperatorImpl.java b/src/main/java/spoon/support/reflect/code/CtUnaryOperatorImpl.java index 685d2a98ebe..f9f1fd4f61c 100644 --- a/src/main/java/spoon/support/reflect/code/CtUnaryOperatorImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtUnaryOperatorImpl.java @@ -16,6 +16,7 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtExpression; import spoon.reflect.code.CtStatement; @@ -28,6 +29,9 @@ import static spoon.reflect.path.CtRole.LABEL; import static spoon.reflect.path.CtRole.OPERATOR_KIND; + + + public class CtUnaryOperatorImpl extends CtExpressionImpl implements CtUnaryOperator { private static final long serialVersionUID = 1L; @@ -61,51 +65,51 @@ public String getLabel() { } @Override - public C insertAfter(CtStatement statement) { + public CtUnaryOperatorImpl insertAfter(CtStatement statement) { CtStatementImpl.insertAfter(this, statement); - return (C) this; + return this; } @Override - public C insertBefore(CtStatement statement) { + public CtUnaryOperatorImpl insertBefore(CtStatement statement) { CtStatementImpl.insertBefore(this, statement); - return (C) this; + return this; } @Override - public C insertAfter(CtStatementList statements) { + public CtUnaryOperatorImpl insertAfter(CtStatementList statements) { CtStatementImpl.insertAfter(this, statements); - return (C) this; + return this; } @Override - public C insertBefore(CtStatementList statements) { + public CtUnaryOperatorImpl insertBefore(CtStatementList statements) { CtStatementImpl.insertBefore(this, statements); - return (C) this; + return this; } @Override - public C setOperand(CtExpression expression) { + public CtUnaryOperatorImpl setOperand(CtExpression expression) { if (expression != null) { expression.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, EXPRESSION, expression, this.operand); this.operand = expression; - return (C) this; + return this; } @Override - public C setKind(UnaryOperatorKind kind) { + public CtUnaryOperatorImpl setKind(UnaryOperatorKind kind) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, OPERATOR_KIND, kind, this.kind); this.kind = kind; - return (C) this; + return this; } @Override - public C setLabel(String label) { + public CtUnaryOperatorImpl setLabel(String label) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, LABEL, label, this.label); this.label = label; - return (C) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtVariableAccessImpl.java b/src/main/java/spoon/support/reflect/code/CtVariableAccessImpl.java index 4047e9f79d6..f43076a095a 100644 --- a/src/main/java/spoon/support/reflect/code/CtVariableAccessImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtVariableAccessImpl.java @@ -16,15 +16,18 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtVariableAccess; -import spoon.reflect.declaration.CtTypedElement; import spoon.reflect.reference.CtTypeReference; import spoon.reflect.reference.CtVariableReference; import spoon.support.DerivedProperty; import static spoon.reflect.path.CtRole.VARIABLE; + + + public abstract class CtVariableAccessImpl extends CtExpressionImpl implements CtVariableAccess { private static final long serialVersionUID = 1L; @@ -41,13 +44,13 @@ public CtVariableReference getVariable() { } @Override - public > C setVariable(CtVariableReference variable) { + public CtVariableAccessImpl setVariable(CtVariableReference variable) { if (variable != null) { variable.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, VARIABLE, variable, this.variable); this.variable = variable; - return (C) this; + return this; } @Override @@ -58,14 +61,14 @@ public CtTypeReference getType() { @Override @DerivedProperty - public C setType(CtTypeReference type) { + public CtVariableAccessImpl setType(CtTypeReference type) { if (type != null) { type.setParent(this); } if (type != null) { getVariable().setType(type); } - return (C) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/code/CtVariableReadImpl.java b/src/main/java/spoon/support/reflect/code/CtVariableReadImpl.java index dbb49f0130d..e14aae61ca5 100644 --- a/src/main/java/spoon/support/reflect/code/CtVariableReadImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtVariableReadImpl.java @@ -16,9 +16,13 @@ */ package spoon.support.reflect.code; + import spoon.reflect.code.CtVariableRead; import spoon.reflect.visitor.CtVisitor; + + + public class CtVariableReadImpl extends CtVariableAccessImpl implements CtVariableRead { private static final long serialVersionUID = 1L; diff --git a/src/main/java/spoon/support/reflect/code/CtVariableWriteImpl.java b/src/main/java/spoon/support/reflect/code/CtVariableWriteImpl.java index 60f953cfd48..addb19fc777 100644 --- a/src/main/java/spoon/support/reflect/code/CtVariableWriteImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtVariableWriteImpl.java @@ -16,9 +16,13 @@ */ package spoon.support.reflect.code; + import spoon.reflect.code.CtVariableWrite; import spoon.reflect.visitor.CtVisitor; + + + public class CtVariableWriteImpl extends CtVariableAccessImpl implements CtVariableWrite { private static final long serialVersionUID = 1L; diff --git a/src/main/java/spoon/support/reflect/code/CtWhileImpl.java b/src/main/java/spoon/support/reflect/code/CtWhileImpl.java index aeef42434b5..f6cce3f69b5 100644 --- a/src/main/java/spoon/support/reflect/code/CtWhileImpl.java +++ b/src/main/java/spoon/support/reflect/code/CtWhileImpl.java @@ -16,6 +16,7 @@ */ package spoon.support.reflect.code; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtExpression; import spoon.reflect.code.CtWhile; @@ -23,6 +24,9 @@ import static spoon.reflect.path.CtRole.EXPRESSION; + + + public class CtWhileImpl extends CtLoopImpl implements CtWhile { private static final long serialVersionUID = 1L; @@ -40,13 +44,13 @@ public CtExpression getLoopingExpression() { } @Override - public T setLoopingExpression(CtExpression expression) { + public CtWhileImpl setLoopingExpression(CtExpression expression) { if (expression != null) { expression.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, EXPRESSION, expression, this.expression); this.expression = expression; - return (T) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/declaration/CtAnnotationImpl.java b/src/main/java/spoon/support/reflect/declaration/CtAnnotationImpl.java index 7f98f6939e3..541945ee4c2 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtAnnotationImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtAnnotationImpl.java @@ -16,6 +16,23 @@ */ package spoon.support.reflect.declaration; + +import java.lang.annotation.Annotation; +import java.lang.reflect.Array; +import java.lang.reflect.Field; +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.lang.reflect.Proxy; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; +import java.util.TreeMap; +import java.util.TreeSet; import spoon.Launcher; import spoon.SpoonException; import spoon.reflect.annotations.MetamodelPropertyField; @@ -33,7 +50,6 @@ import spoon.reflect.declaration.CtElement; import spoon.reflect.declaration.CtField; import spoon.reflect.declaration.CtMethod; -import spoon.reflect.declaration.CtShadowable; import spoon.reflect.declaration.CtType; import spoon.reflect.eval.PartialEvaluator; import spoon.reflect.path.CtRole; @@ -46,22 +62,8 @@ import spoon.support.comparator.CtLineElementComparator; import spoon.support.reflect.code.CtExpressionImpl; -import java.lang.annotation.Annotation; -import java.lang.reflect.Array; -import java.lang.reflect.Field; -import java.lang.reflect.InvocationHandler; -import java.lang.reflect.Method; -import java.lang.reflect.Proxy; -import java.util.Collection; -import java.util.Collections; -import java.util.Comparator; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Map.Entry; -import java.util.Set; -import java.util.TreeMap; -import java.util.TreeSet; + + /** * The implementation for {@link spoon.reflect.declaration.CtAnnotation}. @@ -101,11 +103,11 @@ public void accept(CtVisitor visitor) { } @Override - public > T addValue(String elementName, Object value) { + public CtAnnotationImpl addValue(String elementName, Object value) { if (value instanceof CtExpression) { - return addValueExpression(elementName, (CtExpression) value); + return ((CtAnnotationImpl) (addValueExpression(elementName, ((CtExpression) (value))))); } - return this.addValueExpression(elementName, convertValueToExpression(value)); + return ((CtAnnotationImpl) (this.addValueExpression(elementName, convertValueToExpression(value)))); } private CtExpression convertValueToExpression(Object value) { @@ -162,7 +164,7 @@ private boolean isPrimitive(Class c) { return c.isPrimitive() || c == Byte.class || c == Short.class || c == Integer.class || c == Long.class || c == Float.class || c == Double.class || c == Boolean.class || c == Character.class; } - private > T addValueExpression(String elementName, CtExpression expression) { + private CtAnnotationImpl addValueExpression(String elementName, CtExpression expression) { if (elementValues.containsKey(elementName)) { // Update value of the existing one. final CtExpression ctExpression = elementValues.get(elementName); @@ -191,27 +193,27 @@ private > T addValueExpression(String elementName, CtE getFactory().getEnvironment().getModelChangeListener().onMapAdd(this, CtRole.VALUE, this.elementValues, elementName, expression); elementValues.put(elementName, expression); } - return (T) this; + return this; } @Override - public > T addValue(String elementName, CtLiteral value) { - return addValueExpression(elementName, value); + public CtAnnotationImpl addValue(String elementName, CtLiteral value) { + return ((CtAnnotationImpl) (addValueExpression(elementName, value))); } @Override - public > T addValue(String elementName, CtNewArray value) { - return addValueExpression(elementName, value); + public CtAnnotationImpl addValue(String elementName, CtNewArray value) { + return ((CtAnnotationImpl) (addValueExpression(elementName, value))); } @Override - public > T addValue(String elementName, CtFieldAccess value) { - return addValueExpression(elementName, value); + public CtAnnotationImpl addValue(String elementName, CtFieldAccess value) { + return ((CtAnnotationImpl) (addValueExpression(elementName, value))); } @Override - public > T addValue(String elementName, CtAnnotation value) { - return addValueExpression(elementName, value); + public CtAnnotationImpl addValue(String elementName, CtAnnotation value) { + return ((CtAnnotationImpl) (addValueExpression(elementName, value))); } /** @@ -306,8 +308,8 @@ private CtExpression getDefaultExpression(String fieldName) { @Override @SuppressWarnings("unchecked") - public T getValue(String key) { - return (T) getValueAsExpression(key); + public CtAnnotationImpl getValue(String key) { + return ((CtAnnotationImpl) (getValueAsExpression(key))); } @Override @@ -456,38 +458,38 @@ private Object getReflectValue(String fieldname) { @Override @SuppressWarnings("unchecked") - public > T setAnnotationType(CtTypeReference annotationType) { + public CtAnnotationImpl setAnnotationType(CtTypeReference annotationType) { if (annotationType != null) { annotationType.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.TYPE, annotationType, this.annotationType); this.annotationType = (CtTypeReference) annotationType; - return (T) this; + return this; } @Override - public > T setElementValues(Map values) { + public CtAnnotationImpl setElementValues(Map values) { getFactory().getEnvironment().getModelChangeListener().onMapDeleteAll(this, CtRole.VALUE, this.elementValues, new HashMap<>(elementValues)); this.elementValues.clear(); for (Entry e : values.entrySet()) { addValue(e.getKey(), e.getValue()); } - return (T) this; + return this; } @Override - public > T setValues(Map values) { + public CtAnnotationImpl setValues(Map values) { getFactory().getEnvironment().getModelChangeListener().onMapDeleteAll(this, CtRole.VALUE, this.elementValues, new HashMap<>(elementValues)); this.elementValues.clear(); for (Entry e : values.entrySet()) { addValue(e.getKey(), e.getValue()); } - return (T) this; + return this; } @Override - public CtElement getAnnotatedElement() { - return this.getParent(); + public CtAnnotationImpl getAnnotatedElement() { + return ((CtAnnotationImpl) (this.getParent())); } @Override @@ -530,10 +532,10 @@ public boolean isShadow() { } @Override - public E setShadow(boolean isShadow) { + public CtAnnotationImpl setShadow(boolean isShadow) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.IS_SHADOW, isShadow, this.isShadow); this.isShadow = isShadow; - return (E) this; + return this; } @Override @@ -549,7 +551,7 @@ public List> getTypeCasts() { @Override @UnsettableProperty - public > C setTypeCasts(List> casts) { - return (C) this; + public CtAnnotationImpl setTypeCasts(List> casts) { + return this; } } diff --git a/src/main/java/spoon/support/reflect/declaration/CtAnnotationMethodImpl.java b/src/main/java/spoon/support/reflect/declaration/CtAnnotationMethodImpl.java index 2ec40b54710..a6a5d510fa5 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtAnnotationMethodImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtAnnotationMethodImpl.java @@ -16,14 +16,14 @@ */ package spoon.support.reflect.declaration; + +import java.util.List; +import java.util.Set; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtBlock; -import spoon.reflect.code.CtBodyHolder; import spoon.reflect.code.CtExpression; import spoon.reflect.code.CtStatement; import spoon.reflect.declaration.CtAnnotationMethod; -import spoon.reflect.declaration.CtExecutable; -import spoon.reflect.declaration.CtFormalTypeDeclarer; import spoon.reflect.declaration.CtParameter; import spoon.reflect.declaration.CtTypeParameter; import spoon.reflect.reference.CtTypeReference; @@ -33,8 +33,8 @@ import static spoon.reflect.path.CtRole.DEFAULT_EXPRESSION; -import java.util.List; -import java.util.Set; + + /** * The implementation for {@link spoon.reflect.declaration.CtAnnotationMethod}. @@ -54,13 +54,13 @@ public CtExpression getDefaultExpression() { } @Override - public > C setDefaultExpression(CtExpression assignedExpression) { + public CtAnnotationMethodImpl setDefaultExpression(CtExpression assignedExpression) { if (assignedExpression != null) { assignedExpression.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, DEFAULT_EXPRESSION, assignedExpression, this.defaultExpression); this.defaultExpression = assignedExpression; - return (C) this; + return this; } @Override @@ -71,8 +71,8 @@ public CtBlock getBody() { @Override @UnsettableProperty - public T setBody(CtStatement statement) { - return (T) this; + public CtAnnotationMethodImpl setBody(CtStatement statement) { + return this; } @Override @@ -83,8 +83,8 @@ public Set> getThrownTypes() { @Override @UnsettableProperty - public > U setThrownTypes(Set> thrownTypes) { - return (U) this; + public CtAnnotationMethodImpl setThrownTypes(Set> thrownTypes) { + return this; } @Override @@ -95,8 +95,8 @@ public List getFormalCtTypeParameters() { @Override @UnsettableProperty - public C setFormalCtTypeParameters(List formalTypeParameters) { - return (C) this; + public CtAnnotationMethodImpl setFormalCtTypeParameters(List formalTypeParameters) { + return this; } @Override @@ -107,8 +107,8 @@ public List> getParameters() { @Override @UnsettableProperty - public > U setParameters(List> parameters) { - return (U) this; + public CtAnnotationMethodImpl setParameters(List> parameters) { + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/declaration/CtAnnotationTypeImpl.java b/src/main/java/spoon/support/reflect/declaration/CtAnnotationTypeImpl.java index 48652937c40..7d2a6be13dd 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtAnnotationTypeImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtAnnotationTypeImpl.java @@ -16,22 +16,23 @@ */ package spoon.support.reflect.declaration; + +import java.lang.annotation.Annotation; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Set; import spoon.reflect.declaration.CtAnnotationMethod; import spoon.reflect.declaration.CtAnnotationType; -import spoon.reflect.declaration.CtFormalTypeDeclarer; import spoon.reflect.declaration.CtMethod; -import spoon.reflect.declaration.CtType; import spoon.reflect.declaration.CtTypeParameter; import spoon.reflect.reference.CtTypeReference; import spoon.reflect.visitor.CtVisitor; import spoon.support.DerivedProperty; import spoon.support.UnsettableProperty; -import java.lang.annotation.Annotation; -import java.util.Collections; -import java.util.HashSet; -import java.util.List; -import java.util.Set; + + /** * The implementation for {@link spoon.reflect.declaration.CtAnnotationType}. @@ -65,14 +66,14 @@ public CtTypeReference getSuperclass() { @Override @UnsettableProperty - public > C setSuperclass(CtTypeReference superClass) { - return (C) this; + public CtAnnotationTypeImpl setSuperclass(CtTypeReference superClass) { + return this; } @Override @UnsettableProperty - public > C setSuperInterfaces(Set> interfaces) { - return (C) this; + public CtAnnotationTypeImpl setSuperInterfaces(Set> interfaces) { + return this; } @Override @@ -83,8 +84,8 @@ public List getFormalCtTypeParameters() { @Override @UnsettableProperty - public C setFormalCtTypeParameters(List formalTypeParameters) { - return (C) this; + public CtAnnotationTypeImpl setFormalCtTypeParameters(List formalTypeParameters) { + return this; } @Override @@ -107,10 +108,10 @@ public Set> getAnnotationMethods() { } @Override - public > C addMethod(CtMethod method) { + public CtAnnotationTypeImpl addMethod(CtMethod method) { if (method != null && !(method instanceof CtAnnotationMethod)) { throw new IllegalArgumentException("The method " + method.getSignature() + " should be a " + CtAnnotationMethod.class.getName()); } - return super.addMethod(method); + return ((CtAnnotationTypeImpl) (super.addMethod(method))); } } diff --git a/src/main/java/spoon/support/reflect/declaration/CtAnonymousExecutableImpl.java b/src/main/java/spoon/support/reflect/declaration/CtAnonymousExecutableImpl.java index 3e1bbba94fa..66f4c07c4f9 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtAnonymousExecutableImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtAnonymousExecutableImpl.java @@ -16,14 +16,14 @@ */ package spoon.support.reflect.declaration; + +import java.util.List; +import java.util.Set; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.declaration.CtAnonymousExecutable; -import spoon.reflect.declaration.CtExecutable; -import spoon.reflect.declaration.CtModifiable; -import spoon.reflect.declaration.CtNamedElement; import spoon.reflect.declaration.CtParameter; -import spoon.reflect.declaration.CtTypedElement; import spoon.reflect.declaration.ModifierKind; +import spoon.reflect.factory.TypeFactory; import spoon.reflect.path.CtRole; import spoon.reflect.reference.CtTypeReference; import spoon.reflect.visitor.CtVisitor; @@ -32,8 +32,8 @@ import spoon.support.reflect.CtExtendedModifier; import spoon.support.reflect.CtModifierHandler; -import java.util.List; -import java.util.Set; + + public class CtAnonymousExecutableImpl extends CtExecutableImpl implements CtAnonymousExecutable { private static final long serialVersionUID = 1L; @@ -47,15 +47,15 @@ public void accept(CtVisitor visitor) { } @Override - public T addModifier(ModifierKind modifier) { + public CtAnonymousExecutableImpl addModifier(ModifierKind modifier) { modifierHandler.addModifier(modifier); - return (T) this; + return this; } @Override - public T removeModifier(ModifierKind modifier) { + public CtAnonymousExecutableImpl removeModifier(ModifierKind modifier) { modifierHandler.removeModifier(modifier); - return (T) this; + return this; } @Override @@ -83,15 +83,15 @@ public boolean hasModifier(ModifierKind modifier) { } @Override - public T setModifiers(Set modifiers) { + public CtAnonymousExecutableImpl setModifiers(Set modifiers) { modifierHandler.setModifiers(modifiers); - return (T) this; + return this; } @Override - public T setVisibility(ModifierKind visibility) { + public CtAnonymousExecutableImpl setVisibility(ModifierKind visibility) { modifierHandler.setVisibility(visibility); - return (T) this; + return this; } @Override @@ -100,9 +100,9 @@ public Set getExtendedModifiers() { } @Override - public T setExtendedModifiers(Set extendedModifiers) { + public CtAnonymousExecutableImpl setExtendedModifiers(Set extendedModifiers) { this.modifierHandler.setExtendedModifiers(extendedModifiers); - return (T) this; + return this; } @Override @@ -113,14 +113,14 @@ public List> getParameters() { @Override @UnsettableProperty - public CtExecutable setParameters(List list) { + public CtAnonymousExecutableImpl setParameters(List list) { // unsettable property return this; } @Override @UnsettableProperty - public CtExecutable addParameter(CtParameter parameter) { + public CtAnonymousExecutableImpl addParameter(CtParameter parameter) { // unsettable property return this; } @@ -139,14 +139,14 @@ public Set> getThrownTypes() { @Override @UnsettableProperty - public CtExecutable setThrownTypes(Set thrownTypes) { + public CtAnonymousExecutableImpl setThrownTypes(Set thrownTypes) { // unsettable property return this; } @Override @UnsettableProperty - public CtExecutable addThrownType(CtTypeReference throwType) { + public CtAnonymousExecutableImpl addThrownType(CtTypeReference throwType) { // unsettable property return this; } @@ -165,9 +165,9 @@ public String getSimpleName() { @Override @UnsettableProperty - public T setSimpleName(String simpleName) { + public CtAnonymousExecutableImpl setSimpleName(String simpleName) { // unsettable property - return (T) this; + return this; } @Override @@ -178,9 +178,9 @@ public CtTypeReference getType() { @Override @UnsettableProperty - public C setType(CtTypeReference type) { + public CtAnonymousExecutableImpl setType(CtTypeReference type) { // unsettable property - return (C) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/declaration/CtClassImpl.java b/src/main/java/spoon/support/reflect/declaration/CtClassImpl.java index fe6a3492464..48b164e45b8 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtClassImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtClassImpl.java @@ -16,7 +16,18 @@ */ package spoon.support.reflect.declaration; + +import java.io.File; +import java.net.MalformedURLException; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.Set; import spoon.SpoonException; +import spoon.SpoonModelBuilder; import spoon.SpoonModelBuilder.InputType; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtCodeElement; @@ -26,7 +37,6 @@ import spoon.reflect.declaration.CtClass; import spoon.reflect.declaration.CtConstructor; import spoon.reflect.declaration.CtExecutable; -import spoon.reflect.declaration.CtType; import spoon.reflect.declaration.CtTypeMember; import spoon.reflect.reference.CtExecutableReference; import spoon.reflect.reference.CtTypeReference; @@ -37,20 +47,13 @@ import spoon.support.reflect.eval.VisitorPartialEvaluator; import spoon.support.util.SignatureBasedSortedSet; -import java.io.File; -import java.net.MalformedURLException; -import java.net.URL; -import java.net.URLClassLoader; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.List; -import java.util.Set; - -import static spoon.reflect.path.CtRole.CONSTRUCTOR; import static spoon.reflect.path.CtRole.ANNONYMOUS_EXECUTABLE; +import static spoon.reflect.path.CtRole.CONSTRUCTOR; import static spoon.reflect.path.CtRole.SUPER_TYPE; + + + /** * The implementation for {@link spoon.reflect.declaration.CtClass}. * @@ -104,13 +107,13 @@ public Set> getConstructors() { } @Override - public > C addAnonymousExecutable(CtAnonymousExecutable e) { + public CtClassImpl addAnonymousExecutable(CtAnonymousExecutable e) { if (e == null) { - return (C) this; + return this; } e.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, ANNONYMOUS_EXECUTABLE, typeMembers, e); - return addTypeMember(e); + return ((CtClassImpl) (addTypeMember(e))); } @Override @@ -125,38 +128,38 @@ public CtTypeReference getSuperclass() { } @Override - public > C setAnonymousExecutables(List anonymousExecutables) { + public CtClassImpl setAnonymousExecutables(List anonymousExecutables) { getFactory().getEnvironment().getModelChangeListener().onListDelete(this, ANNONYMOUS_EXECUTABLE, typeMembers, new ArrayList<>(getAnonymousExecutables())); if (anonymousExecutables == null || anonymousExecutables.isEmpty()) { this.typeMembers.removeAll(getAnonymousExecutables()); - return (C) this; + return this; } typeMembers.removeAll(getAnonymousExecutables()); for (CtAnonymousExecutable exec : anonymousExecutables) { addAnonymousExecutable(exec); } - return (C) this; + return this; } @Override - public > C setConstructors(Set> constructors) { + public CtClassImpl setConstructors(Set> constructors) { Set> oldConstructor = getConstructors(); getFactory().getEnvironment().getModelChangeListener().onListDelete(this, CONSTRUCTOR, typeMembers, oldConstructor); if (constructors == null || constructors.isEmpty()) { this.typeMembers.removeAll(oldConstructor); - return (C) this; + return this; } typeMembers.removeAll(oldConstructor); for (CtConstructor constructor : constructors) { addConstructor(constructor); } - return (C) this; + return this; } @Override - public > C addConstructor(CtConstructor constructor) { + public CtClassImpl addConstructor(CtConstructor constructor) { getFactory().getEnvironment().getModelChangeListener().onListAdd(this, CONSTRUCTOR, typeMembers, constructor); - return addTypeMember(constructor); + return ((CtClassImpl) (addTypeMember(constructor))); } @Override @@ -165,13 +168,13 @@ public void removeConstructor(CtConstructor constructor) { } @Override - public > C setSuperclass(CtTypeReference superClass) { + public CtClassImpl setSuperclass(CtTypeReference superClass) { if (superClass != null) { superClass.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, SUPER_TYPE, superClass, this.superClass); this.superClass = superClass; - return (C) this; + return this; } @Override @@ -195,27 +198,27 @@ public boolean isSubtypeOf(CtTypeReference type) { } @Override - public C insertAfter(CtStatement statement) { + public CtClassImpl insertAfter(CtStatement statement) { CtStatementImpl.insertAfter(this, statement); - return (C) this; + return this; } @Override - public C insertAfter(CtStatementList statements) { + public CtClassImpl insertAfter(CtStatementList statements) { CtStatementImpl.insertAfter(this, statements); - return (C) this; + return this; } @Override - public C insertBefore(CtStatement statement) { + public CtClassImpl insertBefore(CtStatement statement) { CtStatementImpl.insertBefore(this, statement); - return (C) this; + return this; } @Override - public C insertBefore(CtStatementList statements) { + public CtClassImpl insertBefore(CtStatementList statements) { CtStatementImpl.insertBefore(this, statements); - return (C) this; + return this; } @Override @@ -225,8 +228,8 @@ public String getLabel() { @Override @UnsettableProperty - public C setLabel(String label) { - return (C) this; + public CtClassImpl setLabel(String label) { + return this; } @SuppressWarnings("unchecked") diff --git a/src/main/java/spoon/support/reflect/declaration/CtConstructorImpl.java b/src/main/java/spoon/support/reflect/declaration/CtConstructorImpl.java index 4bd0d42805a..4c75798cc09 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtConstructorImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtConstructorImpl.java @@ -16,15 +16,14 @@ */ package spoon.support.reflect.declaration; + +import java.util.ArrayList; +import java.util.List; +import java.util.Set; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.declaration.CtConstructor; -import spoon.reflect.declaration.CtFormalTypeDeclarer; -import spoon.reflect.declaration.CtModifiable; -import spoon.reflect.declaration.CtNamedElement; -import spoon.reflect.declaration.CtShadowable; import spoon.reflect.declaration.CtType; import spoon.reflect.declaration.CtTypeParameter; -import spoon.reflect.declaration.CtTypedElement; import spoon.reflect.declaration.ModifierKind; import spoon.reflect.path.CtRole; import spoon.reflect.reference.CtExecutableReference; @@ -35,12 +34,11 @@ import spoon.support.reflect.CtExtendedModifier; import spoon.support.reflect.CtModifierHandler; -import java.util.ArrayList; -import java.util.List; -import java.util.Set; - import static spoon.reflect.ModelElementContainerDefaultCapacities.TYPE_TYPE_PARAMETERS_CONTAINER_DEFAULT_CAPACITY; + + + public class CtConstructorImpl extends CtExecutableImpl implements CtConstructor { private static final long serialVersionUID = 1L; @@ -57,8 +55,8 @@ public void accept(CtVisitor visitor) { @Override @UnsettableProperty - public C setSimpleName(String simpleName) { - return (C) this; + public CtConstructorImpl setSimpleName(String simpleName) { + return this; } @Override @@ -83,9 +81,9 @@ public CtTypeReference getType() { @Override @UnsettableProperty - public C setType(CtTypeReference type) { + public CtConstructorImpl setType(CtTypeReference type) { // unsettable property - return (C) this; + return this; } @Override @@ -94,10 +92,10 @@ public List getFormalCtTypeParameters() { } @Override - public C setFormalCtTypeParameters(List formalTypeParameters) { + public CtConstructorImpl setFormalCtTypeParameters(List formalTypeParameters) { if (formalTypeParameters == null || formalTypeParameters.isEmpty()) { this.formalCtTypeParameters = CtElementImpl.emptyList(); - return (C) this; + return this; } if (this.formalCtTypeParameters == CtElementImpl.emptyList()) { this.formalCtTypeParameters = new ArrayList<>(TYPE_TYPE_PARAMETERS_CONTAINER_DEFAULT_CAPACITY); @@ -107,13 +105,13 @@ public C setFormalCtTypeParameters(List C addFormalCtTypeParameter(CtTypeParameter formalTypeParameter) { + public CtConstructorImpl addFormalCtTypeParameter(CtTypeParameter formalTypeParameter) { if (formalTypeParameter == null) { - return (C) this; + return this; } getFactory().getEnvironment().getModelChangeListener().onListAdd(this, CtRole.TYPE_PARAMETER, this.formalCtTypeParameters, formalTypeParameter); if (formalCtTypeParameters == CtElementImpl.emptyList()) { @@ -121,7 +119,7 @@ public C addFormalCtTypeParameter(CtTypeParamet } formalTypeParameter.setParent(this); formalCtTypeParameters.add(formalTypeParameter); - return (C) this; + return this; } @Override @@ -144,27 +142,27 @@ public boolean hasModifier(ModifierKind modifier) { } @Override - public C setModifiers(Set modifiers) { + public CtConstructorImpl setModifiers(Set modifiers) { modifierHandler.setModifiers(modifiers); - return (C) this; + return this; } @Override - public C addModifier(ModifierKind modifier) { + public CtConstructorImpl addModifier(ModifierKind modifier) { modifierHandler.addModifier(modifier); - return (C) this; + return this; } @Override - public C removeModifier(ModifierKind modifier) { + public CtConstructorImpl removeModifier(ModifierKind modifier) { modifierHandler.removeModifier(modifier); - return (C) this; + return this; } @Override - public C setVisibility(ModifierKind visibility) { + public CtConstructorImpl setVisibility(ModifierKind visibility) { modifierHandler.setVisibility(visibility); - return (C) this; + return this; } @Override @@ -178,9 +176,9 @@ public Set getExtendedModifiers() { } @Override - public T setExtendedModifiers(Set extendedModifiers) { + public CtConstructorImpl setExtendedModifiers(Set extendedModifiers) { this.modifierHandler.setExtendedModifiers(extendedModifiers); - return (T) this; + return this; } @@ -193,10 +191,10 @@ public boolean isShadow() { } @Override - public E setShadow(boolean isShadow) { + public CtConstructorImpl setShadow(boolean isShadow) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.IS_SHADOW, isShadow, this.isShadow); this.isShadow = isShadow; - return (E) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/declaration/CtElementImpl.java b/src/main/java/spoon/support/reflect/declaration/CtElementImpl.java index 9555bd8155f..6b04812d699 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtElementImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtElementImpl.java @@ -16,6 +16,17 @@ */ package spoon.support.reflect.declaration; + +import java.io.Serializable; +import java.lang.annotation.Annotation; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; import org.apache.log4j.Logger; import spoon.Launcher; import spoon.reflect.ModelElementContainerDefaultCapacities; @@ -64,16 +75,10 @@ import spoon.support.visitor.equals.EqualsVisitor; import spoon.support.visitor.replace.ReplacementVisitor; -import java.io.Serializable; -import java.lang.annotation.Annotation; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.Iterator; -import java.util.List; -import java.util.Map; -import java.util.Set; +import static spoon.reflect.code.CtComment.CommentType.JAVADOC; + + + /** * Contains the default implementation of most CtElement methods. @@ -213,17 +218,17 @@ public int hashCode() { } @Override - public E setAnnotations(List> annotations) { + public CtElementImpl setAnnotations(List> annotations) { if (annotations == null || annotations.isEmpty()) { this.annotations = emptyList(); - return (E) this; + return this; } getFactory().getEnvironment().getModelChangeListener().onListDeleteAll(this, CtRole.ANNOTATION, this.annotations, new ArrayList<>(this.annotations)); this.annotations.clear(); for (CtAnnotation annot : annotations) { addAnnotation(annot); } - return (E) this; + return this; } @Override @@ -233,9 +238,9 @@ public void delete() { } @Override - public E addAnnotation(CtAnnotation annotation) { + public CtElementImpl addAnnotation(CtAnnotation annotation) { if (annotation == null) { - return (E) this; + return this; } if (this.annotations == CtElementImpl.>emptyList()) { this.annotations = new ArrayList<>(ModelElementContainerDefaultCapacities.ANNOTATIONS_CONTAINER_DEFAULT_CAPACITY); @@ -243,7 +248,7 @@ public E addAnnotation(CtAnnotation annotation.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, CtRole.ANNOTATION, this.annotations, annotation); this.annotations.add(annotation); - return (E) this; + return this; } @Override @@ -256,36 +261,36 @@ public boolean removeAnnotation(CtAnnotation annotation) { } @Override - public E setDocComment(String docComment) { + public CtElementImpl setDocComment(String docComment) { for (CtComment ctComment : comments) { if (ctComment.getCommentType() == CtComment.CommentType.JAVADOC) { ctComment.setContent(docComment); - return (E) this; + return this; } } this.addComment(factory.Code().createComment(docComment, CtComment.CommentType.JAVADOC)); - return (E) this; + return this; } @Override - public E setPosition(SourcePosition position) { + public CtElementImpl setPosition(SourcePosition position) { if (position == null) { position = SourcePosition.NOPOSITION; } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.POSITION, position, this.position); this.position = position; - return (E) this; + return this; } @Override - public E setPositions(final SourcePosition position) { + public CtElementImpl setPositions(final SourcePosition position) { accept(new CtScanner() { @Override public void enter(CtElement e) { e.setPosition(position); } }); - return (E) this; + return this; } @Override @@ -323,10 +328,10 @@ public boolean isImplicit() { } @Override - public E setImplicit(boolean implicit) { + public CtElementImpl setImplicit(boolean implicit) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.IS_IMPLICIT, implicit, this.implicit); this.implicit = implicit; - return (E) this; + return this; } @Override @@ -480,10 +485,10 @@ public void replace(Collection elements) { } @Override - public E setAllMetadata(Map metadata) { + public CtElementImpl setAllMetadata(Map metadata) { if (metadata == null || metadata.isEmpty()) { this.metadata = null; - return (E) this; + return this; } if (this.metadata == null) { this.metadata = new HashMap<>(); @@ -491,16 +496,16 @@ public E setAllMetadata(Map metadata) { this.metadata.clear(); } this.metadata.putAll(metadata); - return (E) this; + return this; } @Override - public E putMetadata(String key, Object val) { + public CtElementImpl putMetadata(String key, Object val) { if (metadata == null) { metadata = new HashMap<>(); } metadata.put(key, val); - return (E) this; + return this; } @Override @@ -533,9 +538,9 @@ public List getComments() { } @Override - public E addComment(CtComment comment) { + public CtElementImpl addComment(CtComment comment) { if (comment == null) { - return (E) this; + return this; } if (this.comments == CtElementImpl.emptyList()) { comments = new ArrayList<>(ModelElementContainerDefaultCapacities.COMMENT_CONTAINER_DEFAULT_CAPACITY); @@ -543,31 +548,31 @@ public E addComment(CtComment comment) { comment.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, CtRole.COMMENT, this.comments, comment); comments.add(comment); - return (E) this; + return this; } @Override - public E removeComment(CtComment comment) { + public CtElementImpl removeComment(CtComment comment) { if (this.comments == CtElementImpl.emptyList()) { - return (E) this; + return this; } getFactory().getEnvironment().getModelChangeListener().onListDelete(this, CtRole.COMMENT, comments, comments.indexOf(comment), comment); this.comments.remove(comment); - return (E) this; + return this; } @Override - public E setComments(List comments) { + public CtElementImpl setComments(List comments) { if (comments == null || comments.isEmpty()) { this.comments = emptyList(); - return (E) this; + return this; } getFactory().getEnvironment().getModelChangeListener().onListDeleteAll(this, CtRole.COMMENT, this.comments, new ArrayList<>(this.comments)); this.comments.clear(); for (CtComment comment : comments) { addComment(comment); } - return (E) this; + return this; } @Override @@ -582,10 +587,10 @@ public T getValueByRole(CtRole role) { } @Override - public E setValueByRole(CtRole role, T value) { + public < T> CtElementImpl setValueByRole(CtRole role, T value) { RoleHandler rh = RoleHandlerHelper.getRoleHandler(this.getClass(), role); rh.setValue(this, value); - return (E) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/declaration/CtEnumImpl.java b/src/main/java/spoon/support/reflect/declaration/CtEnumImpl.java index 5e82a9d70b0..6da7d1b25c3 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtEnumImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtEnumImpl.java @@ -16,28 +16,30 @@ */ package spoon.support.reflect.declaration; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Set; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.declaration.CtEnum; import spoon.reflect.declaration.CtEnumValue; import spoon.reflect.declaration.CtField; -import spoon.reflect.declaration.CtFormalTypeDeclarer; import spoon.reflect.declaration.CtMethod; -import spoon.reflect.declaration.CtType; import spoon.reflect.declaration.CtTypeParameter; import spoon.reflect.declaration.ModifierKind; +import spoon.reflect.factory.TypeFactory; import spoon.reflect.reference.CtTypeReference; import spoon.reflect.visitor.CtVisitor; import spoon.support.DerivedProperty; import spoon.support.UnsettableProperty; import spoon.support.util.SignatureBasedSortedSet; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.Set; - import static spoon.reflect.path.CtRole.VALUE; + + + public class CtEnumImpl> extends CtClassImpl implements CtEnum { private static final long serialVersionUID = 1L; @@ -70,9 +72,9 @@ public boolean isSubtypeOf(CtTypeReference type) { } @Override - public > C addEnumValue(CtEnumValue enumValue) { + public CtEnumImpl addEnumValue(CtEnumValue enumValue) { if (enumValue == null) { - return (C) this; + return this; } if (enumValues == CtElementImpl.>emptyList()) { enumValues = new ArrayList<>(); @@ -84,7 +86,7 @@ public > C addEnumValue(CtEnumValue enumValue) { } // enum value already exists. - return (C) this; + return this; } @Override @@ -112,21 +114,21 @@ public List> getEnumValues() { } @Override - public > C setEnumValues(List> enumValues) { + public CtEnumImpl setEnumValues(List> enumValues) { if (enumValues == null) { this.enumValues = emptyList(); - return (C) this; + return this; } getFactory().getEnvironment().getModelChangeListener().onListDeleteAll(this, VALUE, this.enumValues, new ArrayList<>(enumValues)); if (enumValues.isEmpty()) { this.enumValues = emptyList(); - return (C) this; + return this; } this.enumValues.clear(); for (CtEnumValue enumValue : enumValues) { addEnumValue(enumValue); } - return (C) this; + return this; } @Override @@ -160,8 +162,8 @@ public CtTypeReference getSuperclass() { @Override @UnsettableProperty - public > C setSuperclass(CtTypeReference superClass) { - return (C) this; + public CtEnumImpl setSuperclass(CtTypeReference superClass) { + return this; } private CtMethod valuesMethod() { @@ -238,7 +240,7 @@ public List getFormalCtTypeParameters() { @Override @UnsettableProperty - public C setFormalCtTypeParameters(List formalTypeParameters) { - return (C) this; + public CtEnumImpl setFormalCtTypeParameters(List formalTypeParameters) { + return this; } } diff --git a/src/main/java/spoon/support/reflect/declaration/CtEnumValueImpl.java b/src/main/java/spoon/support/reflect/declaration/CtEnumValueImpl.java index 88cb8f840c2..5ffccc5e05a 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtEnumValueImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtEnumValueImpl.java @@ -16,11 +16,15 @@ */ package spoon.support.reflect.declaration; + import spoon.reflect.code.CtExpression; import spoon.reflect.declaration.CtEnumValue; import spoon.reflect.visitor.CtVisitor; import spoon.support.DerivedProperty; + + + public class CtEnumValueImpl extends CtFieldImpl implements CtEnumValue { @Override public void accept(CtVisitor v) { diff --git a/src/main/java/spoon/support/reflect/declaration/CtExecutableImpl.java b/src/main/java/spoon/support/reflect/declaration/CtExecutableImpl.java index 8919a213866..58ff79d83a3 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtExecutableImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtExecutableImpl.java @@ -16,9 +16,13 @@ */ package spoon.support.reflect.declaration; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtBlock; -import spoon.reflect.code.CtBodyHolder; import spoon.reflect.code.CtStatement; import spoon.reflect.declaration.CtExecutable; import spoon.reflect.declaration.CtParameter; @@ -28,17 +32,15 @@ import spoon.support.util.QualifiedNameBasedSortedSet; import spoon.support.visitor.SignaturePrinter; -import java.util.ArrayList; -import java.util.HashSet; -import java.util.List; -import java.util.Set; - import static spoon.reflect.ModelElementContainerDefaultCapacities.PARAMETERS_CONTAINER_DEFAULT_CAPACITY; import static spoon.reflect.path.CtRole.BODY; import static spoon.reflect.path.CtRole.PARAMETER; import static spoon.reflect.path.CtRole.THROWN; + + + /** * The implementation for {@link spoon.reflect.declaration.CtExecutable}. * @@ -74,7 +76,7 @@ public CtBlock getBody() { } @Override - public T setBody(CtStatement statement) { + public CtExecutableImpl setBody(CtStatement statement) { if (statement != null) { CtBlock body = getFactory().Code().getOrCreateCtBlock(statement); getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, BODY, body, this.body); @@ -86,7 +88,7 @@ public T setBody(CtStatement statement) { getFactory().getEnvironment().getModelChangeListener().onObjectDelete(this, BODY, this.body); this.body = null; } - return (T) this; + return this; } @Override @@ -95,10 +97,10 @@ public List> getParameters() { } @Override - public > T setParameters(List> parameters) { + public CtExecutableImpl setParameters(List> parameters) { if (parameters == null || parameters.isEmpty()) { this.parameters = CtElementImpl.emptyList(); - return (T) this; + return this; } if (this.parameters == CtElementImpl.>emptyList()) { this.parameters = new ArrayList<>(PARAMETERS_CONTAINER_DEFAULT_CAPACITY); @@ -108,13 +110,13 @@ public > T setParameters(List> paramete for (CtParameter p : parameters) { addParameter(p); } - return (T) this; + return this; } @Override - public > T addParameter(CtParameter parameter) { + public CtExecutableImpl addParameter(CtParameter parameter) { if (parameter == null) { - return (T) this; + return this; } if (parameters == CtElementImpl.>emptyList()) { parameters = new ArrayList<>(PARAMETERS_CONTAINER_DEFAULT_CAPACITY); @@ -122,7 +124,7 @@ public > T addParameter(CtParameter parameter) { parameter.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, PARAMETER, this.parameters, parameter); parameters.add(parameter); - return (T) this; + return this; } @Override @@ -140,10 +142,10 @@ public Set> getThrownTypes() { } @Override - public > T setThrownTypes(Set> thrownTypes) { + public CtExecutableImpl setThrownTypes(Set> thrownTypes) { if (thrownTypes == null || thrownTypes.isEmpty()) { this.thrownTypes = CtElementImpl.emptySet(); - return (T) this; + return this; } if (this.thrownTypes == CtElementImpl.>emptySet()) { this.thrownTypes = new QualifiedNameBasedSortedSet<>(); @@ -153,13 +155,13 @@ public > T setThrownTypes(Set thrownType : thrownTypes) { addThrownType(thrownType); } - return (T) this; + return this; } @Override - public > T addThrownType(CtTypeReference throwType) { + public CtExecutableImpl addThrownType(CtTypeReference throwType) { if (throwType == null) { - return (T) this; + return this; } if (thrownTypes == CtElementImpl.>emptySet()) { thrownTypes = new QualifiedNameBasedSortedSet<>(); @@ -167,7 +169,7 @@ public > T addThrownType(CtTypeReference getType() { } @Override - public > C setDefaultExpression(CtExpression defaultExpression) { + public CtFieldImpl setDefaultExpression(CtExpression defaultExpression) { if (defaultExpression != null) { defaultExpression.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.DEFAULT_EXPRESSION, defaultExpression, this.defaultExpression); this.defaultExpression = defaultExpression; - return (C) this; + return this; } @Override - public C setType(CtTypeReference type) { + public CtFieldImpl setType(CtTypeReference type) { if (type != null) { type.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.TYPE, type, this.type); this.type = type; - return (C) this; + return this; } @Override @@ -117,21 +115,21 @@ public boolean hasModifier(ModifierKind modifier) { } @Override - public C setModifiers(Set modifiers) { + public CtFieldImpl setModifiers(Set modifiers) { modifierHandler.setModifiers(modifiers); - return (C) this; + return this; } @Override - public C addModifier(ModifierKind modifier) { + public CtFieldImpl addModifier(ModifierKind modifier) { modifierHandler.addModifier(modifier); - return (C) this; + return this; } @Override - public C removeModifier(ModifierKind modifier) { + public CtFieldImpl removeModifier(ModifierKind modifier) { modifierHandler.removeModifier(modifier); - return (C) this; + return this; } @Override @@ -140,16 +138,16 @@ public Set getExtendedModifiers() { } @Override - public C setExtendedModifiers(Set extendedModifiers) { + public CtFieldImpl setExtendedModifiers(Set extendedModifiers) { this.modifierHandler.setExtendedModifiers(extendedModifiers); - return (C) this; + return this; } @Override - public C setVisibility(ModifierKind visibility) { + public CtFieldImpl setVisibility(ModifierKind visibility) { modifierHandler.setVisibility(visibility); - return (C) this; + return this; } @Override @@ -164,9 +162,9 @@ public CtExpression getAssignment() { } @Override - public > C setAssignment(CtExpression assignment) { + public CtFieldImpl setAssignment(CtExpression assignment) { setDefaultExpression(assignment); - return (C) this; + return this; } @MetamodelPropertyField(role = CtRole.IS_SHADOW) @@ -178,10 +176,10 @@ public boolean isShadow() { } @Override - public E setShadow(boolean isShadow) { + public CtFieldImpl setShadow(boolean isShadow) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.IS_SHADOW, isShadow, this.isShadow); this.isShadow = isShadow; - return (E) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/declaration/CtImportImpl.java b/src/main/java/spoon/support/reflect/declaration/CtImportImpl.java index 7f7c2d0d1c1..6e553d5b0d2 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtImportImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtImportImpl.java @@ -16,19 +16,23 @@ */ package spoon.support.reflect.declaration; + import spoon.SpoonException; import spoon.reflect.annotations.MetamodelPropertyField; +import spoon.reflect.declaration.CtImport; +import spoon.reflect.declaration.CtImportKind; import spoon.reflect.path.CtRole; import spoon.reflect.reference.CtExecutableReference; import spoon.reflect.reference.CtFieldReference; -import spoon.reflect.declaration.CtImport; import spoon.reflect.reference.CtPackageReference; import spoon.reflect.reference.CtReference; -import spoon.reflect.declaration.CtImportKind; import spoon.reflect.reference.CtTypeReference; import spoon.reflect.visitor.CtVisitor; import spoon.support.reflect.reference.CtWildcardStaticTypeMemberReferenceImpl; + + + public class CtImportImpl extends CtElementImpl implements CtImport { @MetamodelPropertyField(role = CtRole.IMPORT_REFERENCE) private CtReference localReference; @@ -58,13 +62,13 @@ public CtImportKind getImportKind() { } @Override - public T setReference(CtReference reference) { + public CtImportImpl setReference(CtReference reference) { if (reference != null) { reference.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.IMPORT_REFERENCE, reference, this.localReference); this.localReference = reference; - return (T) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/declaration/CtInterfaceImpl.java b/src/main/java/spoon/support/reflect/declaration/CtInterfaceImpl.java index 62fd23ef891..712ff204c0f 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtInterfaceImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtInterfaceImpl.java @@ -16,18 +16,20 @@ */ package spoon.support.reflect.declaration; -import spoon.reflect.declaration.CtInterface; -import spoon.reflect.declaration.CtType; -import spoon.reflect.reference.CtExecutableReference; -import spoon.reflect.reference.CtTypeReference; -import spoon.reflect.visitor.CtVisitor; -import spoon.support.UnsettableProperty; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.List; import java.util.Set; +import spoon.reflect.declaration.CtInterface; +import spoon.reflect.reference.CtExecutableReference; +import spoon.reflect.reference.CtTypeReference; +import spoon.reflect.visitor.CtVisitor; +import spoon.support.UnsettableProperty; + + + public class CtInterfaceImpl extends CtTypeImpl implements CtInterface { private static final long serialVersionUID = 1L; @@ -67,8 +69,8 @@ public CtInterface clone() { @Override @UnsettableProperty - public > C setSuperclass(CtTypeReference superClass) { + public CtInterfaceImpl setSuperclass(CtTypeReference superClass) { // unsettable property - return (C) this; + return this; } } diff --git a/src/main/java/spoon/support/reflect/declaration/CtMethodImpl.java b/src/main/java/spoon/support/reflect/declaration/CtMethodImpl.java index 9cfc1f23fcc..bcbd06b9638 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtMethodImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtMethodImpl.java @@ -16,28 +16,28 @@ */ package spoon.support.reflect.declaration; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Set; import spoon.refactoring.Refactoring; import spoon.reflect.ModelElementContainerDefaultCapacities; import spoon.reflect.annotations.MetamodelPropertyField; -import spoon.reflect.declaration.CtFormalTypeDeclarer; import spoon.reflect.declaration.CtMethod; -import spoon.reflect.declaration.CtModifiable; -import spoon.reflect.declaration.CtShadowable; import spoon.reflect.declaration.CtTypeParameter; -import spoon.reflect.declaration.CtTypedElement; import spoon.reflect.declaration.ModifierKind; import spoon.reflect.path.CtRole; import spoon.reflect.reference.CtTypeReference; import spoon.reflect.visitor.CtVisitor; +import spoon.reflect.visitor.chain.CtConsumer; import spoon.reflect.visitor.filter.AllTypeMembersFunction; import spoon.support.reflect.CtExtendedModifier; import spoon.support.reflect.CtModifierHandler; import spoon.support.visitor.ClassTypingContext; -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; -import java.util.Set; + + /** * The implementation for {@link spoon.reflect.declaration.CtMethod}. @@ -73,13 +73,13 @@ public CtTypeReference getType() { } @Override - public C setType(CtTypeReference type) { + public CtMethodImpl setType(CtTypeReference type) { if (type != null) { type.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.TYPE, type, this.returnType); this.returnType = type; - return (C) this; + return this; } @Override @@ -88,10 +88,10 @@ public boolean isDefaultMethod() { } @Override - public > C setDefaultMethod(boolean defaultMethod) { + public CtMethodImpl setDefaultMethod(boolean defaultMethod) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.IS_DEFAULT, defaultMethod, this.defaultMethod); this.defaultMethod = defaultMethod; - return (C) this; + return this; } @Override @@ -100,11 +100,11 @@ public List getFormalCtTypeParameters() { } @Override - public C setFormalCtTypeParameters(List formalTypeParameters) { + public CtMethodImpl setFormalCtTypeParameters(List formalTypeParameters) { getFactory().getEnvironment().getModelChangeListener().onListDeleteAll(this, CtRole.TYPE_PARAMETER, this.formalCtTypeParameters, new ArrayList<>(this.formalCtTypeParameters)); if (formalTypeParameters == null || formalTypeParameters.isEmpty()) { this.formalCtTypeParameters = CtElementImpl.emptyList(); - return (C) this; + return this; } if (this.formalCtTypeParameters == CtElementImpl.emptyList()) { this.formalCtTypeParameters = new ArrayList<>(ModelElementContainerDefaultCapacities.TYPE_TYPE_PARAMETERS_CONTAINER_DEFAULT_CAPACITY); @@ -113,13 +113,13 @@ public C setFormalCtTypeParameters(List C addFormalCtTypeParameter(CtTypeParameter formalTypeParameter) { + public CtMethodImpl addFormalCtTypeParameter(CtTypeParameter formalTypeParameter) { if (formalTypeParameter == null) { - return (C) this; + return this; } if (formalCtTypeParameters == CtElementImpl.emptyList()) { formalCtTypeParameters = new ArrayList<>(ModelElementContainerDefaultCapacities.TYPE_TYPE_PARAMETERS_CONTAINER_DEFAULT_CAPACITY); @@ -127,7 +127,7 @@ public C addFormalCtTypeParameter(CtTypeParamet getFactory().getEnvironment().getModelChangeListener().onListAdd(this, CtRole.TYPE_PARAMETER, this.formalCtTypeParameters, formalTypeParameter); formalTypeParameter.setParent(this); formalCtTypeParameters.add(formalTypeParameter); - return (C) this; + return this; } @Override @@ -150,27 +150,27 @@ public boolean hasModifier(ModifierKind modifier) { } @Override - public C setModifiers(Set modifiers) { + public CtMethodImpl setModifiers(Set modifiers) { modifierHandler.setModifiers(modifiers); - return (C) this; + return this; } @Override - public C addModifier(ModifierKind modifier) { + public CtMethodImpl addModifier(ModifierKind modifier) { modifierHandler.addModifier(modifier); - return (C) this; + return this; } @Override - public C removeModifier(ModifierKind modifier) { + public CtMethodImpl removeModifier(ModifierKind modifier) { modifierHandler.removeModifier(modifier); - return (C) this; + return this; } @Override - public C setVisibility(ModifierKind visibility) { + public CtMethodImpl setVisibility(ModifierKind visibility) { modifierHandler.setVisibility(visibility); - return (C) this; + return this; } @Override @@ -184,9 +184,9 @@ public Set getExtendedModifiers() { } @Override - public C setExtendedModifiers(Set extendedModifiers) { + public CtMethodImpl setExtendedModifiers(Set extendedModifiers) { this.modifierHandler.setExtendedModifiers(extendedModifiers); - return (C) this; + return this; } @Override @@ -203,10 +203,10 @@ public boolean isShadow() { } @Override - public E setShadow(boolean isShadow) { + public CtMethodImpl setShadow(boolean isShadow) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.IS_SHADOW, isShadow, this.isShadow); this.isShadow = isShadow; - return (E) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/declaration/CtModuleImpl.java b/src/main/java/spoon/support/reflect/declaration/CtModuleImpl.java index d5c5625fe45..063296d0d7e 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtModuleImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtModuleImpl.java @@ -16,14 +16,18 @@ */ package spoon.support.reflect.declaration; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.declaration.CtElement; import spoon.reflect.declaration.CtModule; import spoon.reflect.declaration.CtModuleDirective; +import spoon.reflect.declaration.CtModuleRequirement; import spoon.reflect.declaration.CtPackage; import spoon.reflect.declaration.CtPackageExport; import spoon.reflect.declaration.CtProvidedService; -import spoon.reflect.declaration.CtModuleRequirement; import spoon.reflect.declaration.CtUsedService; import spoon.reflect.path.CtRole; import spoon.reflect.reference.CtModuleReference; @@ -32,9 +36,8 @@ import spoon.support.comparator.CtLineElementComparator; import spoon.support.util.SortedList; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; + + public class CtModuleImpl extends CtNamedElementImpl implements CtModule { @MetamodelPropertyField(role = CtRole.MODIFIER) @@ -60,11 +63,11 @@ public boolean isOpenModule() { } @Override - public T setModuleDirectives(List moduleDirectives) { + public CtModuleImpl setModuleDirectives(List moduleDirectives) { getFactory().getEnvironment().getModelChangeListener().onListDeleteAll(this, CtRole.MODULE_DIRECTIVE, this.moduleDirectives, new ArrayList<>(this.moduleDirectives)); if (moduleDirectives == null || moduleDirectives.isEmpty()) { this.moduleDirectives = CtElementImpl.emptyList(); - return (T) this; + return this; } if (this.moduleDirectives == CtElementImpl.emptyList()) { this.moduleDirectives = new SortedList<>(new CtLineElementComparator()); @@ -75,13 +78,13 @@ public T setModuleDirectives(List module this.addModuleDirective(moduleDirective); } - return (T) this; + return this; } @Override - public T addModuleDirective(CtModuleDirective moduleDirective) { + public CtModuleImpl addModuleDirective(CtModuleDirective moduleDirective) { if (moduleDirective == null) { - return (T) this; + return this; } if (this.moduleDirectives == CtElementImpl.emptyList()) { @@ -95,13 +98,13 @@ public T addModuleDirective(CtModuleDirective moduleDirecti this.moduleDirectives.add(moduleDirective); } - return (T) this; + return this; } @Override - public T addModuleDirectiveAt(int position, CtModuleDirective moduleDirective) { + public CtModuleImpl addModuleDirectiveAt(int position, CtModuleDirective moduleDirective) { if (moduleDirective == null) { - return (T) this; + return this; } if (this.moduleDirectives == CtElementImpl.emptyList()) { @@ -115,7 +118,7 @@ public T addModuleDirectiveAt(int position, CtModuleDirecti this.moduleDirectives.add(position, moduleDirective); } - return (T) this; + return this; } @Override @@ -124,9 +127,9 @@ public List getModuleDirectives() { } @Override - public T removeModuleDirective(CtModuleDirective moduleDirective) { + public CtModuleImpl removeModuleDirective(CtModuleDirective moduleDirective) { if (moduleDirective == null || this.moduleDirectives.isEmpty()) { - return (T) this; + return this; } if (this.moduleDirectives.contains(moduleDirective)) { getFactory().getEnvironment().getModelChangeListener().onListDelete(this, CtRole.MODULE_DIRECTIVE.getMatchingSubRoleFor(moduleDirective), this.moduleDirectives, this.moduleDirectives.indexOf(moduleDirective), moduleDirective); @@ -137,14 +140,14 @@ public T removeModuleDirective(CtModuleDirective moduleDire } } - return (T) this; + return this; } @Override - public T setIsOpenModule(boolean openModule) { + public CtModuleImpl setIsOpenModule(boolean openModule) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.MODIFIER, openModule, this.openModule); this.openModule = openModule; - return (T) this; + return this; } @Override @@ -163,9 +166,9 @@ public List getUsedServices() { } @Override - public T setUsedServices(List consumedServices) { + public CtModuleImpl setUsedServices(List consumedServices) { if (consumedServices == null || consumedServices.isEmpty()) { - return (T) this; + return this; } List usedServices = getUsedServices(); getFactory().getEnvironment().getModelChangeListener().onListDelete(this, CtRole.SERVICE_TYPE, this.moduleDirectives, new ArrayList<>(usedServices)); @@ -174,25 +177,25 @@ public T setUsedServices(List consumedServic for (CtUsedService consumedService : consumedServices) { this.addModuleDirective(consumedService); } - return (T) this; + return this; } @Override - public T addUsedService(CtUsedService consumedService) { + public CtModuleImpl addUsedService(CtUsedService consumedService) { if (consumedService == null) { - return (T) this; + return this; } this.addModuleDirective(consumedService); - return (T) this; + return this; } @Override - public T removeUsedService(CtUsedService usedService) { + public CtModuleImpl removeUsedService(CtUsedService usedService) { if (usedService == null) { - return (T) this; + return this; } - return this.removeModuleDirective(usedService); + return ((CtModuleImpl) (this.removeModuleDirective(usedService))); } @Override @@ -214,9 +217,9 @@ public List getExportedPackages() { } @Override - public T setExportedPackages(List exportedPackages) { + public CtModuleImpl setExportedPackages(List exportedPackages) { if (exportedPackages == null || exportedPackages.isEmpty()) { - return (T) this; + return this; } List oldExportedPackages = getExportedPackages(); @@ -228,25 +231,25 @@ public T setExportedPackages(List exported this.addModuleDirective(exportedPackage); } - return (T) this; + return this; } @Override - public T addExportedPackage(CtPackageExport exportedPackage) { + public CtModuleImpl addExportedPackage(CtPackageExport exportedPackage) { if (exportedPackage == null) { - return (T) this; + return this; } exportedPackage.setOpenedPackage(false); this.addModuleDirective(exportedPackage); - return (T) this; + return this; } @Override - public T removeExportedPackage(CtPackageExport exportedPackage) { + public CtModuleImpl removeExportedPackage(CtPackageExport exportedPackage) { if (exportedPackage == null) { - return (T) this; + return this; } - return this.removeModuleDirective(exportedPackage); + return ((CtModuleImpl) (this.removeModuleDirective(exportedPackage))); } @Override @@ -268,9 +271,9 @@ public List getOpenedPackages() { } @Override - public T setOpenedPackages(List openedPackages) { + public CtModuleImpl setOpenedPackages(List openedPackages) { if (openedPackages == null || openedPackages.isEmpty()) { - return (T) this; + return this; } List oldOpenedPackages = getOpenedPackages(); @@ -282,25 +285,25 @@ public T setOpenedPackages(List openedPack this.addModuleDirective(exportedPackage); } - return (T) this; + return this; } @Override - public T addOpenedPackage(CtPackageExport openedPackage) { + public CtModuleImpl addOpenedPackage(CtPackageExport openedPackage) { if (openedPackage == null) { - return (T) this; + return this; } openedPackage.setOpenedPackage(true); this.addModuleDirective(openedPackage); - return (T) this; + return this; } @Override - public T removeOpenedPackage(CtPackageExport openedPackage) { + public CtModuleImpl removeOpenedPackage(CtPackageExport openedPackage) { if (openedPackage == null) { - return (T) this; + return this; } - return this.removeModuleDirective(openedPackage); + return ((CtModuleImpl) (this.removeModuleDirective(openedPackage))); } @Override @@ -319,9 +322,9 @@ public List getRequiredModules() { } @Override - public T setRequiredModules(List requiredModules) { + public CtModuleImpl setRequiredModules(List requiredModules) { if (requiredModules == null || requiredModules.isEmpty()) { - return (T) this; + return this; } List oldRequiredModules = getRequiredModules(); @@ -331,25 +334,25 @@ public T setRequiredModules(List requi for (CtModuleRequirement moduleRequirement : requiredModules) { this.addModuleDirective(moduleRequirement); } - return (T) this; + return this; } @Override - public T addRequiredModule(CtModuleRequirement requiredModule) { + public CtModuleImpl addRequiredModule(CtModuleRequirement requiredModule) { if (requiredModule == null) { - return (T) this; + return this; } this.addModuleDirective(requiredModule); - return (T) this; + return this; } @Override - public T removeRequiredModule(CtModuleRequirement requiredModule) { + public CtModuleImpl removeRequiredModule(CtModuleRequirement requiredModule) { if (requiredModule == null) { - return (T) this; + return this; } - return this.removeModuleDirective(requiredModule); + return ((CtModuleImpl) (this.removeModuleDirective(requiredModule))); } @Override @@ -368,9 +371,9 @@ public List getProvidedServices() { } @Override - public T setProvidedServices(List providedServices) { + public CtModuleImpl setProvidedServices(List providedServices) { if (providedServices == null || providedServices.isEmpty()) { - return (T) this; + return this; } List oldProvidedServices = getProvidedServices(); @@ -381,25 +384,25 @@ public T setProvidedServices(List provid this.addModuleDirective(providedService); } - return (T) this; + return this; } @Override - public T addProvidedService(CtProvidedService providedService) { + public CtModuleImpl addProvidedService(CtProvidedService providedService) { if (providedService == null) { - return (T) this; + return this; } this.addModuleDirective(providedService); - return (T) this; + return this; } @Override - public T removeProvidedService(CtProvidedService providedService) { + public CtModuleImpl removeProvidedService(CtProvidedService providedService) { if (providedService == null) { - return (T) this; + return this; } - return this.removeModuleDirective(providedService); + return ((CtModuleImpl) (this.removeModuleDirective(providedService))); } @Override @@ -408,13 +411,13 @@ public CtPackage getRootPackage() { } @Override - public T setRootPackage(CtPackage rootPackage) { + public CtModuleImpl setRootPackage(CtPackage rootPackage) { if (rootPackage != null) { rootPackage.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.SUB_PACKAGE, rootPackage, this.rootPackage); this.rootPackage = rootPackage; - return (T) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/declaration/CtModuleRequirementImpl.java b/src/main/java/spoon/support/reflect/declaration/CtModuleRequirementImpl.java index 0909fff5fe5..249b5e6020f 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtModuleRequirementImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtModuleRequirementImpl.java @@ -16,14 +16,17 @@ */ package spoon.support.reflect.declaration; + +import java.util.HashSet; +import java.util.Set; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.declaration.CtModuleRequirement; import spoon.reflect.path.CtRole; import spoon.reflect.reference.CtModuleReference; import spoon.reflect.visitor.CtVisitor; -import java.util.HashSet; -import java.util.Set; + + public class CtModuleRequirementImpl extends CtElementImpl implements CtModuleRequirement { @MetamodelPropertyField(role = CtRole.MODIFIER) @@ -41,11 +44,11 @@ public Set getRequiresModifiers() { } @Override - public T setRequiresModifiers(Set requiresModifiers) { + public CtModuleRequirementImpl setRequiresModifiers(Set requiresModifiers) { getFactory().getEnvironment().getModelChangeListener().onSetDeleteAll(this, CtRole.MODIFIER, this.requiresModifiers, new HashSet<>(requiresModifiers)); if (requiresModifiers == null || requiresModifiers.isEmpty()) { this.requiresModifiers = CtElementImpl.emptySet(); - return (T) this; + return this; } if (this.requiresModifiers == CtElementImpl.emptySet()) { @@ -57,7 +60,7 @@ public T setRequiresModifiers(Set T setModuleReference(CtModuleReference moduleReference) { + public CtModuleRequirementImpl setModuleReference(CtModuleReference moduleReference) { if (moduleReference != null) { moduleReference.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.MODULE_REF, moduleReference, this.moduleReference); this.moduleReference = moduleReference; - return (T) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/declaration/CtNamedElementImpl.java b/src/main/java/spoon/support/reflect/declaration/CtNamedElementImpl.java index 4347b772cb9..1bc876e4a9c 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtNamedElementImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtNamedElementImpl.java @@ -16,6 +16,7 @@ */ package spoon.support.reflect.declaration; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.declaration.CtNamedElement; import spoon.reflect.factory.Factory; @@ -24,6 +25,9 @@ import static spoon.reflect.path.CtRole.NAME; + + + public abstract class CtNamedElementImpl extends CtElementImpl implements CtNamedElement { private static final long serialVersionUID = 1L; @@ -42,18 +46,18 @@ public String getSimpleName() { } @Override - public T setSimpleName(String simpleName) { + public CtNamedElementImpl setSimpleName(String simpleName) { Factory factory = getFactory(); if (factory == null) { this.simpleName = simpleName; - return (T) this; + return this; } if (factory instanceof FactoryImpl) { simpleName = ((FactoryImpl) factory).dedup(simpleName); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, NAME, simpleName, this.simpleName); this.simpleName = simpleName; - return (T) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/declaration/CtPackageExportImpl.java b/src/main/java/spoon/support/reflect/declaration/CtPackageExportImpl.java index aeca49b7d10..9521da78f9c 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtPackageExportImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtPackageExportImpl.java @@ -16,6 +16,10 @@ */ package spoon.support.reflect.declaration; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.declaration.CtPackageExport; import spoon.reflect.path.CtRole; @@ -23,9 +27,8 @@ import spoon.reflect.reference.CtPackageReference; import spoon.reflect.visitor.CtVisitor; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; + + public class CtPackageExportImpl extends CtElementImpl implements CtPackageExport { @MetamodelPropertyField(role = CtRole.PACKAGE_REF) @@ -41,10 +44,10 @@ public CtPackageExportImpl() { } @Override - public T setOpenedPackage(boolean openedPackage) { + public CtPackageExportImpl setOpenedPackage(boolean openedPackage) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.OPENED_PACKAGE, openedPackage, this.isOpen); this.isOpen = openedPackage; - return (T) this; + return this; } @Override @@ -58,13 +61,13 @@ public CtPackageReference getPackageReference() { } @Override - public T setPackageReference(CtPackageReference packageReference) { + public CtPackageExportImpl setPackageReference(CtPackageReference packageReference) { if (packageReference != null) { packageReference.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.PACKAGE_REF, packageReference, this.packageReference); this.packageReference = packageReference; - return (T) this; + return this; } @Override @@ -73,11 +76,11 @@ public List getTargetExport() { } @Override - public T setTargetExport(List targetExports) { + public CtPackageExportImpl setTargetExport(List targetExports) { getFactory().getEnvironment().getModelChangeListener().onListDeleteAll(this, CtRole.MODULE_REF, this.targets, new ArrayList<>(this.targets)); if (targetExports == null || targetExports.isEmpty()) { this.targets = CtElementImpl.emptyList(); - return (T) this; + return this; } if (this.targets == CtElementImpl.emptyList()) { @@ -88,13 +91,13 @@ public T setTargetExport(List tar this.addTargetExport(targetExport); } - return (T) this; + return this; } @Override - public T addTargetExport(CtModuleReference targetExport) { + public CtPackageExportImpl addTargetExport(CtModuleReference targetExport) { if (targetExport == null) { - return (T) this; + return this; } if (this.targets == CtElementImpl.emptyList()) { this.targets = new ArrayList<>(); @@ -102,7 +105,7 @@ public T addTargetExport(CtModuleReference targetExp getFactory().getEnvironment().getModelChangeListener().onListAdd(this, CtRole.MODULE_REF, this.targets, targetExport); targetExport.setParent(this); this.targets.add(targetExport); - return (T) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/declaration/CtPackageImpl.java b/src/main/java/spoon/support/reflect/declaration/CtPackageImpl.java index 5c328ce848c..ca7070c0199 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtPackageImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtPackageImpl.java @@ -16,11 +16,13 @@ */ package spoon.support.reflect.declaration; + +import java.util.Comparator; +import java.util.Set; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.declaration.CtElement; import spoon.reflect.declaration.CtModule; import spoon.reflect.declaration.CtPackage; -import spoon.reflect.declaration.CtShadowable; import spoon.reflect.declaration.CtType; import spoon.reflect.declaration.ParentNotInitializedException; import spoon.reflect.path.CtRole; @@ -29,7 +31,8 @@ import spoon.support.comparator.QualifiedNameComparator; import spoon.support.util.ModelSet; -import java.util.Set; + + /** * The implementation for {@link spoon.reflect.declaration.CtPackage}. @@ -98,9 +101,9 @@ public void accept(CtVisitor v) { } @Override - public T addPackage(CtPackage pack) { + public CtPackageImpl addPackage(CtPackage pack) { this.packs.add(pack); - return (T) this; + return this; } /** add all types of "from" in "to" */ @@ -186,15 +189,15 @@ public Set> getTypes() { } @Override - public T setPackages(Set packs) { + public CtPackageImpl setPackages(Set packs) { this.packs.set(packs); - return (T) this; + return this; } @Override - public T setTypes(Set> types) { + public CtPackageImpl setTypes(Set> types) { this.types.set(types); - return (T) this; + return this; } @Override @@ -203,9 +206,9 @@ public CtPackageReference getReference() { } @Override - public T addType(CtType type) { + public CtPackageImpl addType(CtType type) { types.add(type); - return (T) this; + return this; } @Override @@ -227,10 +230,10 @@ public boolean isShadow() { } @Override - public E setShadow(boolean isShadow) { + public CtPackageImpl setShadow(boolean isShadow) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.IS_SHADOW, isShadow, this.isShadow); this.isShadow = isShadow; - return (E) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/declaration/CtParameterImpl.java b/src/main/java/spoon/support/reflect/declaration/CtParameterImpl.java index 0690031953a..b7c285d982f 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtParameterImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtParameterImpl.java @@ -16,14 +16,12 @@ */ package spoon.support.reflect.declaration; + +import java.util.Set; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtExpression; import spoon.reflect.declaration.CtExecutable; -import spoon.reflect.declaration.CtModifiable; import spoon.reflect.declaration.CtParameter; -import spoon.reflect.declaration.CtShadowable; -import spoon.reflect.declaration.CtTypedElement; -import spoon.reflect.declaration.CtVariable; import spoon.reflect.declaration.ModifierKind; import spoon.reflect.path.CtRole; import spoon.reflect.reference.CtParameterReference; @@ -34,7 +32,8 @@ import spoon.support.reflect.CtExtendedModifier; import spoon.support.reflect.CtModifierHandler; -import java.util.Set; + + /** * The implementation for {@link spoon.reflect.declaration.CtParameter}. @@ -79,19 +78,19 @@ public CtTypeReference getType() { @Override @UnsettableProperty - public > C setDefaultExpression(CtExpression defaultExpression) { + public CtParameterImpl setDefaultExpression(CtExpression defaultExpression) { // unsettable property - return (C) this; + return this; } @Override - public C setType(CtTypeReference type) { + public CtParameterImpl setType(CtTypeReference type) { if (type != null) { type.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.TYPE, type, this.type); this.type = type; - return (C) this; + return this; } @Override @@ -100,10 +99,10 @@ public boolean isVarArgs() { } @Override - public > C setVarArgs(boolean varArgs) { + public CtParameterImpl setVarArgs(boolean varArgs) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.IS_VARARGS, varArgs, this.varArgs); this.varArgs = varArgs; - return (C) this; + return this; } @Override @@ -117,27 +116,27 @@ public boolean hasModifier(ModifierKind modifier) { } @Override - public C setModifiers(Set modifiers) { + public CtParameterImpl setModifiers(Set modifiers) { modifierHandler.setModifiers(modifiers); - return (C) this; + return this; } @Override - public C addModifier(ModifierKind modifier) { + public CtParameterImpl addModifier(ModifierKind modifier) { modifierHandler.addModifier(modifier); - return (C) this; + return this; } @Override - public C removeModifier(ModifierKind modifier) { + public CtParameterImpl removeModifier(ModifierKind modifier) { modifierHandler.removeModifier(modifier); - return (C) this; + return this; } @Override - public C setVisibility(ModifierKind visibility) { + public CtParameterImpl setVisibility(ModifierKind visibility) { modifierHandler.setVisibility(visibility); - return (C) this; + return this; } @Override @@ -157,9 +156,9 @@ public Set getExtendedModifiers() { } @Override - public T setExtendedModifiers(Set extendedModifiers) { + public CtParameterImpl setExtendedModifiers(Set extendedModifiers) { this.modifierHandler.setExtendedModifiers(extendedModifiers); - return (T) this; + return this; } @@ -172,10 +171,10 @@ public boolean isShadow() { } @Override - public E setShadow(boolean isShadow) { + public CtParameterImpl setShadow(boolean isShadow) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.IS_SHADOW, isShadow, this.isShadow); this.isShadow = isShadow; - return (E) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/declaration/CtProvidedServiceImpl.java b/src/main/java/spoon/support/reflect/declaration/CtProvidedServiceImpl.java index 8ded2db7d81..c664dd5bf2b 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtProvidedServiceImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtProvidedServiceImpl.java @@ -16,15 +16,18 @@ */ package spoon.support.reflect.declaration; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.declaration.CtProvidedService; import spoon.reflect.path.CtRole; import spoon.reflect.reference.CtTypeReference; import spoon.reflect.visitor.CtVisitor; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; + + public class CtProvidedServiceImpl extends CtElementImpl implements CtProvidedService { @MetamodelPropertyField(role = CtRole.SERVICE_TYPE) @@ -42,13 +45,13 @@ public CtTypeReference getServiceType() { } @Override - public T setServiceType(CtTypeReference providingType) { + public CtProvidedServiceImpl setServiceType(CtTypeReference providingType) { if (providingType != null) { providingType.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.SERVICE_TYPE, providingType, this.serviceType); this.serviceType = providingType; - return (T) this; + return this; } @Override @@ -57,11 +60,11 @@ public List getImplementationTypes() { } @Override - public T setImplementationTypes(List usedTypes) { + public CtProvidedServiceImpl setImplementationTypes(List usedTypes) { getFactory().getEnvironment().getModelChangeListener().onListDeleteAll(this, CtRole.IMPLEMENTATION_TYPE, this.implementationTypes, new ArrayList<>(this.implementationTypes)); if (usedTypes == null || usedTypes.isEmpty()) { this.implementationTypes = CtElementImpl.emptyList(); - return (T) this; + return this; } if (this.implementationTypes == CtElementImpl.emptyList()) { @@ -72,13 +75,13 @@ public T setImplementationTypes(List T addImplementationType(CtTypeReference usedType) { + public CtProvidedServiceImpl addImplementationType(CtTypeReference usedType) { if (usedType == null) { - return (T) this; + return this; } if (this.implementationTypes == CtElementImpl.emptyList()) { this.implementationTypes = new ArrayList<>(); @@ -87,7 +90,7 @@ public T addImplementationType(CtTypeReference use getFactory().getEnvironment().getModelChangeListener().onListAdd(this, CtRole.IMPLEMENTATION_TYPE, this.implementationTypes, usedType); usedType.setParent(this); this.implementationTypes.add(usedType); - return (T) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/declaration/CtTypeImpl.java b/src/main/java/spoon/support/reflect/declaration/CtTypeImpl.java index 908897630a9..07af43dfdbc 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtTypeImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtTypeImpl.java @@ -16,20 +16,32 @@ */ package spoon.support.reflect.declaration; + +import java.lang.annotation.Annotation; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.function.Predicate; import spoon.SpoonException; import spoon.refactoring.Refactoring; +import spoon.reflect.ModelElementContainerDefaultCapacities; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.code.CtBlock; import spoon.reflect.declaration.CtAnnotation; import spoon.reflect.declaration.CtAnnotationType; +import spoon.reflect.declaration.CtClass; import spoon.reflect.declaration.CtConstructor; +import spoon.reflect.declaration.CtEnum; import spoon.reflect.declaration.CtExecutable; import spoon.reflect.declaration.CtField; -import spoon.reflect.declaration.CtFormalTypeDeclarer; +import spoon.reflect.declaration.CtInterface; import spoon.reflect.declaration.CtMethod; -import spoon.reflect.declaration.CtModifiable; import spoon.reflect.declaration.CtPackage; -import spoon.reflect.declaration.CtShadowable; import spoon.reflect.declaration.CtType; import spoon.reflect.declaration.CtTypeMember; import spoon.reflect.declaration.CtTypeParameter; @@ -57,17 +69,8 @@ import spoon.support.util.SignatureBasedSortedSet; import spoon.support.visitor.ClassTypingContext; -import java.lang.annotation.Annotation; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.Comparator; -import java.util.HashSet; -import java.util.List; -import java.util.Set; -import spoon.reflect.ModelElementContainerDefaultCapacities; + /** * The implementation for {@link spoon.reflect.declaration.CtType}. @@ -102,14 +105,14 @@ public List getTypeMembers() { * Otherwise, adds it at the end. */ @Override - public > C addTypeMember(CtTypeMember member) { + public CtTypeImpl addTypeMember(CtTypeMember member) { if (member == null) { - return (C) this; + return this; } Comparator c = new CtLineElementComparator(); if (member.isImplicit()) { - return addTypeMemberAt(0, member); + return ((CtTypeImpl) (addTypeMemberAt(0, member))); } // by default, inserting at the end @@ -126,13 +129,13 @@ public > C addTypeMember(CtTypeMember member) { insertionPosition--; } } - return addTypeMemberAt(insertionPosition, member); + return ((CtTypeImpl) (addTypeMemberAt(insertionPosition, member))); } @Override - public > C addTypeMemberAt(int position, CtTypeMember member) { + public CtTypeImpl addTypeMemberAt(int position, CtTypeMember member) { if (member == null) { - return (C) this; + return this; } if (this.typeMembers == CtElementImpl.emptyList()) { this.typeMembers = new ArrayList<>(); @@ -147,7 +150,7 @@ public > C addTypeMemberAt(int position, CtTypeMember member this.typeMembers.add(member); } } - return (C) this; + return this; } @Override @@ -170,49 +173,49 @@ public boolean removeTypeMember(CtTypeMember member) { } @Override - public > C setTypeMembers(List members) { + public CtTypeImpl setTypeMembers(List members) { for (CtTypeMember typeMember : new ArrayList<>(typeMembers)) { removeTypeMember(typeMember); } if (members == null || members.isEmpty()) { this.typeMembers = emptyList(); - return (C) this; + return this; } typeMembers.clear(); for (CtTypeMember typeMember : members) { addTypeMember(typeMember); } - return (C) this; + return this; } @Override - public > C addFieldAtTop(CtField field) { - return addTypeMemberAt(0, field); + public CtTypeImpl addFieldAtTop(CtField field) { + return ((CtTypeImpl) (addTypeMemberAt(0, field))); } @Override - public > C addField(CtField field) { - return addTypeMember(field); + public CtTypeImpl addField(CtField field) { + return ((CtTypeImpl) (addTypeMember(field))); } @Override - public > C addField(int index, CtField field) { - return addTypeMemberAt(index, field); + public CtTypeImpl addField(int index, CtField field) { + return ((CtTypeImpl) (addTypeMemberAt(index, field))); } @Override - public > C setFields(List> fields) { + public CtTypeImpl setFields(List> fields) { List> oldFields = getFields(); if (fields == null || fields.isEmpty()) { this.typeMembers.removeAll(oldFields); - return (C) this; + return this; } getFactory().getEnvironment().getModelChangeListener().onListDelete(this, CtRole.FIELD, this.typeMembers, new ArrayList<>(oldFields)); typeMembers.removeAll(oldFields); for (CtField field : fields) { addField(field); } - return (C) this; + return this; } @Override @@ -255,8 +258,8 @@ public List> getFields() { } @Override - public > C addNestedType(CtType nestedType) { - return addTypeMember(nestedType); + public CtTypeImpl addNestedType(CtType nestedType) { + return ((CtTypeImpl) (addTypeMember(nestedType))); } @Override @@ -265,18 +268,18 @@ public boolean removeNestedType(CtType nestedType) { } @Override - public > C setNestedTypes(Set> nestedTypes) { + public CtTypeImpl setNestedTypes(Set> nestedTypes) { Set> oldNestedTypes = getNestedTypes(); getFactory().getEnvironment().getModelChangeListener().onListDelete(this, CtRole.NESTED_TYPE, typeMembers, oldNestedTypes); if (nestedTypes == null || nestedTypes.isEmpty()) { this.typeMembers.removeAll(oldNestedTypes); - return (C) this; + return this; } typeMembers.removeAll(oldNestedTypes); for (CtType nestedType : nestedTypes) { addNestedType(nestedType); } - return (C) this; + return this; } @Override @@ -463,27 +466,27 @@ public boolean hasModifier(ModifierKind modifier) { } @Override - public C setModifiers(Set modifiers) { + public CtTypeImpl setModifiers(Set modifiers) { modifierHandler.setModifiers(modifiers); - return (C) this; + return this; } @Override - public C addModifier(ModifierKind modifier) { + public CtTypeImpl addModifier(ModifierKind modifier) { modifierHandler.addModifier(modifier); - return (C) this; + return this; } @Override - public C removeModifier(ModifierKind modifier) { + public CtTypeImpl removeModifier(ModifierKind modifier) { modifierHandler.removeModifier(modifier); - return (C) this; + return this; } @Override - public C setVisibility(ModifierKind visibility) { + public CtTypeImpl setVisibility(ModifierKind visibility) { modifierHandler.setVisibility(visibility); - return (C) this; + return this; } @Override @@ -497,9 +500,9 @@ public Set getExtendedModifiers() { } @Override - public T setExtendedModifiers(Set extendedModifiers) { + public CtTypeImpl setExtendedModifiers(Set extendedModifiers) { this.modifierHandler.setExtendedModifiers(extendedModifiers); - return (T) this; + return this; } @Override @@ -576,7 +579,7 @@ public List> getDeclaredFields() { } @Override - public > C addMethod(CtMethod method) { + public CtTypeImpl addMethod(CtMethod method) { if (method != null) { for (CtTypeMember typeMember : new ArrayList<>(typeMembers)) { if (!(typeMember instanceof CtMethod)) { @@ -590,7 +593,7 @@ public > C addMethod(CtMethod method) { } } } - return addTypeMember(method); + return ((CtTypeImpl) (addTypeMember(method))); } @Override @@ -599,9 +602,9 @@ public boolean removeMethod(CtMethod method) { } @Override - public > C addSuperInterface(CtTypeReference interfac) { + public CtTypeImpl addSuperInterface(CtTypeReference interfac) { if (interfac == null) { - return (C) this; + return this; } if (interfaces == CtElementImpl.>emptySet()) { interfaces = new QualifiedNameBasedSortedSet<>(); @@ -609,7 +612,7 @@ public > C addSuperInterface(CtTypeReference interfac) interfac.setParent(this); getFactory().getEnvironment().getModelChangeListener().onSetAdd(this, CtRole.INTERFACE, this.interfaces, interfac); interfaces.add(interfac); - return (C) this; + return this; } @Override @@ -636,11 +639,11 @@ public List getFormalCtTypeParameters() { } @Override - public C setFormalCtTypeParameters(List formalTypeParameters) { + public CtTypeImpl setFormalCtTypeParameters(List formalTypeParameters) { getFactory().getEnvironment().getModelChangeListener().onListDeleteAll(this, CtRole.TYPE_PARAMETER, formalCtTypeParameters, new ArrayList<>(formalCtTypeParameters)); if (formalTypeParameters == null || formalTypeParameters.isEmpty()) { this.formalCtTypeParameters = CtElementImpl.emptyList(); - return (C) this; + return this; } if (this.formalCtTypeParameters == CtElementImpl.emptyList()) { this.formalCtTypeParameters = new ArrayList<>(ModelElementContainerDefaultCapacities.TYPE_TYPE_PARAMETERS_CONTAINER_DEFAULT_CAPACITY); @@ -649,13 +652,13 @@ public C setFormalCtTypeParameters(List C addFormalCtTypeParameter(CtTypeParameter formalTypeParameter) { + public CtTypeImpl addFormalCtTypeParameter(CtTypeParameter formalTypeParameter) { if (formalTypeParameter == null) { - return (C) this; + return this; } if (formalCtTypeParameters == CtElementImpl.emptyList()) { formalCtTypeParameters = new ArrayList<>(ModelElementContainerDefaultCapacities.TYPE_TYPE_PARAMETERS_CONTAINER_DEFAULT_CAPACITY); @@ -663,7 +666,7 @@ public C addFormalCtTypeParameter(CtTypeParamet formalTypeParameter.setParent(this); getFactory().getEnvironment().getModelChangeListener().onListAdd(this, CtRole.TYPE_PARAMETER, this.formalCtTypeParameters, formalTypeParameter); formalCtTypeParameters.add(formalTypeParameter); - return (C) this; + return this; } @Override @@ -847,31 +850,31 @@ public Set> getSuperInterfaces() { } @Override - public > C setMethods(Set> methods) { + public CtTypeImpl setMethods(Set> methods) { Set> allMethods = getMethods(); getFactory().getEnvironment().getModelChangeListener().onListDelete(this, CtRole.METHOD, this.typeMembers, new ArrayList(allMethods)); typeMembers.removeAll(allMethods); if (methods == null || methods.isEmpty()) { - return (C) this; + return this; } for (CtMethod meth : methods) { addMethod(meth); } - return (C) this; + return this; } @Override @UnsettableProperty - public > C setSuperclass(CtTypeReference superClass) { + public CtTypeImpl setSuperclass(CtTypeReference superClass) { // overridden in subclasses. - return (C) this; + return this; } @Override - public > C setSuperInterfaces(Set> interfaces) { + public CtTypeImpl setSuperInterfaces(Set> interfaces) { if (interfaces == null || interfaces.isEmpty()) { this.interfaces = CtElementImpl.emptySet(); - return (C) this; + return this; } if (this.interfaces == CtElementImpl.>emptySet()) { this.interfaces = new QualifiedNameBasedSortedSet<>(); @@ -881,7 +884,7 @@ public > C setSuperInterfaces(Set> interf for (CtTypeReference anInterface : interfaces) { addSuperInterface(anInterface); } - return (C) this; + return this; } @Override @@ -938,10 +941,10 @@ public boolean isShadow() { } @Override - public E setShadow(boolean isShadow) { + public CtTypeImpl setShadow(boolean isShadow) { getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.IS_SHADOW, isShadow, this.isShadow); this.isShadow = isShadow; - return (E) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/declaration/CtTypeParameterImpl.java b/src/main/java/spoon/support/reflect/declaration/CtTypeParameterImpl.java index 9eb91dca349..0e6906c5325 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtTypeParameterImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtTypeParameterImpl.java @@ -16,17 +16,22 @@ */ package spoon.support.reflect.declaration; + +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.Set; import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.declaration.CtField; import spoon.reflect.declaration.CtFormalTypeDeclarer; import spoon.reflect.declaration.CtMethod; -import spoon.reflect.declaration.CtModifiable; import spoon.reflect.declaration.CtPackage; import spoon.reflect.declaration.CtType; import spoon.reflect.declaration.CtTypeMember; import spoon.reflect.declaration.CtTypeParameter; import spoon.reflect.declaration.ModifierKind; import spoon.reflect.declaration.ParentNotInitializedException; +import spoon.reflect.factory.TypeFactory; import spoon.reflect.reference.CtExecutableReference; import spoon.reflect.reference.CtFieldReference; import spoon.reflect.reference.CtTypeParameterReference; @@ -36,13 +41,11 @@ import spoon.support.UnsettableProperty; import spoon.support.visitor.GenericTypeAdapter; -import java.util.Collection; -import java.util.Collections; -import java.util.List; -import java.util.Set; - import static spoon.reflect.path.CtRole.SUPER_TYPE; + + + public class CtTypeParameterImpl extends CtTypeImpl implements CtTypeParameter { @MetamodelPropertyField(role = SUPER_TYPE) CtTypeReference superClass; @@ -58,13 +61,13 @@ public CtTypeReference getSuperclass() { } @Override - public > C setSuperclass(CtTypeReference superClass) { + public CtTypeParameterImpl setSuperclass(CtTypeReference superClass) { if (superClass != null) { superClass.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, SUPER_TYPE, superClass, this.superClass); this.superClass = superClass; - return (C) this; + return this; } @Override @@ -98,30 +101,30 @@ public CtFormalTypeDeclarer getTypeParameterDeclarer() { @Override @UnsettableProperty - public > C addFieldAtTop(CtField field) { + public CtTypeParameterImpl addFieldAtTop(CtField field) { // unsettable property - return (C) this; + return this; } @Override @UnsettableProperty - public > C addField(CtField field) { + public CtTypeParameterImpl addField(CtField field) { // unsettable property - return (C) this; + return this; } @Override @UnsettableProperty - public > C addField(int index, CtField field) { + public CtTypeParameterImpl addField(int index, CtField field) { // unsettable property - return (C) this; + return this; } @Override @UnsettableProperty - public > C setFields(List> fields) { + public CtTypeParameterImpl setFields(List> fields) { // unsettable property - return (C) this; + return this; } @Override @@ -144,9 +147,9 @@ public List> getFields() { @Override @UnsettableProperty - public > C addNestedType(CtType nestedType) { + public CtTypeParameterImpl addNestedType(CtType nestedType) { // unsettable property - return (C) this; + return this; } @Override @@ -158,9 +161,9 @@ public boolean removeNestedType(CtType nestedType) { @Override @UnsettableProperty - public > C setNestedTypes(Set> nestedTypes) { + public CtTypeParameterImpl setNestedTypes(Set> nestedTypes) { // unsettable property - return (C) this; + return this; } @Override @@ -197,30 +200,30 @@ public boolean hasModifier(ModifierKind modifier) { @Override @UnsettableProperty - public C setModifiers(Set modifiers) { + public CtTypeParameterImpl setModifiers(Set modifiers) { // unsettable property - return (C) this; + return this; } @Override @UnsettableProperty - public C addModifier(ModifierKind modifier) { + public CtTypeParameterImpl addModifier(ModifierKind modifier) { // unsettable property - return (C) this; + return this; } @Override @UnsettableProperty - public C removeModifier(ModifierKind modifier) { + public CtTypeParameterImpl removeModifier(ModifierKind modifier) { // unsettable property - return (C) this; + return this; } @Override @UnsettableProperty - public C setVisibility(ModifierKind visibility) { + public CtTypeParameterImpl setVisibility(ModifierKind visibility) { // unsettable property - return (C) this; + return this; } @Override @@ -314,9 +317,9 @@ private static CtTypeReference getBound(CtTypeParameter typeParam) { @Override @UnsettableProperty - public > C addMethod(CtMethod method) { + public CtTypeParameterImpl addMethod(CtMethod method) { // unsettable property - return (C) this; + return this; } @Override @@ -328,9 +331,9 @@ public boolean removeMethod(CtMethod method) { @Override @UnsettableProperty - public > C addSuperInterface(CtTypeReference interfac) { + public CtTypeParameterImpl addSuperInterface(CtTypeReference interfac) { // unsettable property - return (C) this; + return this; } @Override @@ -374,16 +377,16 @@ public Set> getSuperInterfaces() { @Override @UnsettableProperty - public > C setMethods(Set> methods) { + public CtTypeParameterImpl setMethods(Set> methods) { // unsettable property - return (C) this; + return this; } @Override @UnsettableProperty - public > C setSuperInterfaces(Set> interfaces) { + public CtTypeParameterImpl setSuperInterfaces(Set> interfaces) { // unsettable property - return (C) this; + return this; } @Override @@ -412,8 +415,8 @@ public List getFormalCtTypeParameters() { @Override @UnsettableProperty - public C setFormalCtTypeParameters(List formalTypeParameters) { - return (C) this; + public CtTypeParameterImpl setFormalCtTypeParameters(List formalTypeParameters) { + return this; } @Override @@ -424,7 +427,7 @@ public List getTypeMembers() { @Override @UnsettableProperty - public > C setTypeMembers(List members) { - return (C) this; + public CtTypeParameterImpl setTypeMembers(List members) { + return this; } } diff --git a/src/main/java/spoon/support/reflect/declaration/CtUsedServiceImpl.java b/src/main/java/spoon/support/reflect/declaration/CtUsedServiceImpl.java index 56cfaeb2e24..c8581ecf55f 100644 --- a/src/main/java/spoon/support/reflect/declaration/CtUsedServiceImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/CtUsedServiceImpl.java @@ -16,12 +16,16 @@ */ package spoon.support.reflect.declaration; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.declaration.CtUsedService; import spoon.reflect.path.CtRole; import spoon.reflect.reference.CtTypeReference; import spoon.reflect.visitor.CtVisitor; + + + public class CtUsedServiceImpl extends CtElementImpl implements CtUsedService { @MetamodelPropertyField(role = CtRole.SERVICE_TYPE) private CtTypeReference serviceType; @@ -32,14 +36,14 @@ public CtTypeReference getServiceType() { } @Override - public T setServiceType(CtTypeReference usedService) { + public CtUsedServiceImpl setServiceType(CtTypeReference usedService) { if (usedService != null) { usedService.setParent(this); } getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, CtRole.SERVICE_TYPE, usedService, this.serviceType); this.serviceType = usedService; - return (T) this; + return this; } @Override diff --git a/src/main/java/spoon/support/reflect/declaration/InvisibleArrayConstructorImpl.java b/src/main/java/spoon/support/reflect/declaration/InvisibleArrayConstructorImpl.java index b6134e73115..d92811e9fe0 100644 --- a/src/main/java/spoon/support/reflect/declaration/InvisibleArrayConstructorImpl.java +++ b/src/main/java/spoon/support/reflect/declaration/InvisibleArrayConstructorImpl.java @@ -16,13 +16,16 @@ */ package spoon.support.reflect.declaration; + import spoon.reflect.annotations.MetamodelPropertyField; import spoon.reflect.declaration.CtType; -import spoon.reflect.declaration.CtTypedElement; import spoon.reflect.path.CtRole; import spoon.reflect.reference.CtTypeReference; + + + /** * This class is used to represent the constructor of an array when calling with an expression like * 
@@ -43,13 +46,13 @@ public CtTypeReference getType() {
 	}
 
 	@Override
-	public  C setType(CtTypeReference type) {
+	public InvisibleArrayConstructorImpl setType(CtTypeReference type) {
 		if (type == null) {
-			return (C) this;
+			return this;
 		}
 
 		this.type = type;
-		return (C) this;
+		return this;
 	}
 
 	@Override
diff --git a/src/main/java/spoon/support/reflect/reference/CtArrayTypeReferenceImpl.java b/src/main/java/spoon/support/reflect/reference/CtArrayTypeReferenceImpl.java
index e1fe19e9c1d..f9f76d47d19 100644
--- a/src/main/java/spoon/support/reflect/reference/CtArrayTypeReferenceImpl.java
+++ b/src/main/java/spoon/support/reflect/reference/CtArrayTypeReferenceImpl.java
@@ -16,17 +16,19 @@
  */
 package spoon.support.reflect.reference;
 
+
+import java.lang.reflect.Array;
 import spoon.reflect.annotations.MetamodelPropertyField;
 import spoon.reflect.reference.CtArrayTypeReference;
-import spoon.reflect.reference.CtReference;
 import spoon.reflect.reference.CtTypeReference;
 import spoon.reflect.visitor.CtVisitor;
 import spoon.support.SpoonClassNotFoundException;
 
-import java.lang.reflect.Array;
-
 import static spoon.reflect.path.CtRole.TYPE;
 
+
+
+
 public class
 CtArrayTypeReferenceImpl extends CtTypeReferenceImpl implements CtArrayTypeReference {
 	private static final long serialVersionUID = 1L;
@@ -53,8 +55,8 @@ public CtTypeReference getComponentType() {
 	}
 
 	@Override
-	public CtTypeReference getArrayType() {
-		return getLastComponentTypeReference(componentType);
+	public CtArrayTypeReferenceImpl getArrayType() {
+		return ((CtArrayTypeReferenceImpl) (getLastComponentTypeReference(componentType)));
 	}
 
 	private CtTypeReference getLastComponentTypeReference(CtTypeReference component) {
@@ -62,13 +64,13 @@ private CtTypeReference getLastComponentTypeReference(CtTypeReference comp
 	}
 
 	@Override
-	public > C setComponentType(CtTypeReference componentType) {
+	public CtArrayTypeReferenceImpl setComponentType(CtTypeReference componentType) {
 		if (componentType != null) {
 			componentType.setParent(this);
 		}
 		getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, TYPE, componentType, this.componentType);
 		this.componentType = componentType;
-		return (C) this;
+		return this;
 	}
 
 	@Override
@@ -77,8 +79,8 @@ public String getSimpleName() {
 	}
 
 	@Override
-	public  T setSimpleName(String simplename) {
-		return (T) this;
+	public CtArrayTypeReferenceImpl setSimpleName(String simplename) {
+		return this;
 	}
 
 	@Override
diff --git a/src/main/java/spoon/support/reflect/reference/CtCatchVariableReferenceImpl.java b/src/main/java/spoon/support/reflect/reference/CtCatchVariableReferenceImpl.java
index 26842a9de39..d627efa8c6a 100644
--- a/src/main/java/spoon/support/reflect/reference/CtCatchVariableReferenceImpl.java
+++ b/src/main/java/spoon/support/reflect/reference/CtCatchVariableReferenceImpl.java
@@ -16,6 +16,7 @@
  */
 package spoon.support.reflect.reference;
 
+
 import spoon.reflect.code.CtCatch;
 import spoon.reflect.code.CtCatchVariable;
 import spoon.reflect.declaration.CtElement;
@@ -23,6 +24,9 @@
 import spoon.reflect.reference.CtCatchVariableReference;
 import spoon.reflect.visitor.CtVisitor;
 
+
+
+
 public class CtCatchVariableReferenceImpl extends CtVariableReferenceImpl implements CtCatchVariableReference {
 	private static final long serialVersionUID = 1L;
 
diff --git a/src/main/java/spoon/support/reflect/reference/CtExecutableReferenceImpl.java b/src/main/java/spoon/support/reflect/reference/CtExecutableReferenceImpl.java
index a0aa9eb2ec3..f8d3f1bc4fb 100644
--- a/src/main/java/spoon/support/reflect/reference/CtExecutableReferenceImpl.java
+++ b/src/main/java/spoon/support/reflect/reference/CtExecutableReferenceImpl.java
@@ -16,6 +16,15 @@
  */
 package spoon.support.reflect.reference;
 
+
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
 import spoon.Launcher;
 import spoon.SpoonException;
 import spoon.reflect.annotations.MetamodelPropertyField;
@@ -27,7 +36,7 @@
 import spoon.reflect.declaration.CtType;
 import spoon.reflect.declaration.CtTypeMember;
 import spoon.reflect.declaration.ModifierKind;
-import spoon.reflect.reference.CtActualTypeContainer;
+import spoon.reflect.factory.TypeFactory;
 import spoon.reflect.reference.CtArrayTypeReference;
 import spoon.reflect.reference.CtExecutableReference;
 import spoon.reflect.reference.CtTypeParameterReference;
@@ -40,22 +49,16 @@
 import spoon.support.visitor.ClassTypingContext;
 import spoon.support.visitor.SignaturePrinter;
 
-import java.lang.reflect.AnnotatedElement;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Set;
-
 import static spoon.reflect.ModelElementContainerDefaultCapacities.METHOD_TYPE_PARAMETERS_CONTAINER_DEFAULT_CAPACITY;
+import static spoon.reflect.path.CtRole.ARGUMENT_TYPE;
 import static spoon.reflect.path.CtRole.DECLARING_TYPE;
 import static spoon.reflect.path.CtRole.IS_STATIC;
-import static spoon.reflect.path.CtRole.ARGUMENT_TYPE;
 import static spoon.reflect.path.CtRole.TYPE;
 import static spoon.reflect.path.CtRole.TYPE_ARGUMENT;
 
+
+
+
 public class CtExecutableReferenceImpl extends CtReferenceImpl implements CtExecutableReference {
 	private static final long serialVersionUID = 1L;
 
@@ -162,10 +165,10 @@ public List> getParameters() {
 	}
 
 	@Override
-	public > C setParameters(List> parameters) {
+	public CtExecutableReferenceImpl setParameters(List> parameters) {
 		if (parameters == null || parameters.isEmpty()) {
 			this.parameters = CtElementImpl.emptyList();
-			return (C) this;
+			return this;
 		}
 		if (this.parameters == CtElementImpl.>emptyList()) {
 			this.parameters = new ArrayList<>();
@@ -175,7 +178,7 @@ public > C setParameters(List parameter : parameters) {
 			addParameter(parameter);
 		}
-		return (C) this;
+		return this;
 	}
 
 	private boolean addParameter(CtTypeReference parameter) {
@@ -241,10 +244,10 @@ public boolean isOverriding(CtExecutableReference executable) {
 	}
 
 	@Override
-	public  C setActualTypeArguments(List> actualTypeArguments) {
+	public CtExecutableReferenceImpl setActualTypeArguments(List> actualTypeArguments) {
 		if (actualTypeArguments == null || actualTypeArguments.isEmpty()) {
 			this.actualTypeArguments = CtElementImpl.emptyList();
-			return (C) this;
+			return this;
 		}
 		if (this.actualTypeArguments == CtElementImpl.>emptyList()) {
 			this.actualTypeArguments = new ArrayList<>();
@@ -254,27 +257,27 @@ public  C setActualTypeArguments(List actualTypeArgument : actualTypeArguments) {
 			addActualTypeArgument(actualTypeArgument);
 		}
-		return (C) this;
+		return this;
 	}
 
 	@Override
-	public > C setDeclaringType(CtTypeReference declaringType) {
+	public CtExecutableReferenceImpl setDeclaringType(CtTypeReference declaringType) {
 		if (declaringType != null) {
 			declaringType.setParent(this);
 		}
 		getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, DECLARING_TYPE, declaringType, this.declaringType);
 		this.declaringType = declaringType;
-		return (C) this;
+		return this;
 	}
 
 	@Override
-	public > C setType(CtTypeReference type) {
+	public CtExecutableReferenceImpl setType(CtTypeReference type) {
 		if (type != null) {
 			type.setParent(this);
 		}
 		getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, TYPE, type, this.type);
 		this.type = type;
-		return (C) this;
+		return this;
 	}
 
 	@Override
@@ -347,10 +350,10 @@ public boolean isStatic() {
 	}
 
 	@Override
-	public > C setStatic(boolean stat) {
+	public CtExecutableReferenceImpl setStatic(boolean stat) {
 		getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, IS_STATIC, stat, this.stat);
 		this.stat = stat;
-		return (C) this;
+		return this;
 	}
 
 	@Override
@@ -390,17 +393,17 @@ public Set getModifiers() {
 	}
 
 	@Override
-	public CtExecutableReference getOverridingExecutable() {
+	public CtExecutableReferenceImpl getOverridingExecutable() {
 		CtTypeReference objectType = getFactory().Type().OBJECT;
 		CtTypeReference declaringType = getDeclaringType();
 		if (declaringType == null) {
-			return getOverloadedExecutable(objectType, objectType);
+			return ((CtExecutableReferenceImpl) (getOverloadedExecutable(objectType, objectType)));
 		}
 		CtTypeReference st = declaringType.getSuperclass();
 		if (st == null) {
-			return getOverloadedExecutable(objectType, objectType);
+			return ((CtExecutableReferenceImpl) (getOverloadedExecutable(objectType, objectType)));
 		}
-		return getOverloadedExecutable(st, objectType);
+		return ((CtExecutableReferenceImpl) (getOverloadedExecutable(st, objectType)));
 	}
 
 	private CtExecutableReference getOverloadedExecutable(CtTypeReference t, CtTypeReference objectType) {
@@ -423,9 +426,9 @@ private CtExecutableReference getOverloadedExecutable(CtTypeReference t, C
 	}
 
 	@Override
-	public  C addActualTypeArgument(CtTypeReference actualTypeArgument) {
+	public CtExecutableReferenceImpl addActualTypeArgument(CtTypeReference actualTypeArgument) {
 		if (actualTypeArgument == null) {
-			return (C) this;
+			return this;
 		}
 		if (actualTypeArguments == CtElementImpl.>emptyList()) {
 			actualTypeArguments = new ArrayList<>(METHOD_TYPE_PARAMETERS_CONTAINER_DEFAULT_CAPACITY);
@@ -433,7 +436,7 @@ public  C addActualTypeArgument(CtTypeReference
 		actualTypeArgument.setParent(this);
 		getFactory().getEnvironment().getModelChangeListener().onListAdd(this, TYPE_ARGUMENT, this.actualTypeArguments, actualTypeArgument);
 		actualTypeArguments.add(actualTypeArgument);
-		return (C) this;
+		return this;
 	}
 
 	@Override
diff --git a/src/main/java/spoon/support/reflect/reference/CtFieldReferenceImpl.java b/src/main/java/spoon/support/reflect/reference/CtFieldReferenceImpl.java
index f4319a5d6c4..c792ad799d7 100644
--- a/src/main/java/spoon/support/reflect/reference/CtFieldReferenceImpl.java
+++ b/src/main/java/spoon/support/reflect/reference/CtFieldReferenceImpl.java
@@ -16,6 +16,11 @@
  */
 package spoon.support.reflect.reference;
 
+
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Member;
+import java.util.Collections;
+import java.util.Set;
 import spoon.Launcher;
 import spoon.reflect.annotations.MetamodelPropertyField;
 import spoon.reflect.declaration.CtEnum;
@@ -28,15 +33,13 @@
 import spoon.reflect.visitor.CtVisitor;
 import spoon.support.util.RtHelper;
 
-import java.lang.reflect.AnnotatedElement;
-import java.lang.reflect.Member;
-import java.util.Collections;
-import java.util.Set;
-
 import static spoon.reflect.path.CtRole.DECLARING_TYPE;
 import static spoon.reflect.path.CtRole.IS_FINAL;
 import static spoon.reflect.path.CtRole.IS_STATIC;
 
+
+
+
 public class CtFieldReferenceImpl extends CtVariableReferenceImpl implements CtFieldReference {
 	private static final long serialVersionUID = 1L;
 
@@ -195,27 +198,27 @@ public boolean isStatic() {
 	}
 
 	@Override
-	public > C setDeclaringType(CtTypeReference declaringType) {
+	public CtFieldReferenceImpl setDeclaringType(CtTypeReference declaringType) {
 		if (declaringType != null) {
 			declaringType.setParent(this);
 		}
 		getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, DECLARING_TYPE, declaringType, this.declaringType);
 		this.declaringType = declaringType;
-		return (C) this;
+		return this;
 	}
 
 	@Override
-	public > C setFinal(boolean fina) {
+	public CtFieldReferenceImpl setFinal(boolean fina) {
 		getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, IS_FINAL, fina, this.fina);
 		this.fina = fina;
-		return (C) this;
+		return this;
 	}
 
 	@Override
-	public > C setStatic(boolean stat) {
+	public CtFieldReferenceImpl setStatic(boolean stat) {
 		getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, IS_STATIC, stat, this.stat);
 		this.stat = stat;
-		return (C) this;
+		return this;
 	}
 
 	@Override
diff --git a/src/main/java/spoon/support/reflect/reference/CtIntersectionTypeReferenceImpl.java b/src/main/java/spoon/support/reflect/reference/CtIntersectionTypeReferenceImpl.java
index b5baef5fe1c..b6d4ff8ec69 100644
--- a/src/main/java/spoon/support/reflect/reference/CtIntersectionTypeReferenceImpl.java
+++ b/src/main/java/spoon/support/reflect/reference/CtIntersectionTypeReferenceImpl.java
@@ -16,19 +16,23 @@
  */
 package spoon.support.reflect.reference;
 
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 import spoon.reflect.annotations.MetamodelPropertyField;
+import spoon.reflect.factory.TypeFactory;
 import spoon.reflect.reference.CtIntersectionTypeReference;
 import spoon.reflect.reference.CtTypeReference;
 import spoon.reflect.visitor.CtVisitor;
 import spoon.support.reflect.declaration.CtElementImpl;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
 import static spoon.reflect.path.CtRole.BOUND;
 
 
+
+
+
 public class CtIntersectionTypeReferenceImpl extends CtTypeReferenceImpl implements CtIntersectionTypeReference {
 	@MetamodelPropertyField(role = BOUND)
 	List> bounds = CtElementImpl.emptyList();
@@ -44,10 +48,10 @@ public List> getBounds() {
 	}
 
 	@Override
-	public  C setBounds(List> bounds) {
+	public CtIntersectionTypeReferenceImpl setBounds(List> bounds) {
 		if (bounds == null || bounds.isEmpty()) {
 			this.bounds = CtElementImpl.emptyList();
-			return (C) this;
+			return this;
 		}
 		if (this.bounds == CtElementImpl.>emptySet()) {
 			this.bounds = new ArrayList<>();
@@ -57,13 +61,13 @@ public  C setBounds(List bound : bounds) {
 			addBound(bound);
 		}
-		return (C) this;
+		return this;
 	}
 
 	@Override
-	public  C addBound(CtTypeReference bound) {
+	public CtIntersectionTypeReferenceImpl addBound(CtTypeReference bound) {
 		if (bound == null) {
-			return (C) this;
+			return this;
 		}
 		if (bounds == CtElementImpl.>emptyList()) {
 			bounds = new ArrayList<>();
@@ -73,7 +77,7 @@ public  C addBound(CtTypeReference bou
 			getFactory().getEnvironment().getModelChangeListener().onListAdd(this, BOUND, this.bounds, bound);
 			bounds.add(bound);
 		}
-		return (C) this;
+		return this;
 	}
 
 	@Override
diff --git a/src/main/java/spoon/support/reflect/reference/CtLocalVariableReferenceImpl.java b/src/main/java/spoon/support/reflect/reference/CtLocalVariableReferenceImpl.java
index 2fa21966f25..682f08a9f70 100644
--- a/src/main/java/spoon/support/reflect/reference/CtLocalVariableReferenceImpl.java
+++ b/src/main/java/spoon/support/reflect/reference/CtLocalVariableReferenceImpl.java
@@ -16,6 +16,7 @@
  */
 package spoon.support.reflect.reference;
 
+
 import spoon.reflect.code.CtLocalVariable;
 import spoon.reflect.declaration.CtVariable;
 import spoon.reflect.declaration.ParentNotInitializedException;
@@ -23,6 +24,10 @@
 import spoon.reflect.reference.CtLocalVariableReference;
 import spoon.reflect.visitor.CtVisitor;
 import spoon.reflect.visitor.filter.PotentialVariableDeclarationFunction;
+import spoon.support.reflect.declaration.CtElementImpl;
+
+
+
 
 /**
  * An implementation for {@link CtLocalVariableReference}.
diff --git a/src/main/java/spoon/support/reflect/reference/CtModuleReferenceImpl.java b/src/main/java/spoon/support/reflect/reference/CtModuleReferenceImpl.java
index 72a61b579e2..c116e268257 100644
--- a/src/main/java/spoon/support/reflect/reference/CtModuleReferenceImpl.java
+++ b/src/main/java/spoon/support/reflect/reference/CtModuleReferenceImpl.java
@@ -16,11 +16,14 @@
  */
 package spoon.support.reflect.reference;
 
+
+import java.lang.reflect.AnnotatedElement;
 import spoon.reflect.declaration.CtModule;
 import spoon.reflect.reference.CtModuleReference;
 import spoon.reflect.visitor.CtVisitor;
 
-import java.lang.reflect.AnnotatedElement;
+
+
 
 public class CtModuleReferenceImpl extends CtReferenceImpl implements CtModuleReference {
 
diff --git a/src/main/java/spoon/support/reflect/reference/CtPackageReferenceImpl.java b/src/main/java/spoon/support/reflect/reference/CtPackageReferenceImpl.java
index 9859aed2690..62086a3c0e1 100644
--- a/src/main/java/spoon/support/reflect/reference/CtPackageReferenceImpl.java
+++ b/src/main/java/spoon/support/reflect/reference/CtPackageReferenceImpl.java
@@ -16,11 +16,14 @@
  */
 package spoon.support.reflect.reference;
 
+
+import java.lang.reflect.AnnotatedElement;
 import spoon.reflect.declaration.CtPackage;
 import spoon.reflect.reference.CtPackageReference;
 import spoon.reflect.visitor.CtVisitor;
 
-import java.lang.reflect.AnnotatedElement;
+
+
 
 public class CtPackageReferenceImpl extends CtReferenceImpl implements CtPackageReference {
 	private static final long serialVersionUID = 1L;
diff --git a/src/main/java/spoon/support/reflect/reference/CtParameterReferenceImpl.java b/src/main/java/spoon/support/reflect/reference/CtParameterReferenceImpl.java
index 014b1cf0160..5bf489789f7 100644
--- a/src/main/java/spoon/support/reflect/reference/CtParameterReferenceImpl.java
+++ b/src/main/java/spoon/support/reflect/reference/CtParameterReferenceImpl.java
@@ -16,6 +16,8 @@
  */
 package spoon.support.reflect.reference;
 
+
+import java.util.List;
 import spoon.reflect.declaration.CtElement;
 import spoon.reflect.declaration.CtExecutable;
 import spoon.reflect.declaration.CtParameter;
@@ -24,7 +26,8 @@
 import spoon.reflect.reference.CtParameterReference;
 import spoon.reflect.visitor.CtVisitor;
 
-import java.util.List;
+
+
 
 public class CtParameterReferenceImpl extends CtVariableReferenceImpl implements CtParameterReference {
 	private static final long serialVersionUID = 1L;
diff --git a/src/main/java/spoon/support/reflect/reference/CtReferenceImpl.java b/src/main/java/spoon/support/reflect/reference/CtReferenceImpl.java
index 9e701c355f4..6a876587a44 100644
--- a/src/main/java/spoon/support/reflect/reference/CtReferenceImpl.java
+++ b/src/main/java/spoon/support/reflect/reference/CtReferenceImpl.java
@@ -16,9 +16,13 @@
  */
 package spoon.support.reflect.reference;
 
+
+import java.io.Serializable;
+import java.lang.reflect.AnnotatedElement;
+import java.util.List;
+import java.util.Objects;
 import spoon.reflect.annotations.MetamodelPropertyField;
 import spoon.reflect.code.CtComment;
-import spoon.reflect.declaration.CtElement;
 import spoon.reflect.factory.Factory;
 import spoon.reflect.factory.FactoryImpl;
 import spoon.reflect.reference.CtReference;
@@ -26,13 +30,11 @@
 import spoon.support.UnsettableProperty;
 import spoon.support.reflect.declaration.CtElementImpl;
 
-import java.io.Serializable;
-import java.lang.reflect.AnnotatedElement;
-import java.util.List;
-import java.util.Objects;
-
 import static spoon.reflect.path.CtRole.NAME;
 
+
+
+
 public abstract class CtReferenceImpl extends CtElementImpl implements CtReference, Serializable {
 
 	private static final long serialVersionUID = 1L;
@@ -51,24 +53,24 @@ public String getSimpleName() {
 	}
 
 	@Override
-	public  T setSimpleName(String simplename) {
+	public CtReferenceImpl setSimpleName(String simplename) {
 		Factory factory = getFactory();
 		if (factory == null) {
 			this.simplename = simplename;
-			return (T) this;
+			return this;
 		}
 		if (factory instanceof FactoryImpl) {
 			simplename = ((FactoryImpl) factory).dedup(simplename);
 		}
 		getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, NAME, simplename, this.simplename);
 		this.simplename = simplename;
-		return (T) this;
+		return this;
 	}
 
 	@UnsettableProperty
 	@Override
-	public  E setComments(List comments) {
-		return (E) this;
+	public CtReferenceImpl setComments(List comments) {
+		return this;
 	}
 
 	@Override
diff --git a/src/main/java/spoon/support/reflect/reference/CtTypeParameterReferenceImpl.java b/src/main/java/spoon/support/reflect/reference/CtTypeParameterReferenceImpl.java
index 0a2fbf64606..d00d49e7dce 100644
--- a/src/main/java/spoon/support/reflect/reference/CtTypeParameterReferenceImpl.java
+++ b/src/main/java/spoon/support/reflect/reference/CtTypeParameterReferenceImpl.java
@@ -16,23 +16,26 @@
  */
 package spoon.support.reflect.reference;
 
+
+import java.lang.reflect.AnnotatedElement;
+import java.util.List;
+import java.util.Objects;
 import spoon.SpoonException;
 import spoon.reflect.declaration.CtElement;
 import spoon.reflect.declaration.CtFormalTypeDeclarer;
 import spoon.reflect.declaration.CtMethod;
 import spoon.reflect.declaration.CtType;
 import spoon.reflect.declaration.CtTypeParameter;
-import spoon.reflect.reference.CtActualTypeContainer;
 import spoon.reflect.reference.CtExecutableReference;
 import spoon.reflect.reference.CtTypeParameterReference;
 import spoon.reflect.reference.CtTypeReference;
 import spoon.reflect.visitor.CtVisitor;
 import spoon.support.DerivedProperty;
 import spoon.support.UnsettableProperty;
+import spoon.support.reflect.declaration.CtElementImpl;
+
+
 
-import java.lang.reflect.AnnotatedElement;
-import java.util.List;
-import java.util.Objects;
 
 public class CtTypeParameterReferenceImpl extends CtTypeReferenceImpl implements CtTypeParameterReference {
 	private static final long serialVersionUID = 1L;
@@ -70,14 +73,14 @@ public List> getActualTypeArguments() {
 
 	@Override
 	@UnsettableProperty
-	public  C setActualTypeArguments(List> actualTypeArguments) {
-		return (C) this;
+	public CtTypeParameterReferenceImpl setActualTypeArguments(List> actualTypeArguments) {
+		return this;
 	}
 
 	@Override
 	@UnsettableProperty
-	public  C addActualTypeArgument(CtTypeReference actualTypeArgument) {
-		return (C) this;
+	public CtTypeParameterReferenceImpl addActualTypeArgument(CtTypeReference actualTypeArgument) {
+		return this;
 	}
 
 	@Override
diff --git a/src/main/java/spoon/support/reflect/reference/CtTypeReferenceImpl.java b/src/main/java/spoon/support/reflect/reference/CtTypeReferenceImpl.java
index fe7aea23757..da1e770fae5 100644
--- a/src/main/java/spoon/support/reflect/reference/CtTypeReferenceImpl.java
+++ b/src/main/java/spoon/support/reflect/reference/CtTypeReferenceImpl.java
@@ -16,6 +16,15 @@
  */
 package spoon.support.reflect.reference;
 
+
+import java.lang.reflect.AnnotatedElement;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 import spoon.Launcher;
 import spoon.SpoonException;
 import spoon.reflect.annotations.MetamodelPropertyField;
@@ -25,11 +34,9 @@
 import spoon.reflect.declaration.CtFormalTypeDeclarer;
 import spoon.reflect.declaration.CtMethod;
 import spoon.reflect.declaration.CtPackage;
-import spoon.reflect.declaration.CtShadowable;
 import spoon.reflect.declaration.CtType;
 import spoon.reflect.declaration.CtTypeParameter;
 import spoon.reflect.declaration.ModifierKind;
-import spoon.reflect.reference.CtActualTypeContainer;
 import spoon.reflect.reference.CtArrayTypeReference;
 import spoon.reflect.reference.CtExecutableReference;
 import spoon.reflect.reference.CtFieldReference;
@@ -42,21 +49,15 @@
 import spoon.support.reflect.declaration.CtElementImpl;
 import spoon.support.visitor.ClassTypingContext;
 
-import java.lang.reflect.AnnotatedElement;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-import java.util.Set;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
 import static spoon.reflect.ModelElementContainerDefaultCapacities.TYPE_TYPE_PARAMETERS_CONTAINER_DEFAULT_CAPACITY;
 import static spoon.reflect.path.CtRole.DECLARING_TYPE;
 import static spoon.reflect.path.CtRole.IS_SHADOW;
 import static spoon.reflect.path.CtRole.PACKAGE_REF;
 import static spoon.reflect.path.CtRole.TYPE_ARGUMENT;
 
+
+
+
 public class CtTypeReferenceImpl extends CtReferenceImpl implements CtTypeReference {
 	private static final long serialVersionUID = 1L;
 
@@ -254,10 +255,10 @@ private boolean isImplementationOf(CtTypeReference type) {
 	}
 
 	@Override
-	public  C setActualTypeArguments(List> actualTypeArguments) {
+	public CtTypeReferenceImpl setActualTypeArguments(List> actualTypeArguments) {
 		if (actualTypeArguments == null || actualTypeArguments.isEmpty()) {
 			this.actualTypeArguments = CtElementImpl.emptyList();
-			return (C) this;
+			return this;
 		}
 		if (this.actualTypeArguments == CtElementImpl.>emptyList()) {
 			this.actualTypeArguments = new ArrayList<>(TYPE_TYPE_PARAMETERS_CONTAINER_DEFAULT_CAPACITY);
@@ -267,27 +268,27 @@ public  C setActualTypeArguments(List actualTypeArgument : actualTypeArguments) {
 			addActualTypeArgument(actualTypeArgument);
 		}
-		return (C) this;
+		return this;
 	}
 
 	@Override
-	public > C setDeclaringType(CtTypeReference declaringType) {
+	public CtTypeReferenceImpl setDeclaringType(CtTypeReference declaringType) {
 		if (declaringType != null) {
 			declaringType.setParent(this);
 		}
 		getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, DECLARING_TYPE, declaringType, this.declaringType);
 		this.declaringType = declaringType;
-		return (C) this;
+		return this;
 	}
 
 	@Override
-	public > C setPackage(CtPackageReference pack) {
+	public CtTypeReferenceImpl setPackage(CtPackageReference pack) {
 		if (pack != null) {
 			pack.setParent(this);
 		}
 		getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, PACKAGE_REF, pack, this.pack);
 		this.pack = pack;
-		return (C) this;
+		return this;
 	}
 
 	@Override
@@ -471,9 +472,9 @@ public boolean isLocalType() {
 	}
 
 	@Override
-	public  C addActualTypeArgument(CtTypeReference actualTypeArgument) {
+	public CtTypeReferenceImpl addActualTypeArgument(CtTypeReference actualTypeArgument) {
 		if (actualTypeArgument == null) {
-			return (C) this;
+			return this;
 		}
 		if (actualTypeArguments == CtElementImpl.>emptyList()) {
 			actualTypeArguments = new ArrayList<>(TYPE_TYPE_PARAMETERS_CONTAINER_DEFAULT_CAPACITY);
@@ -481,7 +482,7 @@ public  C addActualTypeArgument(CtTypeReference
 		actualTypeArgument.setParent(this);
 		getFactory().getEnvironment().getModelChangeListener().onListAdd(this, TYPE_ARGUMENT, this.actualTypeArguments, actualTypeArgument);
 		actualTypeArguments.add(actualTypeArgument);
-		return (C) this;
+		return this;
 	}
 
 	@Override
@@ -718,10 +719,10 @@ public boolean isShadow() {
 	}
 
 	@Override
-	public  E setShadow(boolean isShadow) {
+	public CtTypeReferenceImpl setShadow(boolean isShadow) {
 		getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, IS_SHADOW, isShadow, this.isShadow);
 		this.isShadow = isShadow;
-		return (E) this;
+		return this;
 	}
 
 	@Override
diff --git a/src/main/java/spoon/support/reflect/reference/CtUnboundVariableReferenceImpl.java b/src/main/java/spoon/support/reflect/reference/CtUnboundVariableReferenceImpl.java
index cf1f5fa98db..ae66f461fd9 100644
--- a/src/main/java/spoon/support/reflect/reference/CtUnboundVariableReferenceImpl.java
+++ b/src/main/java/spoon/support/reflect/reference/CtUnboundVariableReferenceImpl.java
@@ -16,15 +16,18 @@
  */
 package spoon.support.reflect.reference;
 
+
 import java.lang.annotation.Annotation;
 import java.util.List;
-
 import spoon.reflect.declaration.CtAnnotation;
-import spoon.reflect.declaration.CtElement;
 import spoon.reflect.reference.CtUnboundVariableReference;
 import spoon.reflect.visitor.CtVisitor;
 import spoon.support.DerivedProperty;
 import spoon.support.UnsettableProperty;
+import spoon.support.reflect.declaration.CtElementImpl;
+
+
+
 
 /** represents a reference to an unbound field (used when no full classpath is available */
 public class CtUnboundVariableReferenceImpl extends CtVariableReferenceImpl implements CtUnboundVariableReference {
@@ -48,7 +51,7 @@ public List> getAnnotations() {
 
 	@Override
 	@UnsettableProperty
-	public  E setAnnotations(List> annotations) {
-		return (E) this;
+	public CtUnboundVariableReferenceImpl setAnnotations(List> annotations) {
+		return this;
 	}
 }
diff --git a/src/main/java/spoon/support/reflect/reference/CtVariableReferenceImpl.java b/src/main/java/spoon/support/reflect/reference/CtVariableReferenceImpl.java
index 8618770adf2..cda96484e49 100644
--- a/src/main/java/spoon/support/reflect/reference/CtVariableReferenceImpl.java
+++ b/src/main/java/spoon/support/reflect/reference/CtVariableReferenceImpl.java
@@ -16,6 +16,10 @@
  */
 package spoon.support.reflect.reference;
 
+
+import java.lang.reflect.AnnotatedElement;
+import java.util.Collections;
+import java.util.Set;
 import spoon.reflect.annotations.MetamodelPropertyField;
 import spoon.reflect.declaration.CtVariable;
 import spoon.reflect.declaration.ModifierKind;
@@ -23,12 +27,11 @@
 import spoon.reflect.reference.CtVariableReference;
 import spoon.reflect.visitor.CtVisitor;
 
-import java.lang.reflect.AnnotatedElement;
-import java.util.Collections;
-import java.util.Set;
-
 import static spoon.reflect.path.CtRole.TYPE;
 
+
+
+
 public abstract class CtVariableReferenceImpl extends CtReferenceImpl implements CtVariableReference {
 	private static final long serialVersionUID = 1L;
 
@@ -49,13 +52,13 @@ public CtTypeReference getType() {
 	}
 
 	@Override
-	public > C setType(CtTypeReference type) {
+	public CtVariableReferenceImpl setType(CtTypeReference type) {
 		if (type != null) {
 			type.setParent(this);
 		}
 		getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, TYPE, type, this.type);
 		this.type = type;
-		return (C) this;
+		return this;
 	}
 
 	@Override
diff --git a/src/main/java/spoon/support/reflect/reference/CtWildcardReferenceImpl.java b/src/main/java/spoon/support/reflect/reference/CtWildcardReferenceImpl.java
index def85c10bf8..8dea02186b9 100644
--- a/src/main/java/spoon/support/reflect/reference/CtWildcardReferenceImpl.java
+++ b/src/main/java/spoon/support/reflect/reference/CtWildcardReferenceImpl.java
@@ -16,17 +16,20 @@
  */
 package spoon.support.reflect.reference;
 
-import static spoon.reflect.path.CtRole.BOUNDING_TYPE;
-import static spoon.reflect.path.CtRole.IS_UPPER;
 
 import spoon.reflect.annotations.MetamodelPropertyField;
 import spoon.reflect.declaration.CtType;
-import spoon.reflect.reference.CtReference;
 import spoon.reflect.reference.CtTypeReference;
 import spoon.reflect.reference.CtWildcardReference;
 import spoon.reflect.visitor.CtVisitor;
 import spoon.support.UnsettableProperty;
 
+import static spoon.reflect.path.CtRole.BOUNDING_TYPE;
+import static spoon.reflect.path.CtRole.IS_UPPER;
+
+
+
+
 public class CtWildcardReferenceImpl extends CtTypeParameterReferenceImpl implements CtWildcardReference {
 
 	@MetamodelPropertyField(role = BOUNDING_TYPE)
@@ -51,14 +54,14 @@ public boolean isUpper() {
 	}
 
 	@Override
-	public  T setUpper(boolean upper) {
+	public CtWildcardReferenceImpl setUpper(boolean upper) {
 		getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, IS_UPPER, upper, this.upper);
 		this.upper = upper;
-		return (T) this;
+		return this;
 	}
 
 	@Override
-	public  T setBoundingType(CtTypeReference superType) {
+	public CtWildcardReferenceImpl setBoundingType(CtTypeReference superType) {
 		if (superType != null) {
 			superType.setParent(this);
 		}
@@ -72,7 +75,7 @@ public  T setBoundingType(CtTypeReference supe
 
 		getFactory().getEnvironment().getModelChangeListener().onObjectUpdate(this, BOUNDING_TYPE, superType, this.superType);
 		this.superType = superType;
-		return (T) this;
+		return this;
 	}
 
 	@Override
@@ -82,8 +85,8 @@ public CtTypeReference getBoundingType() {
 
 	@Override
 	@UnsettableProperty
-	public  T setSimpleName(String simplename) {
-		return (T) this;
+	public CtWildcardReferenceImpl setSimpleName(String simplename) {
+		return this;
 	}
 
 	@Override
diff --git a/src/main/java/spoon/support/reflect/reference/CtWildcardStaticTypeMemberReferenceImpl.java b/src/main/java/spoon/support/reflect/reference/CtWildcardStaticTypeMemberReferenceImpl.java
index a78ec1fc696..2e4a6234aa3 100644
--- a/src/main/java/spoon/support/reflect/reference/CtWildcardStaticTypeMemberReferenceImpl.java
+++ b/src/main/java/spoon/support/reflect/reference/CtWildcardStaticTypeMemberReferenceImpl.java
@@ -16,7 +16,8 @@
  */
 package spoon.support.reflect.reference;
 
-import spoon.reflect.reference.CtReference;
+
+
 
 /**
  * This class intends to be used only to represent the reference of a
@@ -30,11 +31,11 @@ public CtWildcardStaticTypeMemberReferenceImpl() {
 	}
 
 	@Override
-	public  T setSimpleName(String newName) {
+	public CtWildcardStaticTypeMemberReferenceImpl setSimpleName(String newName) {
 		if (!newName.endsWith(".*")) {
 			newName += ".*";
 		}
-		return super.setSimpleName(newName);
+		return ((CtWildcardStaticTypeMemberReferenceImpl) (super.setSimpleName(newName)));
 	}
 
 	@Override