Uses of Class
org.codehaus.groovy.ast.expr.Expression

Packages that use Expression
groovy.beans   
org.codehaus.groovy.antlr Parser related classes. 
org.codehaus.groovy.ast Groovy AST nodes for the syntax of the language 
org.codehaus.groovy.ast.expr AST nodes for Groovy expressions 
org.codehaus.groovy.ast.stmt AST nodes for Groovy statements 
org.codehaus.groovy.classgen Generates Java classes for Groovy classes using ASM. 
org.codehaus.groovy.control Compiler control classes. 
org.codehaus.groovy.tools.javac Classes related to the joint compiler. 
org.codehaus.groovy.transform   
 

Uses of Expression in groovy.beans
 

Methods in groovy.beans with parameters of type Expression
protected  Statement BindableASTTransformation.createBindableStatement(PropertyNode propertyNode, Expression fieldExpression)
          Creates a statement body similar to: this.firePropertyChange("field", field, field = value)
protected  Statement VetoableASTTransformation.createConstrainedStatement(PropertyNode propertyNode, Expression fieldExpression)
          Creates a statement body silimar to: this.fireVetoableChange("field", field, field = value)
protected  Statement VetoableASTTransformation.createSetStatement(Expression fieldExpression)
          Creates a statement body similar to: field = value

Used when the field is not also @Bindable

 

Uses of Expression in org.codehaus.groovy.antlr
 

Methods in org.codehaus.groovy.antlr that return Expression
protected  Expression AntlrParserPlugin.arguments(antlr.collections.AST elist)
           
protected  Expression AntlrParserPlugin.asExpression(antlr.collections.AST node)
           
protected  Expression AntlrParserPlugin.binaryExpression(int type, antlr.collections.AST node)
           
protected  Expression AntlrParserPlugin.blockExpression(antlr.collections.AST node)
           
protected  Expression AntlrParserPlugin.castExpression(antlr.collections.AST castNode)
           
protected  Expression AntlrParserPlugin.constructorCallExpression(antlr.collections.AST node)
           
protected  Expression AntlrParserPlugin.declarationExpression(antlr.collections.AST variableDef)
           
protected  Expression AntlrParserPlugin.dotExpression(antlr.collections.AST node)
           
protected  Expression AntlrParserPlugin.dynamicMemberExpression(antlr.collections.AST dynamicMemberNode)
           
protected  Expression AntlrParserPlugin.expression(antlr.collections.AST node)
           
protected  Expression AntlrParserPlugin.expression(antlr.collections.AST node, boolean convertToConstant)
           
protected  Expression AntlrParserPlugin.expressionList(antlr.collections.AST node)
           
protected  Expression AntlrParserPlugin.expressionSwitch(antlr.collections.AST node)
           
protected  Expression AntlrParserPlugin.gstring(antlr.collections.AST gstringNode)
           
protected  Expression AntlrParserPlugin.indexExpression(antlr.collections.AST indexNode)
           
protected  Expression AntlrParserPlugin.instanceofExpression(antlr.collections.AST node)
           
protected  Expression AntlrParserPlugin.listExpression(antlr.collections.AST listNode)
           
protected  Expression AntlrParserPlugin.literalExpression(antlr.collections.AST node, java.lang.Object value)
           
protected  Expression AntlrParserPlugin.mapExpression(antlr.collections.AST mapNode)
          Typically only used for map constructors I think?
protected  Expression AntlrParserPlugin.methodCallExpression(antlr.collections.AST methodCallNode)
           
protected  Expression AntlrParserPlugin.methodPointerExpression(antlr.collections.AST node)
           
protected  Expression AntlrParserPlugin.postfixExpression(antlr.collections.AST node, int token)
           
protected  Expression AntlrParserPlugin.prefixExpression(antlr.collections.AST node, int token)
           
protected  Expression AntlrParserPlugin.rangeExpression(antlr.collections.AST rangeNode, boolean inclusive)
           
protected  Expression AntlrParserPlugin.specialConstructorCallExpression(antlr.collections.AST methodCallNode, ClassNode special)
           
protected  Expression AntlrParserPlugin.spreadExpression(antlr.collections.AST node)
           
protected  Expression AntlrParserPlugin.spreadMapExpression(antlr.collections.AST node)
           
protected  Expression AntlrParserPlugin.ternaryExpression(antlr.collections.AST ternaryNode)
           
protected  Expression AntlrParserPlugin.unaryMinusExpression(antlr.collections.AST unaryMinusExpr)
           
protected  Expression AntlrParserPlugin.unaryPlusExpression(antlr.collections.AST unaryPlusExpr)
           
protected  Expression AntlrParserPlugin.variableExpression(antlr.collections.AST node)
           
 

Methods in org.codehaus.groovy.antlr with parameters of type Expression
static void EnumHelper.addEnumConstant(ClassNode enumClass, java.lang.String name, Expression init)
           
 

Uses of Expression in org.codehaus.groovy.ast
 

Fields in org.codehaus.groovy.ast declared as Expression
private  Expression Parameter.defaultValue
           
private  Expression FieldNode.initialValueExpression
           
 

Methods in org.codehaus.groovy.ast that return Expression
 Expression PropertyNode.getInitialExpression()
           
 Expression FieldNode.getInitialExpression()
           
 Expression Parameter.getInitialExpression()
           
 Expression DynamicVariable.getInitialExpression()
           
 Expression Variable.getInitialExpression()
          expression used to initialize the variable or null of there is no initialization.
 Expression FieldNode.getInitialValueExpression()
           
 Expression AnnotationNode.getMember(java.lang.String name)
           
 Expression ClassCodeExpressionTransformer.transform(Expression exp)
           
 

Methods in org.codehaus.groovy.ast with parameters of type Expression
 FieldNode ClassNode.addField(java.lang.String name, int modifiers, ClassNode type, Expression initialValue)
           
 void AnnotationNode.addMember(java.lang.String name, Expression value)
           
 PropertyNode ClassNode.addProperty(java.lang.String name, int modifiers, ClassNode type, Expression initialValueExpression, Statement getterBlock, Statement setterBlock)
           
 boolean ClassNode.hasPossibleMethod(java.lang.String name, Expression arguments)
          Returns true if the given method has a possibly matching instance method with the given name and arguments.
 boolean ClassNode.hasPossibleStaticMethod(java.lang.String name, Expression arguments)
          Returns true if the given method has a possibly matching static method with the given name and arguments.
 void Parameter.setInitialExpression(Expression init)
           
 void FieldNode.setInitialValueExpression(Expression initialValueExpression)
           
 void AnnotationNode.setMember(java.lang.String name, Expression value)
           
 Expression ClassCodeExpressionTransformer.transform(Expression exp)
           
 MethodNode ClassNode.tryFindPossibleMethod(java.lang.String name, Expression arguments)
           
 

Constructors in org.codehaus.groovy.ast with parameters of type Expression
FieldNode(java.lang.String name, int modifiers, ClassNode type, ClassNode owner, Expression initialValueExpression)
           
Parameter(ClassNode type, java.lang.String name, Expression defaultValue)
           
PropertyNode(java.lang.String name, int modifiers, ClassNode type, ClassNode owner, Expression initialValueExpression, Statement getterBlock, Statement setterBlock)
           
 

Uses of Expression in org.codehaus.groovy.ast.expr
 

Subclasses of Expression in org.codehaus.groovy.ast.expr
 class AnnotationConstantExpression
          Represents an annotation "constant" that may appear in annotation attributes (mainly used as a marker).
 class ArgumentListExpression
          Represents one or more arguments being passed into a method
 class ArrayExpression
          Represents an array object construction either using a fixed size or an initializer expression
 class AttributeExpression
          Represents an attribute access (accessing the field of a class) such as the expression "foo.@bar".
 class BinaryExpression
          Represents two expressions and an operation
 class BitwiseNegationExpression
           
 class BooleanExpression
          Represents a boolean expression
 class CastExpression
          Represents a type cast expression
 class ClassExpression
          Represents access to a Java/Groovy class in an expression, such as when invoking a static method or accessing a static type
 class ClosureExpression
          Represents a closure creation expression such as { statement; } or { i : statement; } or { i, x, String y: statement }
 class ClosureListExpression
          This class rerpresents a list of expressions used to create closures.
 class ConstantExpression
          Represents a constant expression such as null, true, false
 class ConstructorCallExpression
          A constructor call
 class DeclarationExpression
          Represents a local variable name declaration, an expression like "def foo" or with type "String foo".
 class ElvisOperatorExpression
          Represents a short ternary expression x ?: y, which is equal to
 class EmptyExpression
          This class is a place holder for an empty expression.
 class FieldExpression
          Represents a field access such as the expression "this.foo".
 class GStringExpression
          Represents a String expression which contains embedded values inside it such as "hello there ${user} how are you" which is expanded lazily
 class ListExpression
          Represents a list expression [1, 2, 3] which creates a mutable List
 class MapEntryExpression
          Represents an entry inside a map expression such as 1 : 2.
 class MapExpression
          Represents a map expression [1 : 2, "a" : "b", x : y] which creates a mutable Map
 class MethodCallExpression
          A method call on an object or class
 class MethodPointerExpression
          Represents a method pointer on an object such as foo.&bar which means find the method pointer on foo for the method called "bar" which is equivalent to foo.metaClass.getMethodPointer(foo, "bar")
 class NamedArgumentListExpression
          Represents one or more arguments being passed into a method by name
 class NotExpression
           
 class PostfixExpression
          Represents a postfix expression like foo++ or bar++
 class PrefixExpression
          Represents a prefix expression like ++foo or --bar
 class PropertyExpression
          Represents a property access such as the expression "foo.bar".
 class RangeExpression
          Represents a range expression such as for iterating.
 class RegexExpression
          Represents a regular expression of the form ~ which creates a regular expression.
 class SpreadExpression
          Represents a spread expression *x in the list expression [1, *x, 2].
 class SpreadMapExpression
          Represents a spread map expression *:m in the map expression [1, *:m, 2, "c":100] or in the method invoke expression func(1, *:m, 2, "c":100).
 class StaticMethodCallExpression
          A static method call on a class
 class TernaryExpression
          Represents a ternary expression (booleanExpression) ? expression : expression
 class TupleExpression
          Represents a tuple expression {1, 2, 3} which creates an immutable List
 class UnaryMinusExpression
           
 class UnaryPlusExpression
           
 class VariableExpression
          Represents a local variable name, the simplest form of expression.
 

Fields in org.codehaus.groovy.ast.expr declared as Expression
private  Expression ConstructorCallExpression.arguments
           
private  Expression MethodCallExpression.arguments
           
private  Expression StaticMethodCallExpression.arguments
           
private  Expression UnaryPlusExpression.expression
           
private  Expression SpreadMapExpression.expression
           
private  Expression BooleanExpression.expression
           
private  Expression UnaryMinusExpression.expression
           
private  Expression BitwiseNegationExpression.expression
           
private  Expression MethodPointerExpression.expression
           
private  Expression CastExpression.expression
           
private  Expression SpreadExpression.expression
           
private  Expression PostfixExpression.expression
           
private  Expression PrefixExpression.expression
           
private  Expression TernaryExpression.falseExpression
           
private  Expression RangeExpression.from
           
private  Expression MapEntryExpression.keyExpression
           
private  Expression BinaryExpression.leftExpression
           
private  Expression MethodCallExpression.method
           
private  Expression MethodPointerExpression.methodName
           
static Expression MethodCallExpression.NO_ARGUMENTS
           
private  Expression MethodCallExpression.objectExpression
           
private  Expression PropertyExpression.objectExpression
           
private  Expression PropertyExpression.property
           
private  Expression BinaryExpression.rightExpression
           
private  Expression RegexExpression.string
           
private  Expression RangeExpression.to
           
private  Expression TernaryExpression.trueExpression
           
private  Expression MapEntryExpression.valueExpression
           
 

Methods in org.codehaus.groovy.ast.expr that return Expression
 Expression GStringExpression.asConstantString()
           
 Expression ConstructorCallExpression.getArguments()
           
 Expression MethodCallExpression.getArguments()
           
 Expression StaticMethodCallExpression.getArguments()
           
 Expression UnaryPlusExpression.getExpression()
           
 Expression SpreadMapExpression.getExpression()
           
 Expression BooleanExpression.getExpression()
           
 Expression UnaryMinusExpression.getExpression()
           
 Expression BitwiseNegationExpression.getExpression()
           
 Expression MethodPointerExpression.getExpression()
           
 Expression CastExpression.getExpression()
           
 Expression SpreadExpression.getExpression()
           
 Expression PostfixExpression.getExpression()
           
 Expression PrefixExpression.getExpression()
           
 Expression ListExpression.getExpression(int i)
           
 Expression ArrayExpression.getExpression(int i)
           
 Expression TupleExpression.getExpression(int i)
           
 Expression TernaryExpression.getFalseExpression()
           
 Expression RangeExpression.getFrom()
           
 Expression VariableExpression.getInitialExpression()
           
 Expression MapEntryExpression.getKeyExpression()
           
 Expression BinaryExpression.getLeftExpression()
           
 Expression MethodCallExpression.getMethod()
           
 Expression MethodPointerExpression.getMethodName()
           
 Expression MethodCallExpression.getObjectExpression()
           
 Expression PropertyExpression.getObjectExpression()
           
 Expression PropertyExpression.getProperty()
           
 Expression RegexExpression.getRegex()
           
 Expression BinaryExpression.getRightExpression()
           
 Expression RangeExpression.getTo()
           
 Expression TernaryExpression.getTrueExpression()
           
 Expression GStringExpression.getValue(int idx)
           
 Expression MapEntryExpression.getValueExpression()
           
 Expression ExpressionTransformer.transform(Expression expression)
          Transforms the given expression into another expression
 Expression ListExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression ConstructorCallExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression UnaryPlusExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression SpreadMapExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression MethodCallExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression BooleanExpression.transformExpression(ExpressionTransformer transformer)
           
abstract  Expression Expression.transformExpression(ExpressionTransformer transformer)
          Return a copy of the expression calling the transformer on any nested expressions
 Expression ElvisOperatorExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression MapExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression UnaryMinusExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression BinaryExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression RegexExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression ArrayExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression BitwiseNegationExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression TupleExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression ClosureExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression MapEntryExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression DeclarationExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression ConstantExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression VariableExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression PropertyExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression StaticMethodCallExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression MethodPointerExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression CastExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression FieldExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression NotExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression RangeExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression TernaryExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression EmptyExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression SpreadExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression ClassExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression PostfixExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression ArgumentListExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression PrefixExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression GStringExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression ClosureListExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression AttributeExpression.transformExpression(ExpressionTransformer transformer)
           
 Expression NamedArgumentListExpression.transformExpression(ExpressionTransformer transformer)
           
 

Methods in org.codehaus.groovy.ast.expr with parameters of type Expression
 void ListExpression.addExpression(Expression expression)
           
 void ArrayExpression.addExpression(Expression expression)
           
 TupleExpression TupleExpression.addExpression(Expression expression)
           
 void MapExpression.addMapEntryExpression(Expression keyExpression, Expression valueExpression)
           
 void GStringExpression.addValue(Expression value)
           
static CastExpression CastExpression.asExpression(ClassNode type, Expression expression)
           
private  void DeclarationExpression.check(Expression left, Expression right)
           
private static BooleanExpression ElvisOperatorExpression.getBool(Expression base)
           
static BinaryExpression BinaryExpression.newAssignmentExpression(Variable variable, Expression rhs)
          Creates an assignment expression in which the specified expression is written into the specified variable name.
static BinaryExpression BinaryExpression.newInitializationExpression(java.lang.String variable, ClassNode type, Expression rhs)
          Creates variable initialization expression in which the specified expression is written into the specified variable name.
 void MethodCallExpression.setArguments(Expression arguments)
           
 void PostfixExpression.setExpression(Expression expression)
           
 void PrefixExpression.setExpression(Expression expression)
           
 void BinaryExpression.setLeftExpression(Expression leftExpression)
           
 void DeclarationExpression.setLeftExpression(Expression leftExpression)
           
 void MethodCallExpression.setMethod(Expression method)
           
 void MethodCallExpression.setObjectExpression(Expression objectExpression)
           
 void PropertyExpression.setObjectExpression(Expression exp)
           
 void BinaryExpression.setRightExpression(Expression rightExpression)
           
 void DeclarationExpression.setRightExpression(Expression rightExpression)
           
 Expression ExpressionTransformer.transform(Expression expression)
          Transforms the given expression into another expression
 

Constructors in org.codehaus.groovy.ast.expr with parameters of type Expression
ArgumentListExpression(Expression expr)
           
ArgumentListExpression(Expression[] expressions)
           
ArgumentListExpression(Expression expr1, Expression expr2)
           
ArgumentListExpression(Expression expr1, Expression expr2, Expression expr3)
           
AttributeExpression(Expression objectExpression, Expression property)
           
AttributeExpression(Expression objectExpression, Expression property, boolean safe)
           
BinaryExpression(Expression leftExpression, Token operation, Expression rightExpression)
           
BitwiseNegationExpression(Expression expression)
           
BooleanExpression(Expression expression)
           
CastExpression(ClassNode type, Expression expression)
           
CastExpression(ClassNode type, Expression expression, boolean ignoreAutoboxing)
           
ConstructorCallExpression(ClassNode type, Expression arguments)
           
DeclarationExpression(Expression left, Token operation, Expression right)
           
DeclarationExpression(VariableExpression left, Token operation, Expression right)
           
ElvisOperatorExpression(Expression base, Expression falseExpression)
           
MapEntryExpression(Expression keyExpression, Expression valueExpression)
           
MethodCallExpression(Expression objectExpression, Expression method, Expression arguments)
           
MethodCallExpression(Expression objectExpression, java.lang.String method, Expression arguments)
           
MethodPointerExpression(Expression expression, Expression methodName)
           
NotExpression(Expression expression)
           
PostfixExpression(Expression expression, Token operation)
           
PrefixExpression(Token operation, Expression expression)
           
PropertyExpression(Expression objectExpression, Expression property)
           
PropertyExpression(Expression objectExpression, Expression property, boolean safe)
           
PropertyExpression(Expression objectExpression, java.lang.String property)
           
RangeExpression(Expression from, Expression to, boolean inclusive)
           
RegexExpression(Expression string)
           
SpreadExpression(Expression expression)
           
SpreadMapExpression(Expression expression)
           
StaticMethodCallExpression(ClassNode type, java.lang.String method, Expression arguments)
           
TernaryExpression(BooleanExpression booleanExpression, Expression trueExpression, Expression falseExpression)
           
TupleExpression(Expression expr)
           
TupleExpression(Expression[] expressionArray)
           
TupleExpression(Expression expr1, Expression expr2)
           
TupleExpression(Expression expr1, Expression expr2, Expression expr3)
           
UnaryMinusExpression(Expression expression)
           
UnaryPlusExpression(Expression expression)
           
 

Uses of Expression in org.codehaus.groovy.ast.stmt
 

Fields in org.codehaus.groovy.ast.stmt declared as Expression
private  Expression ForStatement.collectionExpression
           
private  Expression SwitchStatement.expression
           
private  Expression ThrowStatement.expression
           
private  Expression ReturnStatement.expression
           
private  Expression CaseStatement.expression
           
private  Expression SynchronizedStatement.expression
           
private  Expression ExpressionStatement.expression
           
private  Expression AssertStatement.messageExpression
           
 

Methods in org.codehaus.groovy.ast.stmt that return Expression
 Expression ForStatement.getCollectionExpression()
           
 Expression SwitchStatement.getExpression()
           
 Expression ThrowStatement.getExpression()
           
 Expression ReturnStatement.getExpression()
           
 Expression CaseStatement.getExpression()
           
 Expression SynchronizedStatement.getExpression()
           
 Expression ExpressionStatement.getExpression()
           
 Expression AssertStatement.getMessageExpression()
           
 

Methods in org.codehaus.groovy.ast.stmt with parameters of type Expression
 void ForStatement.setCollectionExpression(Expression collectionExpression)
           
 void SwitchStatement.setExpression(Expression e)
           
 void ThrowStatement.setExpression(Expression expression)
           
 void ReturnStatement.setExpression(Expression expression)
           
 void CaseStatement.setExpression(Expression e)
           
 void SynchronizedStatement.setExpression(Expression expression)
           
 void ExpressionStatement.setExpression(Expression expression)
           
 void AssertStatement.setMessageExpression(Expression messageExpression)
           
 

Constructors in org.codehaus.groovy.ast.stmt with parameters of type Expression
AssertStatement(BooleanExpression booleanExpression, Expression messageExpression)
           
CaseStatement(Expression expression, Statement code)
           
ExpressionStatement(Expression expression)
           
ForStatement(Parameter variable, Expression collectionExpression, Statement loopBlock)
           
ReturnStatement(Expression expression)
           
SwitchStatement(Expression expression)
           
SwitchStatement(Expression expression, java.util.List caseStatements, Statement defaultStatement)
           
SwitchStatement(Expression expression, Statement defaultStatement)
           
SynchronizedStatement(Expression expression, Statement code)
           
ThrowStatement(Expression expression)
           
 

Uses of Expression in org.codehaus.groovy.classgen
 

Subclasses of Expression in org.codehaus.groovy.classgen
 class BytecodeExpression
          Represents some custom bytecode generation by the compiler
 

Fields in org.codehaus.groovy.classgen declared as Expression
private static Expression VariableScopeVisitor.CALL
           
 

Methods in org.codehaus.groovy.classgen that return Expression
protected  Expression AsmClassGenerator.createReturnLHSExpression(Expression expression)
          For assignment expressions, return a safe expression for the LHS we can use to return the value
protected  Expression AsmClassGenerator.createReusableExpression(Expression expression)
           
 Expression BytecodeExpression.transformExpression(ExpressionTransformer transformer)
           
 

Methods in org.codehaus.groovy.classgen with parameters of type Expression
private  void AsmClassGenerator.addVariableNames(Expression expression, java.util.List list)
           
protected static int AsmClassGenerator.argumentSize(Expression arguments)
           
protected  boolean AsmClassGenerator.argumentsUseStack(Expression arguments)
           
private  void AsmClassGenerator.assignmentCastAndVisit(ClassNode type, Expression rightExpression)
           
 void AnnotationVisitor.checkcircularReference(ClassNode searchClass, ClassNode attrType, Expression startExp)
           
private  void ClassCompletionVerifier.checkForInvalidDeclaration(Expression exp)
           
private  void VariableScopeVisitor.checkVariableContextAccess(Variable v, Expression expr)
           
private  Variable VariableScopeVisitor.checkVariableNameForDeclaration(java.lang.String name, Expression expression)
           
protected static boolean AsmClassGenerator.containsSpreadExpression(Expression arguments)
           
protected  Expression AsmClassGenerator.createReturnLHSExpression(Expression expression)
          For assignment expressions, return a safe expression for the LHS we can use to return the value
protected  Expression AsmClassGenerator.createReusableExpression(Expression expression)
           
protected  void AsmClassGenerator.doConvertAndCast(ClassNode type, Expression expression, boolean ignoreAutoboxing, boolean forceCast, boolean coerce)
          Casts to the given type unless it can be determined that the cast is unnecessary
protected  boolean AsmClassGenerator.emptyArguments(Expression arguments)
           
protected  void AsmClassGenerator.evaluateExpression(Expression expression)
           
protected  void AsmClassGenerator.evaluatePostfixMethod(java.lang.String method, Expression expression)
           
protected  void AsmClassGenerator.evaluatePrefixMethod(java.lang.String method, Expression expression)
           
private  void AsmClassGenerator.execMethodAndStoreForSubscriptOperator(java.lang.String method, Expression expression)
           
private  ConstantExpression AnnotationVisitor.getConstantExpression(Expression exp)
           
protected  ClassNode AsmClassGenerator.getExpressionType(Expression expression)
           
protected  ClassNode AsmClassGenerator.getLHSType(Expression leftExpression)
          Deduces the type name required for some casting
private  java.lang.String AsmClassGenerator.getMethodName(Expression message)
           
private  void AsmClassGenerator.improveExprType(Expression expr)
           
private  void AsmClassGenerator.invokeClosure(Expression arguments, java.lang.String methodName)
           
protected  boolean AsmClassGenerator.isComparisonExpression(Expression expression)
           
protected  boolean AsmClassGenerator.isGroovyObject(Expression objectExpression)
           
protected  boolean AsmClassGenerator.isPopRequired(Expression expression)
           
private static boolean AsmClassGenerator.isSuperExpression(Expression expression)
           
private static boolean AsmClassGenerator.isThisExpression(Expression expression)
           
private static boolean AsmClassGenerator.isThisOrSuper(Expression expression)
           
private  void AsmClassGenerator.load(Expression exp)
           
private  void AsmClassGenerator.loadDynamicName(Expression name)
           
private  void AsmClassGenerator.loadWrapper(Expression argument)
           
private  void AsmClassGenerator.makeBinopCallSite(Expression receiver, java.lang.String message, Expression arguments)
           
private  void AsmClassGenerator.makeCall(ClassExpression sender, Expression receiver, Expression message, Expression arguments, MethodCallerMultiAdapter adapter, boolean safe, boolean spreadSafe, boolean implicitThis)
           
private  void AsmClassGenerator.makeCall(Expression receiver, Expression message, Expression arguments, MethodCallerMultiAdapter adapter, boolean safe, boolean spreadSafe, boolean implicitThis)
           
private  void AsmClassGenerator.makeCallSite(Expression receiver, java.lang.String message, Expression arguments, boolean safe, boolean implicitThis, boolean callCurrent, boolean callStatic)
           
private  void AsmClassGenerator.makeGetPropertySite(Expression receiver, java.lang.String methodName, boolean safe, boolean implicitThis)
           
private  void AsmClassGenerator.makeGroovyObjectGetPropertySite(Expression receiver, java.lang.String methodName, boolean safe, boolean implicitThis)
           
protected  void AsmClassGenerator.visitAndAutoboxBoolean(Expression expression)
           
(package private)  void AsmClassGenerator.visitAnnotationDefaultExpression(org.objectweb.asm.AnnotationVisitor av, ClassNode type, Expression exp)
           
protected  void AnnotationVisitor.visitExpression(java.lang.String attrName, Expression attrExp, ClassNode attrType)
           
 

Uses of Expression in org.codehaus.groovy.control
 

Fields in org.codehaus.groovy.control declared as Expression
private  Expression StaticImportVisitor.foundArgs
           
private  Expression StaticImportVisitor.foundConstant
           
 

Methods in org.codehaus.groovy.control that return Expression
private  Expression ResolveVisitor.correctClassClassChain(PropertyExpression pe)
           
private  Expression StaticImportVisitor.findStaticField(ClassNode staticImportType, java.lang.String fieldName)
           
private  Expression StaticImportVisitor.findStaticFieldImportFromModule(java.lang.String name)
           
private  Expression StaticImportVisitor.findStaticMethod(ClassNode staticImportType, java.lang.String methodName, Expression args)
           
private  Expression StaticImportVisitor.findStaticMethodImportFromModule(Expression method, Expression args)
           
 Expression OptimizerVisitor.transform(Expression exp)
           
 Expression ResolveVisitor.transform(Expression exp)
           
 Expression StaticImportVisitor.transform(Expression exp)
           
protected  Expression ResolveVisitor.transformAnnotationConstantExpression(AnnotationConstantExpression ace)
           
protected  Expression ResolveVisitor.transformBinaryExpression(BinaryExpression be)
           
protected  Expression ResolveVisitor.transformClosureExpression(ClosureExpression ce)
           
protected  Expression StaticImportVisitor.transformClosureExpression(ClosureExpression ce)
           
protected  Expression ResolveVisitor.transformConstructorCallExpression(ConstructorCallExpression cce)
           
protected  Expression StaticImportVisitor.transformConstructorCallExpression(ConstructorCallExpression cce)
           
protected  Expression ResolveVisitor.transformDeclarationExpression(DeclarationExpression de)
           
protected  Expression ResolveVisitor.transformMethodCallExpression(MethodCallExpression mce)
           
protected  Expression StaticImportVisitor.transformMethodCallExpression(MethodCallExpression mce)
           
protected  Expression ResolveVisitor.transformPropertyExpression(PropertyExpression pe)
           
protected  Expression StaticImportVisitor.transformPropertyExpression(PropertyExpression pe)
           
protected  Expression ResolveVisitor.transformVariableExpression(VariableExpression ve)
           
protected  Expression StaticImportVisitor.transformVariableExpression(VariableExpression ve)
           
 

Methods in org.codehaus.groovy.control with parameters of type Expression
private  Expression StaticImportVisitor.findStaticMethod(ClassNode staticImportType, java.lang.String methodName, Expression args)
           
private  Expression StaticImportVisitor.findStaticMethodImportFromModule(Expression method, Expression args)
           
 Expression OptimizerVisitor.transform(Expression exp)
           
 Expression ResolveVisitor.transform(Expression exp)
           
 Expression StaticImportVisitor.transform(Expression exp)
           
 

Uses of Expression in org.codehaus.groovy.tools.javac
 

Methods in org.codehaus.groovy.tools.javac with parameters of type Expression
private  ClassNode JavaStubGenerator.getConstructorArgumentType(Expression arg, ConstructorNode node)
           
 

Uses of Expression in org.codehaus.groovy.transform
 

Methods in org.codehaus.groovy.transform that return Expression
private  Expression ImmutableASTTransformation.assignExpr(Expression fieldExpr, Expression value)
           
private  Expression ImmutableASTTransformation.checkUnresolved(ClassNode cNode, FieldNode fNode, Expression value)
           
private  Expression ImmutableASTTransformation.cloneArrayOrCloneableExpr(Expression fieldExpr)
           
private  Expression ImmutableASTTransformation.cloneCollectionExpr(Expression fieldExpr)
           
private  Expression ImmutableASTTransformation.cloneDateExpr(Expression origDate)
           
private  Expression ImmutableASTTransformation.findArg(java.lang.String fName)
           
private  Expression LazyASTTransformation.getInitExpr(FieldNode fieldNode)
           
 Expression NewifyASTTransformation.transform(Expression expr)
           
private  Expression NewifyASTTransformation.transformMethodCall(MethodCallExpression mce, Expression args)
           
 

Methods in org.codehaus.groovy.transform with parameters of type Expression
private  ExpressionStatement ImmutableASTTransformation.append(Expression result, Expression expr)
           
private  Expression ImmutableASTTransformation.assignExpr(Expression fieldExpr, Expression value)
           
private  Statement ImmutableASTTransformation.assignStatement(Expression fieldExpr, Expression value)
           
private  Statement ImmutableASTTransformation.calculateHashStatements(Expression hash, java.util.List<PropertyNode> list)
           
private  Expression ImmutableASTTransformation.checkUnresolved(ClassNode cNode, FieldNode fNode, Expression value)
           
private  Expression ImmutableASTTransformation.cloneArrayOrCloneableExpr(Expression fieldExpr)
           
private  Expression ImmutableASTTransformation.cloneCollectionExpr(Expression fieldExpr)
           
private  Expression ImmutableASTTransformation.cloneDateExpr(Expression origDate)
           
private  void LazyASTTransformation.create(FieldNode fieldNode, Expression initExpr)
           
private  void LazyASTTransformation.createSoft(FieldNode fieldNode, Expression initExpr)
           
private  void LazyASTTransformation.createSoftGetter(FieldNode fieldNode, Expression initExpr, ClassNode type)
           
private  boolean NewifyASTTransformation.determineAutoFlag(Expression autoExpr)
           
private  ListExpression NewifyASTTransformation.determineClassesToNewify(Expression expr)
           
private  BooleanExpression ImmutableASTTransformation.equalsNullExpr(Expression argExpr)
           
private  BooleanExpression ImmutableASTTransformation.identicalExpr(Expression self, Expression other)
           
private  BooleanExpression ImmutableASTTransformation.isOneExpr(Expression expr)
           
private  BooleanExpression ImmutableASTTransformation.isTrueExpr(Expression argExpr)
           
private  BooleanExpression ImmutableASTTransformation.isZeroExpr(Expression expr)
           
private  BooleanExpression ImmutableASTTransformation.notEqualsExpr(PropertyNode pNode, Expression other)
           
private  IfStatement ImmutableASTTransformation.returnFalseIfNull(Expression other)
           
private  Statement ImmutableASTTransformation.returnFalseIfPropertyNotEqual(PropertyNode pNode, Expression other)
           
private  Statement ImmutableASTTransformation.returnFalseIfWrongType(ClassNode cNode, Expression other)
           
private  IfStatement ImmutableASTTransformation.returnTrueIfIdentical(Expression self, Expression other)
           
private  Statement ImmutableASTTransformation.safeExpression(Expression fieldExpr, Expression expression)
           
private  Statement ImmutableASTTransformation.toStringPropertyName(Expression result, java.lang.String fName)
           
 Expression NewifyASTTransformation.transform(Expression expr)
           
private  Expression NewifyASTTransformation.transformMethodCall(MethodCallExpression mce, Expression args)
           
 



Copyright © ${year} The Codehaus. All Rights Reserved.