Uses of Interface
spoon.reflect.code.CtExpression

Packages that use CtExpression

Package	Description
spoon.refactoring
spoon.reflect.code	This package contains the meta-model part that models the executable code (methods and constructors' bodies, field initializers).
spoon.reflect.declaration	This package contains the meta-model part that models the declarations (program's structures such as classes, fields, etc).
spoon.reflect.factory	This package defines all the sub-factories for the Spoon meta-model.
spoon.reflect.visitor	This package defines visitor, scanner, and scanner-based query API for Java programs reified in the meta-model.
spoon.support	This package contains some default implementations for commonly used processing tasks.
spoon.support.compiler
spoon.support.compiler.jdt
spoon.support.reflect.code
spoon.support.reflect.declaration
spoon.support.reflect.eval
spoon.support.template	This package defines the substitution and matching engines for Java templates.
spoon.support.visitor.clone
spoon.support.visitor.replace
spoon.template	This package defines a framework for well-typed pure-Java templates.

Uses of CtExpression in spoon.refactoring

Methods in spoon.refactoring with parameters of type CtExpression

Modifier and Type	Method	Description
protected boolean	CtParameterRemoveRefactoring.canRemoveExpression(CtExpression<?> toBeRemovedExpression)	Detects whether `toBeRemovedExpression` can be safely removed during the refactoring
protected void	CtParameterRemoveRefactoring.createExpressionCannotBeRemovedIssue(CtInvocation<?> invocation, CtExpression<?> toBeRemovedExpression)	Override this method to get access to details about this refactoring issue.

Uses of CtExpression in spoon.reflect.code

Classes in spoon.reflect.code with type parameters of type CtExpression

Modifier and Type	Interface	Description
interface	CtArrayAccess<T,E extends CtExpression<?>>	This code element defines a one-dimensional array access.
interface	CtExecutableReferenceExpression<T,E extends CtExpression<?>>	This abstract code element defines an expression which represents an executable reference.
interface	CtTargetedExpression<T,E extends CtExpression<?>>	This abstract code element defines an expression which contains a target expression.

Subinterfaces of CtExpression in spoon.reflect.code

Modifier and Type	Interface	Description
interface	CtAnnotationFieldAccess<T>	This code element defines an access to a annotation parameter variable.
interface	CtArrayAccess<T,E extends CtExpression<?>>	This code element defines a one-dimensional array access.
interface	CtArrayRead<T>	This code element defines a read access to an array.
interface	CtArrayWrite<T>	This code element defines a write access to an array.
interface	CtAssignment<T,A extends T>	This code element defines an assignment.
interface	CtBinaryOperator<T>	This interface defines a binary operator.
interface	CtCodeSnippetExpression<T>	This element is a code snippet that must represent an expression and can thus be inserted in the program's model as is.
interface	CtConditional<T>	This code element defines conditional expressions using the ? (ternary expressions).
interface	CtConstructorCall<T>	This code element represents a constructor call.
interface	CtExecutableReferenceExpression<T,E extends CtExpression<?>>	This abstract code element defines an expression which represents an executable reference.
interface	CtFieldAccess<T>	This code element defines an access to a field variable (read and write)
interface	CtFieldRead<T>	This code element defines a read access to a field.
interface	CtFieldWrite<T>	This code element defines a write access to a field.
interface	CtInvocation<T>	This code element defines a concrete invocation.
interface	CtLambda<T>	This code element represents the creation of a lambda.
interface	CtLiteral<T>	This code element defines a literal value (an int, a string, etc).
interface	CtNewArray<T>	This code element defines the inline creation of a new array.
interface	CtNewClass<T>	This code element represents the creation of a anonymous class.
interface	CtOperatorAssignment<T,A extends T>	This code element defines an self-operated assignment such as += or *=.
interface	CtSuperAccess<T>	This code element defines an access to super.
interface	CtSwitchExpression<T,S>	This code element defines a switch expression.
interface	CtTargetedExpression<T,E extends CtExpression<?>>	This abstract code element defines an expression which contains a target expression.
interface	CtTextBlock	This code element defines a Text Block String Literal.
interface	CtThisAccess<T>	This code element defines an access to this.
interface	CtTypeAccess<A>	This code element represents a type reference usable as an expression.
interface	CtTypePattern	This code element defines a type pattern, introduced in Java 16 by JEP 394.
interface	CtUnaryOperator<T>	This code element represents a unary operator.
interface	CtVariableAccess<T>	This code element defines an access to a variable (read and write).
interface	CtVariableRead<T>	This code element defines an read access to a variable.
interface	CtVariableWrite<T>	This code element defines a write to a variable.

Methods in spoon.reflect.code with type parameters of type CtExpression

Modifier and Type	Method	Description
<C extends CtExpression<T>> C	CtExpression.addTypeCast(CtTypeReference<?> type)	Adds a type cast.
<C extends CtExpression<Void>> C	CtTypePattern.addTypeCast(CtTypeReference<?> type)
<E extends CtExpression<T>> E	CtCodeSnippetExpression.compile()	Compiles this expression snippet to produce the corresponding AST expression.
<C extends CtExpression<T>> C	CtExpression.setTypeCasts(List<CtTypeReference<?>> types)	Sets the type casts.
<C extends CtExpression<Void>> C	CtTypePattern.setTypeCasts(List<CtTypeReference<?>> types)

Methods in spoon.reflect.code that return CtExpression

Modifier and Type	Method	Description
CtExpression<T>	CtExpression.clone()
CtExpression<Boolean>	CtAssert.getAssertExpression()	Gets the assert expression.
CtExpression<T>	CtAssignment.getAssigned()	Returns the assigned expression on the left-hand side (where the value is stored, e.g.
CtExpression<T>	CtLocalVariable.getAssignment()	Useful proxy to CtVariable.getDefaultExpression().
CtExpression<A>	CtRHSReceiver.getAssignment()	Returns the right-hand side of the "=" operator.
CtExpression<S>	CtCase.getCaseExpression()	Gets the case expression.
CtExpression<Boolean>	CtConditional.getCondition()	Gets the condition expression.
CtExpression<Boolean>	CtIf.getCondition()	Gets the boolean expression that represents the if's condition.
CtExpression<T>	CtConditional.getElseExpression()	Gets the "false" expression.
CtExpression<T>	CtAssert.getExpression()	Gets the expression of the assertion if defined.
CtExpression<Boolean>	CtFor.getExpression()	Gets the end-loop test expression.
CtExpression<?>	CtForEach.getExpression()	Gets the iterated expression (an iterable of an array).
CtExpression<T>	CtLambda.getExpression()	Gets the expression in the body.
CtExpression<?>	CtSynchronized.getExpression()	Gets the expression that defines the monitored object if any.
CtExpression<?>	CtYieldStatement.getExpression()	Gets the expression of the yield statement.
CtExpression<Integer>	CtArrayAccess.getIndexExpression()	Returns the expression that defines the index.
CtExpression<?>	CtBinaryOperator.getLeftHandOperand()	Returns the left-hand operand.
CtExpression<Boolean>	CtDo.getLoopingExpression()	Returns the looping test as a boolean expression.
CtExpression<Boolean>	CtWhile.getLoopingExpression()	Gets the looping boolean test expression.
CtExpression<?>	CtUnaryOperator.getOperand()	Gets the expression to which the operator is applied.
CtExpression<R>	CtReturn.getReturnedExpression()	Gets the returned expression.
CtExpression<?>	CtBinaryOperator.getRightHandOperand()	Returns the right-hand operand.
CtExpression<S>	CtAbstractSwitch.getSelector()	Gets the selector.
CtExpression<T>	CtConditional.getThenExpression()	Gets the "true" expression.
CtExpression<? extends Throwable>	CtThrow.getThrownExpression()	Returns the thrown expression (must be a throwable).

Methods in spoon.reflect.code that return types with arguments of type CtExpression

Modifier and Type	Method	Description
List<CtExpression<?>>	CtAbstractInvocation.getArguments()	The arguments of the invocation.
List<CtExpression<S>>	CtCase.getCaseExpressions()	Gets the case expressions.
List<CtExpression<Integer>>	CtNewArray.getDimensionExpressions()	Gets the expressions that define the array's dimensions.
List<CtExpression<?>>	CtNewArray.getElements()	Gets the initialization expressions.

Methods in spoon.reflect.code with parameters of type CtExpression

Modifier and Type	Method	Description
<C extends CtAbstractInvocation<T>> C	CtAbstractInvocation.addArgument(CtExpression<?> argument)	Adds an argument expression to the invocation.
<C extends CtAbstractInvocation<T>> C	CtAbstractInvocation.addArgumentAt(int position, CtExpression<?> argument)	Adds an argument expression to the invocation at the specified position.
<T extends CtCase<S>> T	CtCase.addCaseExpression(CtExpression<S> caseExpression)	Adds case expression.
<C extends CtNewArray<T>> C	CtNewArray.addDimensionExpression(CtExpression<Integer> dimension)	Adds a dimension expression.
<C extends CtNewArray<T>> C	CtNewArray.addElement(CtExpression<?> expression)	Adds an element.
void	CtAbstractInvocation.removeArgument(CtExpression<?> argument)	Removes an argument expression from the invocation.
boolean	CtNewArray.removeDimensionExpression(CtExpression<Integer> dimension)	Removes a dimension expression.
boolean	CtNewArray.removeElement(CtExpression<?> expression)	Removes an element.
<A extends CtAssert<T>> A	CtAssert.setAssertExpression(CtExpression<Boolean> asserted)	Sets the assert expression.
<C extends CtAssignment<T, A>> C	CtAssignment.setAssigned(CtExpression<T> assigned)	Sets the assigned expression (left hand side - LHS).
<U extends CtRHSReceiver<T>> U	CtLocalVariable.setAssignment(CtExpression<T> assignment)
<T extends CtRHSReceiver<A>> T	CtRHSReceiver.setAssignment(CtExpression<A> assignment)	Sets the right-hand side expression (RHS) of the "=" operator.
<T extends CtCase<S>> T	CtCase.setCaseExpression(CtExpression<S> caseExpression)	Sets the case expression.
<C extends CtConditional<T>> C	CtConditional.setCondition(CtExpression<Boolean> condition)	Sets the condition expression.
<T extends CtIf> T	CtIf.setCondition(CtExpression<Boolean> expression)	Sets the boolean expression that represents the if's condition.
<C extends CtVariable<T>> C	CtCatchVariable.setDefaultExpression(CtExpression<T> assignedExpression)
<C extends CtConditional<T>> C	CtConditional.setElseExpression(CtExpression<T> elseExpression)	Sets the "false" expression.
<A extends CtAssert<T>> A	CtAssert.setExpression(CtExpression<T> expression)	Sets the expression of the assertion.
<T extends CtFor> T	CtFor.setExpression(CtExpression<Boolean> expression)	Sets the end-loop test expression.
<T extends CtForEach> T	CtForEach.setExpression(CtExpression<?> expression)	Sets the iterated expression (an iterable of an array).
<C extends CtLambda<T>> C	CtLambda.setExpression(CtExpression<T> expression)	Sets the expression in the body of the lambda.
<T extends CtSynchronized> T	CtSynchronized.setExpression(CtExpression<?> expression)	Sets the expression that defines the monitored.
<T extends CtYieldStatement> T	CtYieldStatement.setExpression(CtExpression<?> expression)	Gets the expression of the yield statement.
<C extends CtArrayAccess<T, E>> C	CtArrayAccess.setIndexExpression(CtExpression<Integer> expression)	Sets the expression that defines the index.
<C extends CtBinaryOperator<T>> C	CtBinaryOperator.setLeftHandOperand(CtExpression<?> expression)	Sets the left-hand operand.
<T extends CtDo> T	CtDo.setLoopingExpression(CtExpression<Boolean> expression)	Sets the looping test as a boolean expression.
<T extends CtWhile> T	CtWhile.setLoopingExpression(CtExpression<Boolean> expression)	Sets the looping boolean test expression.
<C extends CtUnaryOperator> C	CtUnaryOperator.setOperand(CtExpression<?> expression)	Sets the expression to which the operator is applied.
<T extends CtReturn<R>> T	CtReturn.setReturnedExpression(CtExpression<R> returnedExpression)	Sets the returned expression.
<C extends CtBinaryOperator<T>> C	CtBinaryOperator.setRightHandOperand(CtExpression<?> expression)	Sets the right-hand operand.
<T extends CtAbstractSwitch<S>> T	CtAbstractSwitch.setSelector(CtExpression<S> selector)	Sets the selector.
<C extends CtConditional<T>> C	CtConditional.setThenExpression(CtExpression<T> thenExpression)	Sets the "true" expression.
<T extends CtThrow> T	CtThrow.setThrownExpression(CtExpression<? extends Throwable> thrownExpression)	Sets the thrown expression (must be a throwable).

Method parameters in spoon.reflect.code with type arguments of type CtExpression

Modifier and Type	Method	Description
<C extends CtAbstractInvocation<T>> C	CtAbstractInvocation.setArguments(List<CtExpression<?>> arguments)	Sets the invocation's arguments.
<T extends CtCase<S>> T	CtCase.setCaseExpressions(List<CtExpression<S>> caseExpressions)	Sets the case expressions.
<C extends CtNewArray<T>> C	CtNewArray.setDimensionExpressions(List<CtExpression<Integer>> dimensions)	Sets the expressions that define the array's dimensions.
<C extends CtNewArray<T>> C	CtNewArray.setElements(List<CtExpression<?>> expression)	Sets the initialization expressions.

Uses of CtExpression in spoon.reflect.declaration

Subinterfaces of CtExpression in spoon.reflect.declaration

Modifier and Type	Interface	Description
interface	CtAnnotation<A extends Annotation>	This element represents an annotation on an element.

Methods in spoon.reflect.declaration with type parameters of type CtExpression

Modifier and Type	Method	Description
<T extends CtExpression> T	CtAnnotation.getValue(String key)	Gets a value, as a CtExpression, for a given key without any conversion.
<T extends CtExpression> T	CtAnnotation.getWrappedValue(String key)	Gets a value for a given key and try to fix its type based on the annotation type.
<C extends CtExpression<A>> C	CtAnnotation.setTypeCasts(List<CtTypeReference<?>> types)

Methods in spoon.reflect.declaration that return CtExpression

Modifier and Type	Method	Description
CtExpression<T>	CtField.getAssignment()	Useful proxy to CtVariable.getDefaultExpression().
CtExpression<T>	CtAnnotationMethod.getDefaultExpression()	Gets the default expression assigned to the annotation method.
CtExpression<T>	CtVariable.getDefaultExpression()	Gets the initialization expression assigned to the variable (also known as the initializer), when declared.

Methods in spoon.reflect.declaration that return types with arguments of type CtExpression

Modifier and Type	Method	Description
Map<String,CtExpression>	CtAnnotation.getAllValues()	Get all values of CtAnnotation.getValues(), plus the default ones defined in the annotation type.
Map<String,CtExpression>	CtAnnotation.getValues()	Returns this annotation's elements and their values.

Methods in spoon.reflect.declaration with parameters of type CtExpression

Modifier and Type	Method	Description
<U extends CtRHSReceiver<T>> U	CtEnumValue.setAssignment(CtExpression<T> assignment)
<U extends CtRHSReceiver<T>> U	CtField.setAssignment(CtExpression<T> assignment)
<C extends CtAnnotationMethod<T>> C	CtAnnotationMethod.setDefaultExpression(CtExpression<T> assignedExpression)	Sets the default expression assigned to the annotation method.
<C extends CtVariable<T>> C	CtParameter.setDefaultExpression(CtExpression<T> assignedExpression)
<C extends CtVariable<T>> C	CtVariable.setDefaultExpression(CtExpression<T> assignedExpression)	Sets the initialization expression assigned to the variable, when declared.

Method parameters in spoon.reflect.declaration with type arguments of type CtExpression

Modifier and Type	Method	Description
<T extends CtAnnotation<A>> T	CtAnnotation.addValue(String elementName, CtNewArray<? extends CtExpression> value)	Adds a new key-array pair for this annotation.
<T extends CtAnnotation<A>> T	CtAnnotation.setValues(Map<String,CtExpression> values)	Set's this annotation's element names and their values.

Uses of CtExpression in spoon.reflect.factory

Methods in spoon.reflect.factory with type parameters of type CtExpression

Modifier and Type	Method	Description
<T, E extends CtExpression<?>> CtExecutableReferenceExpression<T,E>	CoreFactory.createExecutableReferenceExpression()	Creates a new executable reference expression.
<T, E extends CtExpression<?>> CtExecutableReferenceExpression<T,E>	Factory.createExecutableReferenceExpression()
<T, E extends CtExpression<?>> CtExecutableReferenceExpression<T,E>	FactoryImpl.createExecutableReferenceExpression()

Methods in spoon.reflect.factory that return types with arguments of type CtExpression

Modifier and Type	Method	Description
List<CtExpression<?>>	CodeFactory.createVariableReads(List<? extends CtVariable<?>> variables)	Creates a list of variable accesses for read.
List<CtExpression<?>>	Factory.createVariableReads(List<? extends CtVariable<?>> variables)
List<CtExpression<?>>	FactoryImpl.createVariableReads(List<? extends CtVariable<?>> variables)

Methods in spoon.reflect.factory with parameters of type CtExpression

Modifier and Type	Method	Description
<T> CtField<T>	FieldFactory.create(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference<T> type, String name, CtExpression<T> defaultExpression)	Creates a field.
<T> CtBinaryOperator<T>	CodeFactory.createBinaryOperator(CtExpression<?> left, CtExpression<?> right, BinaryOperatorKind kind)	Creates a binary operator.
<T> CtBinaryOperator<T>	Factory.createBinaryOperator(CtExpression<?> left, CtExpression<?> right, BinaryOperatorKind kind)
<T> CtBinaryOperator<T>	FactoryImpl.createBinaryOperator(CtExpression<?> left, CtExpression<?> right, BinaryOperatorKind kind)
<T> CtConstructorCall<T>	CodeFactory.createConstructorCall(CtTypeReference<T> type, CtExpression<?>... parameters)	Creates a constructor call.
<T> CtConstructorCall<T>	Factory.createConstructorCall(CtTypeReference<T> type, CtExpression<?>... parameters)
<T> CtConstructorCall<T>	FactoryImpl.createConstructorCall(CtTypeReference<T> type, CtExpression<?>... parameters)
CtField	Factory.createField(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference type, String name, CtExpression defaultExpression)
CtField	FactoryImpl.createField(CtType<?> target, Set<ModifierKind> modifiers, CtTypeReference type, String name, CtExpression defaultExpression)
<T> CtInvocation<T>	CodeFactory.createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, List<CtExpression<?>> arguments)	Creates an invocation (can be a statement or an expression).
<T> CtInvocation<T>	CodeFactory.createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, CtExpression<?>... arguments)	Creates an invocation (can be a statement or an expression).
<T> CtInvocation<T>	Factory.createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, List<CtExpression<?>> arguments)
<T> CtInvocation<T>	Factory.createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, CtExpression<?>... arguments)
<T> CtInvocation<T>	FactoryImpl.createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, List<CtExpression<?>> arguments)
<T> CtInvocation<T>	FactoryImpl.createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, CtExpression<?>... arguments)
<T> CtLocalVariable<T>	CodeFactory.createLocalVariable(CtTypeReference<T> type, String name, CtExpression<T> defaultExpression)	Creates a local variable declaration.
<T> CtLocalVariable<T>	Factory.createLocalVariable(CtTypeReference<T> type, String name, CtExpression<T> defaultExpression)
<T> CtLocalVariable<T>	FactoryImpl.createLocalVariable(CtTypeReference<T> type, String name, CtExpression<T> defaultExpression)
<T> CtNewClass<T>	CodeFactory.createNewClass(CtType<T> superClass, CtExpression<?>... parameters)	Creates a new anonymous class.
CtNewClass<?>	Factory.createNewClass(CtType<?> superClass, CtExpression<?>... parameters)	Creates an anonymous class
CtNewClass<?>	FactoryImpl.createNewClass(CtType<?> superClass, CtExpression<?>... parameters)
<T> CtExecutableReference<T>	ConstructorFactory.createReference(CtTypeReference<T> type, CtExpression<?>... parameters)	Creates a constructor reference.
<A, T extends A> CtAssignment<A,T>	CodeFactory.createVariableAssignment(CtVariableReference<A> variable, boolean isStatic, CtExpression<T> expression)	Creates a variable assignment (can be an expression or a statement).
<A, T extends A> CtAssignment<A,T>	Factory.createVariableAssignment(CtVariableReference<A> variable, boolean isStatic, CtExpression<T> expression)
<A, T extends A> CtAssignment<A,T>	FactoryImpl.createVariableAssignment(CtVariableReference<A> variable, boolean isStatic, CtExpression<T> expression)

Method parameters in spoon.reflect.factory with type arguments of type CtExpression

Modifier and Type	Method	Description
<T> CtInvocation<T>	CodeFactory.createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, List<CtExpression<?>> arguments)	Creates an invocation (can be a statement or an expression).
<T> CtInvocation<T>	Factory.createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, List<CtExpression<?>> arguments)
<T> CtInvocation<T>	FactoryImpl.createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, List<CtExpression<?>> arguments)

Uses of CtExpression in spoon.reflect.visitor

Methods in spoon.reflect.visitor with type parameters of type CtExpression

Modifier and Type	Method	Description
<T, E extends CtExpression<?>> void	CtInheritanceScanner.scanCtArrayAccess(CtArrayAccess<T,E> arrayAccess)	Scans an array access (read and write).
<T, E extends CtExpression<?>> void	CtInheritanceScanner.scanCtTargetedExpression(CtTargetedExpression<T,E> targetedExpression)	Scans an abstract targeted expression.
<T, E extends CtExpression<?>> void	CtAbstractVisitor.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression)
<T, E extends CtExpression<?>> void	CtBiScannerDefault.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression)
<T, E extends CtExpression<?>> void	CtInheritanceScanner.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> e)
<T, E extends CtExpression<?>> void	CtScanner.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression)
<T, E extends CtExpression<?>> void	CtVisitor.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression)	Visits a reference to an executable.
<T, E extends CtExpression<?>> void	DefaultJavaPrettyPrinter.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression)

Methods in spoon.reflect.visitor with parameters of type CtExpression

Modifier and Type	Method	Description
protected void	DefaultJavaPrettyPrinter.enterCtExpression(CtExpression<?> e)	Enters an expression.
protected void	DefaultJavaPrettyPrinter.exitCtExpression(CtExpression<?> e)	Exits an expression.
static Optional<CtTypeReference<?>>	OperatorHelper.getPromotedType(BinaryOperatorKind operator, CtExpression<?> left, CtExpression<?> right)	Get the promoted type of the binary operator, as defined by the Java Language Specification.
static Optional<CtTypeReference<?>>	OperatorHelper.getPromotedType(UnaryOperatorKind operator, CtExpression<?> operand)	Gets the promoted type of the unary operator, as defined by the Java Language Specification.
<T> void	CtInheritanceScanner.scanCtExpression(CtExpression<T> expression)	Scans an abstract expression.

Uses of CtExpression in spoon.support

Methods in spoon.support with type parameters of type CtExpression

Modifier and Type	Method	Description
<T, E extends CtExpression<?>> CtExecutableReferenceExpression<T,E>	DefaultCoreFactory.createExecutableReferenceExpression()

Uses of CtExpression in spoon.support.compiler

Methods in spoon.support.compiler that return CtExpression

Modifier and Type	Method	Description
static <T> CtExpression<T>	SnippetCompilationHelper.compileExpression(CtCodeSnippetExpression<T> expr)

Uses of CtExpression in spoon.support.compiler.jdt

Methods in spoon.support.compiler.jdt with type parameters of type CtExpression

Modifier and Type	Method	Description
<T, E extends CtExpression<?>> void	ParentExiter.scanCtTargetedExpression(CtTargetedExpression<T,E> targetedExpression)
<T, E extends CtExpression<?>> void	ParentExiter.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression)

Methods in spoon.support.compiler.jdt with parameters of type CtExpression

Modifier and Type	Method	Description
<T> CtFieldAccess<T>	JDTTreeBuilderHelper.createFieldAccess(CtVariableReference<T> variableReference, CtExpression<?> target, boolean isReadAccess)	Creates variable access from a CtVariableReference.

Uses of CtExpression in spoon.support.reflect.code

Classes in spoon.support.reflect.code with type parameters of type CtExpression

Modifier and Type	Class	Description
class	CtArrayAccessImpl<T,V extends CtExpression<?>>
class	CtExecutableReferenceExpressionImpl<T,E extends CtExpression<?>>
class	CtTargetedExpressionImpl<E,T extends CtExpression<?>>

Classes in spoon.support.reflect.code that implement CtExpression

Modifier and Type	Class	Description
class	CtAnnotationFieldAccessImpl<T>
class	CtArrayAccessImpl<T,V extends CtExpression<?>>
class	CtArrayReadImpl<T>
class	CtArrayWriteImpl<T>
class	CtAssignmentImpl<T,A extends T>
class	CtBinaryOperatorImpl<T>
class	CtCodeSnippetExpressionImpl<T>
class	CtConditionalImpl<T>
class	CtConstructorCallImpl<T>
class	CtExecutableReferenceExpressionImpl<T,E extends CtExpression<?>>
class	CtExpressionImpl<T>
class	CtFieldAccessImpl<T>
class	CtFieldReadImpl<T>
class	CtFieldWriteImpl<T>
class	CtInvocationImpl<T>
class	CtLambdaImpl<T>
class	CtLiteralImpl<T>
class	CtNewArrayImpl<T>
class	CtNewClassImpl<T>
class	CtOperatorAssignmentImpl<T,A extends T>
class	CtSuperAccessImpl<T>
class	CtSwitchExpressionImpl<T,S>
class	CtTargetedExpressionImpl<E,T extends CtExpression<?>>
class	CtTextBlockImpl
class	CtThisAccessImpl<T>
class	CtTypeAccessImpl<A>
class	CtTypePatternImpl
class	CtUnaryOperatorImpl<T>
class	CtVariableAccessImpl<T>
class	CtVariableReadImpl<T>
class	CtVariableWriteImpl<T>

Methods in spoon.support.reflect.code with type parameters of type CtExpression

Modifier and Type	Method	Description
<C extends CtExpression<T>> C	CtAssignmentImpl.addTypeCast(CtTypeReference<?> type)
<C extends CtExpression<T>> C	CtExpressionImpl.addTypeCast(CtTypeReference<?> type)
<E extends CtExpression<T>> E	CtCodeSnippetExpressionImpl.compile()
<C extends CtTargetedExpression<T, CtExpression<?>>> C	CtFieldAccessImpl.setTarget(CtExpression<?> target)
<C extends CtTargetedExpression<T, CtExpression<?>>> C	CtSuperAccessImpl.setTarget(CtExpression<?> target)
<C extends CtExpression<T>> C	CtAssignmentImpl.setTypeCasts(List<CtTypeReference<?>> casts)
<C extends CtExpression<T>> C	CtExpressionImpl.setTypeCasts(List<CtTypeReference<?>> casts)

Methods in spoon.support.reflect.code that return CtExpression

Modifier and Type	Method	Description
CtExpression<T>	CtExpressionImpl.clone()
CtExpression<Boolean>	CtAssertImpl.getAssertExpression()
CtExpression<T>	CtAssignmentImpl.getAssigned()
CtExpression<A>	CtAssignmentImpl.getAssignment()
CtExpression<T>	CtLocalVariableImpl.getAssignment()
CtExpression<E>	CtCaseImpl.getCaseExpression()
CtExpression<Boolean>	CtConditionalImpl.getCondition()
CtExpression<Boolean>	CtIfImpl.getCondition()
CtExpression<T>	CtCatchVariableImpl.getDefaultExpression()
CtExpression<T>	CtLocalVariableImpl.getDefaultExpression()
CtExpression<T>	CtConditionalImpl.getElseExpression()
CtExpression<T>	CtAssertImpl.getExpression()
CtExpression<?>	CtForEachImpl.getExpression()
CtExpression<Boolean>	CtForImpl.getExpression()
CtExpression<T>	CtLambdaImpl.getExpression()
CtExpression<?>	CtSynchronizedImpl.getExpression()
CtExpression<?>	CtYieldStatementImpl.getExpression()
CtExpression<Integer>	CtArrayAccessImpl.getIndexExpression()
CtExpression<?>	CtBinaryOperatorImpl.getLeftHandOperand()
CtExpression<Boolean>	CtDoImpl.getLoopingExpression()
CtExpression<Boolean>	CtWhileImpl.getLoopingExpression()
CtExpression<?>	CtUnaryOperatorImpl.getOperand()
CtExpression<R>	CtReturnImpl.getReturnedExpression()
CtExpression<?>	CtBinaryOperatorImpl.getRightHandOperand()
CtExpression<S>	CtSwitchExpressionImpl.getSelector()
CtExpression<S>	CtSwitchImpl.getSelector()
CtExpression<?>	CtFieldAccessImpl.getTarget()
CtExpression<?>	CtSuperAccessImpl.getTarget()
CtExpression<T>	CtConditionalImpl.getThenExpression()
CtExpression<? extends Throwable>	CtThrowImpl.getThrownExpression()

Methods in spoon.support.reflect.code that return types with arguments of type CtExpression

Modifier and Type	Method	Description
List<CtExpression<?>>	CtConstructorCallImpl.getArguments()
List<CtExpression<?>>	CtInvocationImpl.getArguments()
List<CtExpression<E>>	CtCaseImpl.getCaseExpressions()
List<CtExpression<Integer>>	CtNewArrayImpl.getDimensionExpressions()
List<CtExpression<?>>	CtNewArrayImpl.getElements()

Methods in spoon.support.reflect.code with parameters of type CtExpression

Modifier and Type	Method	Description
<C extends CtAbstractInvocation<T>> C	CtConstructorCallImpl.addArgument(CtExpression<?> argument)
<C extends CtAbstractInvocation<T>> C	CtInvocationImpl.addArgument(CtExpression<?> argument)
<C extends CtAbstractInvocation<T>> C	CtConstructorCallImpl.addArgumentAt(int position, CtExpression<?> argument)
<C extends CtAbstractInvocation<T>> C	CtInvocationImpl.addArgumentAt(int position, CtExpression<?> argument)
<T extends CtCase<E>> T	CtCaseImpl.addCaseExpression(CtExpression<E> caseExpression)
<C extends CtNewArray<T>> C	CtNewArrayImpl.addDimensionExpression(CtExpression<Integer> dimension)
<C extends CtNewArray<T>> C	CtNewArrayImpl.addElement(CtExpression<?> expression)
void	CtConstructorCallImpl.removeArgument(CtExpression<?> argument)
void	CtInvocationImpl.removeArgument(CtExpression<?> argument)
boolean	CtNewArrayImpl.removeDimensionExpression(CtExpression<Integer> dimension)
boolean	CtNewArrayImpl.removeElement(CtExpression<?> expression)
<A extends CtAssert<T>> A	CtAssertImpl.setAssertExpression(CtExpression<Boolean> asserted)
<C extends CtAssignment<T, A>> C	CtAssignmentImpl.setAssigned(CtExpression<T> assigned)
<C extends CtRHSReceiver<A>> C	CtAssignmentImpl.setAssignment(CtExpression<A> assignment)
<C extends CtRHSReceiver<T>> C	CtLocalVariableImpl.setAssignment(CtExpression<T> assignment)
<T extends CtCase<E>> T	CtCaseImpl.setCaseExpression(CtExpression<E> caseExpression)
<C extends CtConditional<T>> C	CtConditionalImpl.setCondition(CtExpression<Boolean> condition)
<T extends CtIf> T	CtIfImpl.setCondition(CtExpression<Boolean> condition)
<C extends CtVariable<T>> C	CtCatchVariableImpl.setDefaultExpression(CtExpression<T> defaultExpression)
<C extends CtVariable<T>> C	CtLocalVariableImpl.setDefaultExpression(CtExpression<T> defaultExpression)
<C extends CtConditional<T>> C	CtConditionalImpl.setElseExpression(CtExpression<T> elseExpression)
<A extends CtAssert<T>> A	CtAssertImpl.setExpression(CtExpression<T> value)
<T extends CtForEach> T	CtForEachImpl.setExpression(CtExpression<?> expression)
<T extends CtFor> T	CtForImpl.setExpression(CtExpression<Boolean> expression)
<C extends CtLambda<T>> C	CtLambdaImpl.setExpression(CtExpression<T> expression)
<T extends CtSynchronized> T	CtSynchronizedImpl.setExpression(CtExpression<?> expression)
<T extends CtYieldStatement> T	CtYieldStatementImpl.setExpression(CtExpression<?> expression)
<C extends CtArrayAccess<T, V>> C	CtArrayAccessImpl.setIndexExpression(CtExpression<Integer> expression)
<C extends CtBinaryOperator<T>> C	CtBinaryOperatorImpl.setLeftHandOperand(CtExpression<?> expression)
<T extends CtDo> T	CtDoImpl.setLoopingExpression(CtExpression<Boolean> expression)
<T extends CtWhile> T	CtWhileImpl.setLoopingExpression(CtExpression<Boolean> expression)
<C extends CtUnaryOperator> C	CtUnaryOperatorImpl.setOperand(CtExpression<?> expression)
<T extends CtReturn<R>> T	CtReturnImpl.setReturnedExpression(CtExpression<R> expression)
<C extends CtBinaryOperator<T>> C	CtBinaryOperatorImpl.setRightHandOperand(CtExpression<?> expression)
<T extends CtAbstractSwitch<S>> T	CtSwitchExpressionImpl.setSelector(CtExpression<S> selector)
<T extends CtAbstractSwitch<S>> T	CtSwitchImpl.setSelector(CtExpression<S> selector)
<C extends CtTargetedExpression<T, CtExpression<?>>> C	CtFieldAccessImpl.setTarget(CtExpression<?> target)
<C extends CtTargetedExpression<T, CtExpression<?>>> C	CtSuperAccessImpl.setTarget(CtExpression<?> target)
<C extends CtConditional<T>> C	CtConditionalImpl.setThenExpression(CtExpression<T> thenExpression)
<T extends CtThrow> T	CtThrowImpl.setThrownExpression(CtExpression<? extends Throwable> expression)

Method parameters in spoon.support.reflect.code with type arguments of type CtExpression

Modifier and Type	Method	Description
<C extends CtAbstractInvocation<T>> C	CtConstructorCallImpl.setArguments(List<CtExpression<?>> arguments)
<C extends CtAbstractInvocation<T>> C	CtInvocationImpl.setArguments(List<CtExpression<?>> arguments)
<T extends CtCase<E>> T	CtCaseImpl.setCaseExpressions(List<CtExpression<E>> caseExpressions)
<C extends CtNewArray<T>> C	CtNewArrayImpl.setDimensionExpressions(List<CtExpression<Integer>> dimensionExpressions)
<C extends CtNewArray<T>> C	CtNewArrayImpl.setElements(List<CtExpression<?>> expressions)

Uses of CtExpression in spoon.support.reflect.declaration

Classes in spoon.support.reflect.declaration that implement CtExpression

Modifier and Type	Class	Description
class	CtAnnotationImpl<A extends Annotation>	The implementation for CtAnnotation.

Methods in spoon.support.reflect.declaration with type parameters of type CtExpression

Modifier and Type	Method	Description
<T extends CtExpression> T	CtAnnotationImpl.getValue(String key)
<T extends CtExpression> T	CtAnnotationImpl.getWrappedValue(String key)
<C extends CtExpression<A>> C	CtAnnotationImpl.setTypeCasts(List<CtTypeReference<?>> casts)

Methods in spoon.support.reflect.declaration that return CtExpression

Modifier and Type	Method	Description
CtExpression<T>	CtEnumValueImpl.getAssignment()
CtExpression<T>	CtFieldImpl.getAssignment()
CtExpression<T>	CtAnnotationMethodImpl.getDefaultExpression()
CtExpression<T>	CtFieldImpl.getDefaultExpression()
CtExpression<T>	CtParameterImpl.getDefaultExpression()

Methods in spoon.support.reflect.declaration that return types with arguments of type CtExpression

Modifier and Type	Method	Description
Map<String,CtExpression>	CtAnnotationImpl.getAllValues()
Map<String,CtExpression>	CtAnnotationImpl.getValues()

Methods in spoon.support.reflect.declaration with parameters of type CtExpression

Modifier and Type	Method	Description
<C extends CtRHSReceiver<T>> C	CtFieldImpl.setAssignment(CtExpression<T> assignment)
<C extends CtAnnotationMethod<T>> C	CtAnnotationMethodImpl.setDefaultExpression(CtExpression<T> assignedExpression)
<C extends CtVariable<T>> C	CtFieldImpl.setDefaultExpression(CtExpression<T> defaultExpression)
<C extends CtVariable<T>> C	CtParameterImpl.setDefaultExpression(CtExpression<T> defaultExpression)

Method parameters in spoon.support.reflect.declaration with type arguments of type CtExpression

Modifier and Type	Method	Description
<T extends CtAnnotation<A>> T	CtAnnotationImpl.addValue(String elementName, CtNewArray<? extends CtExpression> value)
<T extends CtAnnotation<A>> T	CtAnnotationImpl.setValues(Map<String,CtExpression> values)

Uses of CtExpression in spoon.support.reflect.eval

Methods in spoon.support.reflect.eval with parameters of type CtExpression

Modifier and Type	Method	Description
static Object	EvalHelper.getCorrespondingRuntimeObject(CtExpression<?> value)	Returns the runtime object corresponding to the expression eg CtLiteral(3) -> 3
static boolean	EvalHelper.isKnownAtCompileTime(CtExpression<?> exp)	returns true if the expression is known at compile time Bonus method for @oscarlvp :-)

Uses of CtExpression in spoon.support.template

Methods in spoon.support.template with parameters of type CtExpression

Modifier and Type	Method	Description
static Integer	Parameters.getIndex(CtExpression<?> e)	Gets the index of a one-dimension array (helper).

Uses of CtExpression in spoon.support.visitor.clone

Methods in spoon.support.visitor.clone with type parameters of type CtExpression

Modifier and Type	Method	Description
<T, E extends CtExpression<?>> void	CloneVisitor.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression)

Uses of CtExpression in spoon.support.visitor.replace

Methods in spoon.support.visitor.replace with type parameters of type CtExpression

Modifier and Type	Method	Description
<T, E extends CtExpression<?>> void	ReplacementVisitor.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression)

Uses of CtExpression in spoon.template

Methods in spoon.template that return CtExpression

Modifier and Type	Method	Description
CtExpression<T>	ExpressionTemplate.apply(CtType<?> targetType)
static <T> CtExpression<T>	ExpressionTemplate.getExpression(CtClass<? extends ExpressionTemplate<?>> p)	Returns the expression.
static CtExpression<?>	Substitution.substituteFieldDefaultExpression(CtType<?> targetType, Template<?> template, String fieldName)	Gets a default expression from a template field with all the template parameters substituted.