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 and 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 and 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 and 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	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 and Description
<C extends CtExpression<T>> C	CtExpression.addTypeCast(CtTypeReference<?> type) Adds a type cast.
<E extends CtExpression<T>> E	CtCodeSnippetExpression.compile() Compiles this expression snippet to produce the corresponding AST expression.
<C extends CtExpression<T>> C	CtExpression.setTypeCasts(java.util.List<CtTypeReference<?>> types) Sets the type casts.

Methods in spoon.reflect.code that return CtExpression

Modifier and Type	Method and Description
CtExpression<T>	CtExpression.clone()
CtExpression<java.lang.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<java.lang.Boolean>	CtIf.getCondition() Gets the boolean expression that represents the if's condition.
CtExpression<java.lang.Boolean>	CtConditional.getCondition() Gets the condition expression.
CtExpression<T>	CtConditional.getElseExpression() Gets the "false" expression.
CtExpression<T>	CtAssert.getExpression() Gets the expression of the assertion if defined.
CtExpression<java.lang.Boolean>	CtFor.getExpression() Gets the end-loop test expression.
CtExpression<?>	CtSynchronized.getExpression() Gets the expression that defines the monitored object if any.
CtExpression<?>	CtYieldStatement.getExpression() Gets the expression of the yield statement.
CtExpression<?>	CtForEach.getExpression() Gets the iterated expression (an iterable of an array).
CtExpression<T>	CtLambda.getExpression() Gets the expression in the body.
CtExpression<java.lang.Integer>	CtArrayAccess.getIndexExpression() Returns the expression that defines the index.
CtExpression<?>	CtBinaryOperator.getLeftHandOperand() Returns the left-hand operand.
CtExpression<java.lang.Boolean>	CtDo.getLoopingExpression() Returns the looping test as a boolean expression.
CtExpression<java.lang.Boolean>	CtWhile.getLoopingExpression() Gets the looping boolean test expression.
CtExpression<T>	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 java.lang.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 and Description
java.util.List<CtExpression<?>>	CtAbstractInvocation.getArguments() The arguments of the invocation.
java.util.List<CtExpression<S>>	CtCase.getCaseExpressions() Gets the case expressions.
java.util.List<CtExpression<java.lang.Integer>>	CtNewArray.getDimensionExpressions() Gets the expressions that define the array's dimensions.
java.util.List<CtExpression<?>>	CtNewArray.getElements() Gets the initialization expressions.

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

Modifier and Type	Method and Description
<C extends CtAbstractInvocation<T>> C	CtAbstractInvocation.addArgument(CtExpression<?> argument) Adds an argument expression to the invocation.
<T extends CtCase<S>> T	CtCase.addCaseExpression(CtExpression<S> caseExpression) Adds case expression.
<C extends CtNewArray<T>> C	CtNewArray.addDimensionExpression(CtExpression<java.lang.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<java.lang.Integer> dimension) Removes a dimension expression.
boolean	CtNewArray.removeElement(CtExpression<?> expression) Removes an element.
<A extends CtAssert<T>> A	CtAssert.setAssertExpression(CtExpression<java.lang.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).
<T extends CtRHSReceiver<A>> T	CtRHSReceiver.setAssignment(CtExpression<A> assignment) Sets the right-hand side expression (RHS) of the "=" operator.
<U extends CtRHSReceiver<T>> U	CtLocalVariable.setAssignment(CtExpression<T> assignment)
<T extends CtCase<S>> T	CtCase.setCaseExpression(CtExpression<S> caseExpression) Sets the case expression.
<C extends CtConditional<T>> C	CtConditional.setCondition(CtExpression<java.lang.Boolean> condition) Sets the condition expression.
<T extends CtIf> T	CtIf.setCondition(CtExpression<java.lang.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.
<T extends CtForEach> T	CtForEach.setExpression(CtExpression<?> expression) Sets the iterated expression (an iterable of an array).
<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.
<T extends CtFor> T	CtFor.setExpression(CtExpression<java.lang.Boolean> expression) Sets the end-loop test expression.
<A extends CtAssert<T>> A	CtAssert.setExpression(CtExpression<T> expression) Sets the expression of the assertion.
<C extends CtLambda<T>> C	CtLambda.setExpression(CtExpression<T> expression) Sets the expression in the body of the lambda.
<C extends CtArrayAccess<T,E>> C	CtArrayAccess.setIndexExpression(CtExpression<java.lang.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<java.lang.Boolean> expression) Sets the looping test as a boolean expression.
<T extends CtWhile> T	CtWhile.setLoopingExpression(CtExpression<java.lang.Boolean> expression) Sets the looping boolean test expression.
<C extends CtUnaryOperator> C	CtUnaryOperator.setOperand(CtExpression<T> 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 java.lang.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 and Description
<C extends CtAbstractInvocation<T>> C	CtAbstractInvocation.setArguments(java.util.List<CtExpression<?>> arguments) Sets the invocation's arguments.
<T extends CtCase<S>> T	CtCase.setCaseExpressions(java.util.List<CtExpression<S>> caseExpressions) Sets the case expressions.
<C extends CtNewArray<T>> C	CtNewArray.setDimensionExpressions(java.util.List<CtExpression<java.lang.Integer>> dimensions) Sets the expressions that define the array's dimensions.
<C extends CtNewArray<T>> C	CtNewArray.setElements(java.util.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 and Description
interface	CtAnnotation<A extends java.lang.annotation.Annotation> This element represents an annotation on an element.

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

Modifier and Type	Method and Description
<T extends CtExpression> T	CtAnnotation.getValue(java.lang.String key) Gets a value, as a CtExpression, for a given key without any conversion.
<T extends CtExpression> T	CtAnnotation.getWrappedValue(java.lang.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(java.util.List<CtTypeReference<?>> types)

Methods in spoon.reflect.declaration that return CtExpression

Modifier and Type	Method and 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 and Description
java.util.Map<java.lang.String,CtExpression>	CtAnnotation.getAllValues() Get all values of CtAnnotation.getValues(), plus the default ones defined in the annotation type.
java.util.Map<java.lang.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 and 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 and Description
<T extends CtAnnotation<A>> T	CtAnnotation.addValue(java.lang.String elementName, CtNewArray<? extends CtExpression> value) Adds a new key-array pair for this annotation.
<T extends CtAnnotation<A>> T	CtAnnotation.setValues(java.util.Map<java.lang.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 and Description
<T,E extends CtExpression<?>> CtExecutableReferenceExpression<T,E>	Factory.createExecutableReferenceExpression()
<T,E extends CtExpression<?>> CtExecutableReferenceExpression<T,E>	CoreFactory.createExecutableReferenceExpression() Creates a new executable reference expression.
<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 and Description
java.util.List<CtExpression<?>>	Factory.createVariableReads(java.util.List<? extends CtVariable<?>> variables)
java.util.List<CtExpression<?>>	CodeFactory.createVariableReads(java.util.List<? extends CtVariable<?>> variables) Creates a list of variable accesses for read.
java.util.List<CtExpression<?>>	FactoryImpl.createVariableReads(java.util.List<? extends CtVariable<?>> variables)

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

Modifier and Type	Method and Description
<T> CtField<T>	FieldFactory.create(CtType<?> target, java.util.Set<ModifierKind> modifiers, CtTypeReference<T> type, java.lang.String name, CtExpression<T> defaultExpression) Creates a field.
<T> CtBinaryOperator<T>	Factory.createBinaryOperator(CtExpression<?> left, CtExpression<?> right, BinaryOperatorKind kind)
<T> CtBinaryOperator<T>	Factory.createBinaryOperator(CtExpression<?> left, CtExpression<?> right, BinaryOperatorKind kind)
<T> CtBinaryOperator<T>	CodeFactory.createBinaryOperator(CtExpression<?> left, CtExpression<?> right, BinaryOperatorKind kind) Creates a binary operator.
<T> CtBinaryOperator<T>	CodeFactory.createBinaryOperator(CtExpression<?> left, CtExpression<?> right, BinaryOperatorKind kind) Creates a binary operator.
<T> CtBinaryOperator<T>	FactoryImpl.createBinaryOperator(CtExpression<?> left, CtExpression<?> right, BinaryOperatorKind kind)
<T> CtBinaryOperator<T>	FactoryImpl.createBinaryOperator(CtExpression<?> left, CtExpression<?> right, BinaryOperatorKind kind)
<T> CtConstructorCall<T>	Factory.createConstructorCall(CtTypeReference<T> type, CtExpression<?>... parameters)
<T> CtConstructorCall<T>	CodeFactory.createConstructorCall(CtTypeReference<T> type, CtExpression<?>... parameters) Creates a constructor call.
<T> CtConstructorCall<T>	FactoryImpl.createConstructorCall(CtTypeReference<T> type, CtExpression<?>... parameters)
CtField	Factory.createField(CtType<?> target, java.util.Set<ModifierKind> modifiers, CtTypeReference type, java.lang.String name, CtExpression defaultExpression)
CtField	FactoryImpl.createField(CtType<?> target, java.util.Set<ModifierKind> modifiers, CtTypeReference type, java.lang.String name, CtExpression defaultExpression)
<T> CtInvocation<T>	Factory.createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, CtExpression<?>... arguments)
<T> CtInvocation<T>	Factory.createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, CtExpression<?>... arguments)
<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>	CodeFactory.createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, CtExpression<?>... arguments) Creates an invocation (can be a statement or an expression).
<T> CtInvocation<T>	FactoryImpl.createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, CtExpression<?>... arguments)
<T> CtInvocation<T>	FactoryImpl.createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, CtExpression<?>... arguments)
<T> CtInvocation<T>	Factory.createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, java.util.List<CtExpression<?>> arguments)
<T> CtInvocation<T>	CodeFactory.createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, java.util.List<CtExpression<?>> arguments) Creates an invocation (can be a statement or an expression).
<T> CtInvocation<T>	FactoryImpl.createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, java.util.List<CtExpression<?>> arguments)
<T> CtLocalVariable<T>	Factory.createLocalVariable(CtTypeReference<T> type, java.lang.String name, CtExpression<T> defaultExpression)
<T> CtLocalVariable<T>	CodeFactory.createLocalVariable(CtTypeReference<T> type, java.lang.String name, CtExpression<T> defaultExpression) Creates a local variable declaration.
<T> CtLocalVariable<T>	FactoryImpl.createLocalVariable(CtTypeReference<T> type, java.lang.String name, CtExpression<T> defaultExpression)
CtNewClass<?>	Factory.createNewClass(CtType<?> superClass, CtExpression<?>... parameters) Creates an anonymous class
CtNewClass<?>	FactoryImpl.createNewClass(CtType<?> superClass, CtExpression<?>... parameters)
<T> CtNewClass<T>	CodeFactory.createNewClass(CtType<T> superClass, CtExpression<?>... parameters) Creates a new anonymous class.
<T> CtExecutableReference<T>	ConstructorFactory.createReference(CtTypeReference<T> type, CtExpression<?>... parameters) Creates a constructor reference.
<A,T extends A> CtAssignment<A,T>	Factory.createVariableAssignment(CtVariableReference<A> variable, boolean isStatic, CtExpression<T> expression)
<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>	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 and Description
<T> CtInvocation<T>	Factory.createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, java.util.List<CtExpression<?>> arguments)
<T> CtInvocation<T>	CodeFactory.createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, java.util.List<CtExpression<?>> arguments) Creates an invocation (can be a statement or an expression).
<T> CtInvocation<T>	FactoryImpl.createInvocation(CtExpression<?> target, CtExecutableReference<T> executable, java.util.List<CtExpression<?>> arguments)
<T> CtStatementList	Factory.createVariableAssignments(java.util.List<? extends CtVariable<T>> variables, java.util.List<? extends CtExpression<T>> expressions)
<T> CtStatementList	CodeFactory.createVariableAssignments(java.util.List<? extends CtVariable<T>> variables, java.util.List<? extends CtExpression<T>> expressions) Creates a list of statements that contains the assignments of a set of variables.
<T> CtStatementList	FactoryImpl.createVariableAssignments(java.util.List<? extends CtVariable<T>> variables, java.util.List<? extends CtExpression<T>> expressions)

Uses of CtExpression in spoon.reflect.visitor

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

Modifier and Type	Method and 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	DefaultJavaPrettyPrinter.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression)
<T,E extends CtExpression<?>> void	CtAbstractVisitor.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	CtInheritanceScanner.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> e)
<T,E extends CtExpression<?>> void	CtScanner.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression)
<T,E extends CtExpression<?>> void	CtBiScannerDefault.visitCtExecutableReferenceExpression(CtExecutableReferenceExpression<T,E> expression)

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

Modifier and Type	Method and Description
protected void	DefaultJavaPrettyPrinter.enterCtExpression(CtExpression<?> e) Enters an expression.
protected void	DefaultJavaPrettyPrinter.exitCtExpression(CtExpression<?> e) Exits an expression.
<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 and 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 and 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 and 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 and 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 and 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 and 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	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 and Description
<C extends CtExpression<T>> C	CtExpressionImpl.addTypeCast(CtTypeReference<?> type)
<C extends CtExpression<T>> C	CtAssignmentImpl.addTypeCast(CtTypeReference<?> type)
<E extends CtExpression<T>> E	CtCodeSnippetExpressionImpl.compile()
<C extends CtTargetedExpression<T,CtExpression<?>>> C	CtSuperAccessImpl.setTarget(CtExpression<?> target)
<C extends CtTargetedExpression<T,CtExpression<?>>> C	CtFieldAccessImpl.setTarget(CtExpression<?> target)
<C extends CtExpression<T>> C	CtExpressionImpl.setTypeCasts(java.util.List<CtTypeReference<?>> casts)
<C extends CtExpression<T>> C	CtAssignmentImpl.setTypeCasts(java.util.List<CtTypeReference<?>> casts)

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

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

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

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

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

Modifier and Type	Method and Description
<C extends CtAbstractInvocation<T>> C	CtConstructorCallImpl.addArgument(CtExpression<?> argument)
<C extends CtAbstractInvocation<T>> C	CtInvocationImpl.addArgument(CtExpression<?> argument)
<T extends CtCase<E>> T	CtCaseImpl.addCaseExpression(CtExpression<E> caseExpression)
<C extends CtNewArray<T>> C	CtNewArrayImpl.addDimensionExpression(CtExpression<java.lang.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<java.lang.Integer> dimension)
boolean	CtNewArrayImpl.removeElement(CtExpression<?> expression)
<A extends CtAssert<T>> A	CtAssertImpl.setAssertExpression(CtExpression<java.lang.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<java.lang.Boolean> condition)
<T extends CtIf> T	CtIfImpl.setCondition(CtExpression<java.lang.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)
<T extends CtForEach> T	CtForEachImpl.setExpression(CtExpression<?> expression)
<T extends CtSynchronized> T	CtSynchronizedImpl.setExpression(CtExpression<?> expression)
<T extends CtYieldStatement> T	CtYieldStatementImpl.setExpression(CtExpression<?> expression)
<T extends CtFor> T	CtForImpl.setExpression(CtExpression<java.lang.Boolean> expression)
<A extends CtAssert<T>> A	CtAssertImpl.setExpression(CtExpression<T> value)
<C extends CtLambda<T>> C	CtLambdaImpl.setExpression(CtExpression<T> expression)
<C extends CtArrayAccess<T,V>> C	CtArrayAccessImpl.setIndexExpression(CtExpression<java.lang.Integer> expression)
<C extends CtBinaryOperator<T>> C	CtBinaryOperatorImpl.setLeftHandOperand(CtExpression<?> expression)
<T extends CtDo> T	CtDoImpl.setLoopingExpression(CtExpression<java.lang.Boolean> expression)
<T extends CtWhile> T	CtWhileImpl.setLoopingExpression(CtExpression<java.lang.Boolean> expression)
<C extends CtUnaryOperator> C	CtUnaryOperatorImpl.setOperand(CtExpression<T> 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	CtSuperAccessImpl.setTarget(CtExpression<?> target)
<C extends CtTargetedExpression<T,CtExpression<?>>> C	CtFieldAccessImpl.setTarget(CtExpression<?> target)
<C extends CtConditional<T>> C	CtConditionalImpl.setThenExpression(CtExpression<T> thenExpression)
<T extends CtThrow> T	CtThrowImpl.setThrownExpression(CtExpression<? extends java.lang.Throwable> expression)

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

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

Uses of CtExpression in spoon.support.reflect.declaration

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

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

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

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

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

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

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

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

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

Modifier and Type	Method and 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 and Description
<T extends CtAnnotation<A>> T	CtAnnotationImpl.addValue(java.lang.String elementName, CtNewArray<? extends CtExpression> value)
<T extends CtAnnotation<A>> T	CtAnnotationImpl.setValues(java.util.Map<java.lang.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 and Description
static java.lang.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 and Description
static java.lang.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 and 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 and 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 and 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, java.lang.String fieldName) Gets a default expression from a template field with all the template parameters substituted.