Package com.strobel.expressions

Class Expression

java.lang.Object

com.strobel.expressions.Expression

Direct Known Subclasses:

BinaryExpression, BlockExpression, ConcatExpression, ConditionalExpression, ConstantExpression, DefaultValueExpression, ForEachExpression, ForExpression, GotoExpression, InvocationExpression, LabelExpression, LambdaExpression, LoopExpression, MemberExpression, MethodCallExpression, NewArrayExpression, NewExpression, ParameterExpression, RuntimeVariablesExpression, SwitchExpression, TryExpression, TypeBinaryExpression, UnaryExpression

public abstract class Expression
extends java.lang.Object

The base type for all nodes in Expression Trees.

Field Summary

Fields

Modifier and Type	Field	Description
private static java.util.Set<BindingFlags>	InstanceMemberBindingFlags
private static java.util.Set<BindingFlags>	StaticMemberBindingFlags
private static java.lang.Class<?>	UNMODIFIABLE_LIST_CLASS

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	Expression()

Method Summary

Modifier and Type	Method	Description
protected Expression	accept(ExpressionVisitor visitor)	Dispatches to the specific visit method for this node type.
private static ExpressionList<? extends Expression>	adaptArguments(MethodInfo method, ExpressionList<? extends Expression> arguments)
static BinaryExpression	add(Expression left, Expression right)
static BinaryExpression	add(Expression left, Expression right, MethodInfo method)
static BinaryExpression	addAssign(Expression left, Expression right)
static BinaryExpression	addAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	addAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
private static BinaryExpression	aggregateBinary(ExpressionType binaryType, ImmutableList<Expression> operands)
static BinaryExpression	and(Expression left, Expression right)
static BinaryExpression	and(Expression left, Expression right, MethodInfo method)
static BinaryExpression	andAlso(Expression left, Expression right)
static BinaryExpression	andAlso(Expression first, Expression... rest)
static BinaryExpression	andAlso(Expression left, Expression right, MethodInfo method)
static BinaryExpression	andAssign(Expression left, Expression right)
static BinaryExpression	andAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	andAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
private static MethodInfo	applyTypeArgs(MethodInfo m, TypeList typeArgs)
static BinaryExpression	arrayIndex(Expression array, Expression index)
static UnaryExpression	arrayLength(Expression array)
(package private) static ParameterExpressionList	arrayToList(ParameterExpression[] parameters)
(package private) static <T extends Expression> ExpressionList<T>	arrayToList(T[] expressions)
(package private) static <T> ReadOnlyList<T>	arrayToReadOnlyList(T[] items)
static BinaryExpression	assign(Expression left, Expression right)
static Expression	base(Type<?> type)
static BlockExpression	block(Expression... expressions)
static BlockExpression	block(ExpressionList<? extends Expression> expressions)
static BlockExpression	block(Expression arg0, Expression arg1)
static BlockExpression	block(Expression arg0, Expression arg1, Expression arg2)
static BlockExpression	block(Expression arg0, Expression arg1, Expression arg2, Expression arg3)
static BlockExpression	block(Expression arg0, Expression arg1, Expression arg2, Expression arg3, Expression arg4)
static BlockExpression	block(ParameterExpression[] variables, Expression... expressions)
static BlockExpression	block(ParameterExpressionList variables, Expression... expressions)
static BlockExpression	block(ParameterExpressionList variables, ExpressionList<? extends Expression> expressions)
static BlockExpression	block(Type<?> type, Expression... expressions)
static BlockExpression	block(Type<?> type, ExpressionList<? extends Expression> expressions)
static BlockExpression	block(Type<?> type, ParameterExpression[] variables, Expression... expressions)
static BlockExpression	block(Type<?> type, ParameterExpressionList variables, Expression... expressions)
static BlockExpression	block(Type<?> type, ParameterExpressionList variables, ExpressionList<? extends Expression> expressions)
static Expression	box(Expression expression)
static MethodCallExpression	call(Expression target, MethodInfo method, Expression... arguments)
static MethodCallExpression	call(Expression target, MethodInfo method, ExpressionList<? extends Expression> arguments)
static MethodCallExpression	call(Expression target, java.lang.String methodName, Expression... arguments)
static MethodCallExpression	call(Expression target, java.lang.String methodName, TypeList typeArguments, Expression... arguments)
static MethodCallExpression	call(Expression target, java.lang.String methodName, TypeList typeArguments, ExpressionList<? extends Expression> arguments)
static MethodCallExpression	call(MethodInfo method, Expression... arguments)
static MethodCallExpression	call(MethodInfo method, ExpressionList<? extends Expression> arguments)
static MethodCallExpression	call(Type<?> declaringType, java.lang.String methodName, Expression... arguments)
static MethodCallExpression	call(Type<?> declaringType, java.lang.String methodName, TypeList typeArguments, Expression... arguments)
static MethodCallExpression	call(Type<?> declaringType, java.lang.String methodName, TypeList typeArguments, ExpressionList<? extends Expression> arguments)
boolean	canReduce()	Indicates that the node can be reduced to a simpler node.
static ConstantExpression	classConstant(Type<?> value)
static BinaryExpression	coalesce(Expression left, Expression right)
static BinaryExpression	coalesce(Expression left, Expression right, LambdaExpression<?> conversion)
static ConcatExpression	concat(ExpressionList<? extends Expression> operands)
static ConcatExpression	concat(Expression first, Expression second)
static ConcatExpression	concat(Expression first, Expression second, Expression... operands)
static ConditionalExpression	condition(Expression test, Expression ifTrue, Expression ifFalse)
static ConditionalExpression	condition(Expression test, Expression ifTrue, Expression ifFalse, Type<?> type)
static ConstantExpression	constant(java.lang.Object value)
static ConstantExpression	constant(java.lang.Object value, Type<?> type)
static UnaryExpression	convert(Expression expression, Type<?> type)
static UnaryExpression	convert(Expression expression, Type<?> type, MethodInfo method)
static UnaryExpression	decrement(Expression expression)
static UnaryExpression	decrement(Expression expression, MethodInfo method)
static DefaultValueExpression	defaultValue(Type<?> type)
static BinaryExpression	divide(Expression left, Expression right)
static BinaryExpression	divide(Expression left, Expression right, MethodInfo method)
static BinaryExpression	divideAssign(Expression left, Expression right)
static BinaryExpression	divideAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	divideAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
static Expression	empty()
(package private) static <T> java.util.List<T>	ensureUnmodifiable(java.util.List<T> list)
static BinaryExpression	equal(Expression left, Expression right)
static BinaryExpression	equal(Expression left, Expression right, MethodInfo method)
static BinaryExpression	exclusiveOr(Expression left, Expression right)
static BinaryExpression	exclusiveOr(Expression left, Expression right, MethodInfo method)
static BinaryExpression	exclusiveOrAssign(Expression left, Expression right)
static BinaryExpression	exclusiveOrAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	exclusiveOrAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
static MemberExpression	field(Expression target, FieldInfo field)
static MemberExpression	field(Expression target, java.lang.String fieldName)
static MemberExpression	field(FieldInfo field)
static MemberExpression	field(Type<?> declaringType, java.lang.String fieldName)
private static int	findBestMethod(MemberList<?> methods, TypeList typeArgs, ExpressionList<? extends Expression> arguments)
private static FieldInfo	findField(Type<?> declaringType, java.lang.String fieldName, java.util.Set<BindingFlags> flags)
private static MethodInfo	findMethod(Type<?> type, java.lang.String methodName, TypeList typeArguments, ExpressionList<? extends Expression> arguments, java.util.Set<BindingFlags> flags)
static ForEachExpression	forEach(ParameterExpression variable, Expression sequence, Expression body)
static ForEachExpression	forEach(ParameterExpression variable, Expression sequence, Expression body, LabelTarget breakTarget)
static ForEachExpression	forEach(ParameterExpression variable, Expression sequence, Expression body, LabelTarget breakTarget, LabelTarget continueTarget)
private static MethodInfo	getBinaryOperatorMethod(ExpressionType binaryType, Type<?> leftType, Type<?> rightType, java.lang.String name)
private static MethodInfo	getBinaryOperatorStaticMethod(ExpressionType binaryType, Type<?> leftType, Type<?> rightType, java.lang.String name)
private static BinaryExpression	getCompareMethodBasedBinaryOperator(ExpressionType binaryType, Expression left, Expression right)
private static BinaryExpression	getComparisonOperator(ExpressionType binaryType, Expression left, Expression right)
java.lang.String	getDebugView()
private static BinaryExpression	getEqualityComparisonOperator(ExpressionType binaryType, java.lang.String opName, Expression left, Expression right)
private static BinaryExpression	getEqualsMethodBasedBinaryOperator(ExpressionType binaryType, Expression left, Expression right)
(package private) static MethodInfo	getInvokeMethod(Expression expression)
(package private) static MethodInfo	getInvokeMethod(Type<?> interfaceType, boolean throwOnError)
private static BinaryExpression	getMethodBasedAssignOperator(ExpressionType binaryType, Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
private static BinaryExpression	getMethodBasedAssignOperator(ExpressionType binaryType, java.lang.String name, Expression left, Expression right, LambdaExpression<?> conversion)
private static BinaryExpression	getMethodBasedAssignOperatorOrThrow(ExpressionType binaryType, java.lang.String name, Expression left, Expression right, LambdaExpression<?> conversion)
private static BinaryExpression	getMethodBasedBinaryOperator(ExpressionType binaryType, Expression left, Expression right, MethodInfo method)
private static BinaryExpression	getMethodBasedBinaryOperator(ExpressionType binaryType, java.lang.String name, Expression left, Expression right)
private static BinaryExpression	getMethodBasedBinaryOperatorOrThrow(ExpressionType binaryType, java.lang.String name, Expression left, Expression right)
private static UnaryExpression	getMethodBasedCoercion(ExpressionType coercionType, Expression expression, Type<?> convertToType)
private static UnaryExpression	getMethodBasedCoercionOperator(ExpressionType unaryType, Expression operand, Type<?> convertToType, MethodInfo method)
private static UnaryExpression	getMethodBasedCoercionOrThrow(ExpressionType coercionType, Expression expression, Type<?> convertToType)
private static UnaryExpression	getMethodBasedUnaryOperator(ExpressionType unaryType, Expression operand, MethodInfo method)
private static UnaryExpression	getMethodBasedUnaryOperator(ExpressionType unaryType, java.lang.String methodName, Expression operand)
private static UnaryExpression	getMethodBasedUnaryOperatorOrThrow(ExpressionType unaryType, Expression operand, java.lang.String... methodNames)
private static UnaryExpression	getMethodBasedUnaryOperatorOrThrow(ExpressionType unaryType, java.lang.String methodName, Expression operand)
(package private) static MethodInfo	getMethodValidated(Type<?> type, java.lang.String name, java.util.Set<BindingFlags> bindingFlags, CallingConvention callingConvention, Type<?>... parameterTypes)
ExpressionType	getNodeType()	Returns the node type of this Expression.
private static BinaryExpression	getStaticMethodBasedBinaryOperator(ExpressionType binaryType, Expression left, Expression right, MethodInfo method)
Type<?>	getType()	Gets the static type of the expression that this Expression represents.
static BinaryExpression	greaterThan(Expression left, Expression right)
static BinaryExpression	greaterThan(Expression left, Expression right, MethodInfo method)
static BinaryExpression	greaterThanOrEqual(Expression left, Expression right)
static BinaryExpression	greaterThanOrEqual(Expression left, Expression right, MethodInfo method)
static ConditionalExpression	ifThen(Expression test, Expression ifTrue)
static ConditionalExpression	ifThenElse(Expression test, Expression ifTrue, Expression ifFalse)
static UnaryExpression	increment(Expression expression)
static UnaryExpression	increment(Expression expression, MethodInfo method)
static TypeBinaryExpression	instanceOf(Expression expression, Type<?> type)
static InvocationExpression	invoke(Expression expression, Expression... arguments)
static InvocationExpression	invoke(Expression expression, ExpressionList<? extends Expression> arguments)
private static boolean	isCompatible(MethodBase m, ExpressionList<? extends Expression> arguments)
static UnaryExpression	isFalse(Expression expression)
static UnaryExpression	isFalse(Expression expression, MethodInfo method)
static UnaryExpression	isNotNull(Expression expression)
static UnaryExpression	isNull(Expression expression)
private static boolean	isNullComparison(Expression left, Expression right)
private static boolean	isNullConstant(Expression e)
static UnaryExpression	isTrue(Expression expression)
static UnaryExpression	isTrue(Expression expression, MethodInfo method)
static LabelTarget	label()
static LabelExpression	label(LabelTarget target)
static LabelExpression	label(LabelTarget target, Expression defaultValue)
static LabelTarget	label(Type<?> type)
static LabelTarget	label(Type<?> type, java.lang.String name)
static LabelTarget	label(java.lang.String name)
static LambdaExpression<?>	lambda(Expression body, boolean tailCall, ParameterExpression... parameters)
static LambdaExpression<?>	lambda(Expression body, boolean tailCall, ParameterExpressionList parameters)
static LambdaExpression<?>	lambda(Expression body, ParameterExpression... parameters)
static LambdaExpression<?>	lambda(Expression body, ParameterExpressionList parameters)
static <T> LambdaExpression<T>	lambda(Type<?> interfaceType, Expression body, boolean tailCall, ParameterExpression... parameters)
static <T> LambdaExpression<T>	lambda(Type<?> interfaceType, Expression body, boolean tailCall, ParameterExpressionList parameters)
static <T> LambdaExpression<T>	lambda(Type<?> interfaceType, Expression body, ParameterExpression... parameters)
static <T> LambdaExpression<T>	lambda(Type<?> interfaceType, Expression body, ParameterExpressionList parameters)
static <T> LambdaExpression<T>	lambda(Type<?> interfaceType, java.lang.String name, Expression body, boolean tailCall, ParameterExpression... parameters)
static <T> LambdaExpression<T>	lambda(Type<?> interfaceType, java.lang.String name, Expression body, boolean tailCall, ParameterExpressionList parameters)
static <T> LambdaExpression<T>	lambda(Type<?> interfaceType, java.lang.String name, Expression body, ParameterExpression... parameters)
static LambdaExpression<?>	lambda(java.lang.String name, Expression body, boolean tailCall, ParameterExpression... parameters)
static LambdaExpression<?>	lambda(java.lang.String name, Expression body, ParameterExpression... parameters)
static BinaryExpression	leftShift(Expression left, Expression right)
static BinaryExpression	leftShift(Expression left, Expression right, MethodInfo method)
static BinaryExpression	leftShiftAssign(Expression left, Expression right)
static BinaryExpression	leftShiftAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	leftShiftAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
static BinaryExpression	lessThan(Expression left, Expression right)
static BinaryExpression	lessThan(Expression left, Expression right, MethodInfo method)
static BinaryExpression	lessThanOrEqual(Expression left, Expression right)
static BinaryExpression	lessThanOrEqual(Expression left, Expression right, MethodInfo method)
static LoopExpression	loop(Expression body)
static LoopExpression	loop(Expression body, LabelTarget breakTarget)
static LoopExpression	loop(Expression body, LabelTarget breakTarget, LabelTarget continueLabel)
static BinaryExpression	makeBinary(ExpressionType binaryType, Expression... rest)
static BinaryExpression	makeBinary(ExpressionType binaryType, Expression left, Expression right)
static BinaryExpression	makeBinary(ExpressionType binaryType, Expression first, Expression... rest)
static BinaryExpression	makeBinary(ExpressionType binaryType, Expression left, Expression right, MethodInfo method)
static BinaryExpression	makeBinary(ExpressionType binaryType, Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
static GotoExpression	makeBreak(LabelTarget target)
static GotoExpression	makeBreak(LabelTarget target, Expression value)
static GotoExpression	makeBreak(LabelTarget target, Expression value, Type<?> type)
static GotoExpression	makeBreak(LabelTarget target, Type<?> type)
static CatchBlock	makeCatch(ParameterExpression variable, Expression body)
static CatchBlock	makeCatch(ParameterExpression variable, Expression body, Expression filter)
static CatchBlock	makeCatch(Type<?> type, Expression body)
static CatchBlock	makeCatch(Type<?> type, Expression body, Expression filter)
static CatchBlock	makeCatch(Type<?> type, ParameterExpression variable, Expression body)
static CatchBlock	makeCatch(Type<?> type, ParameterExpression variable, Expression body, Expression filter)
static GotoExpression	makeContinue(LabelTarget target)
static GotoExpression	makeContinue(LabelTarget target, Type<?> type)
static ForExpression	makeFor(ParameterExpression variable, Expression initializer, Expression test, Expression step, Expression body)
static ForExpression	makeFor(ParameterExpression variable, Expression initializer, Expression test, Expression step, Expression body, LabelTarget breakTarget)
static ForExpression	makeFor(ParameterExpression variable, Expression initializer, Expression test, Expression step, Expression body, LabelTarget breakTarget, LabelTarget continueTarget)
static GotoExpression	makeGoto(GotoExpressionKind kind, LabelTarget target, Expression value, Type<?> type)
static GotoExpression	makeGoto(LabelTarget target)
static GotoExpression	makeGoto(LabelTarget target, Expression value)
static GotoExpression	makeGoto(LabelTarget target, Expression value, Type<?> type)
static GotoExpression	makeGoto(LabelTarget target, Type<?> type)
static MemberExpression	makeMemberAccess(Expression target, MemberInfo member)
static NewExpression	makeNew(ConstructorInfo constructor)
static NewExpression	makeNew(ConstructorInfo constructor, Expression... parameters)
static NewExpression	makeNew(ConstructorInfo constructor, ExpressionList<? extends Expression> parameters)
static NewExpression	makeNew(Type<?> type, Expression... parameters)
private static UnaryExpression	makeOpAssignUnary(ExpressionType kind, Expression expression, MethodInfo method)
static GotoExpression	makeReturn(LabelTarget target)
static GotoExpression	makeReturn(LabelTarget target, Expression value)
static GotoExpression	makeReturn(LabelTarget target, Expression value, Type<?> type)
static GotoExpression	makeReturn(LabelTarget target, Type<?> type)
static SwitchExpression	makeSwitch(Expression switchValue, Expression defaultBody, SwitchCase... cases)
static SwitchExpression	makeSwitch(Expression switchValue, Expression defaultBody, MethodInfo comparison, ReadOnlyList<SwitchCase> cases)
static SwitchExpression	makeSwitch(Expression switchValue, Expression defaultBody, MethodInfo comparison, SwitchCase... cases)
static SwitchExpression	makeSwitch(Expression switchValue, SwitchCase... cases)
static SwitchExpression	makeSwitch(Expression switchValue, SwitchOptions options, Expression defaultBody, SwitchCase... cases)
static SwitchExpression	makeSwitch(Expression switchValue, SwitchOptions options, Expression defaultBody, MethodInfo comparison, ReadOnlyList<SwitchCase> cases)
static SwitchExpression	makeSwitch(Expression switchValue, SwitchOptions options, Expression defaultBody, MethodInfo comparison, SwitchCase... cases)
static SwitchExpression	makeSwitch(Expression switchValue, SwitchOptions options, SwitchCase... cases)
static SwitchExpression	makeSwitch(Type<?> type, Expression switchValue, Expression defaultBody, SwitchCase... cases)
static SwitchExpression	makeSwitch(Type<?> type, Expression switchValue, Expression defaultBody, MethodInfo comparison, SwitchCase... cases)
static SwitchExpression	makeSwitch(Type<?> type, Expression switchValue, SwitchOptions options, Expression defaultBody, SwitchCase... cases)
static SwitchExpression	makeSwitch(Type<?> type, Expression switchValue, SwitchOptions options, Expression defaultBody, MethodInfo comparison, ReadOnlyList<SwitchCase> cases)
static SwitchExpression	makeSwitch(Type<?> type, Expression switchValue, SwitchOptions options, Expression defaultBody, MethodInfo comparison, SwitchCase... cases)
static UnaryExpression	makeThrow(Expression expression)
static UnaryExpression	makeThrow(Expression value, Type<?> type)
static TryExpression	makeTry(Type<?> type, Expression body, ReadOnlyList<CatchBlock> catchBlocks, Expression finallyBlock)
static TryExpression	makeTry(Type<?> type, Expression body, CatchBlock... handlers)
static TryExpression	makeTry(Type<?> type, Expression body, Expression finallyBlock, CatchBlock... handlers)
static UnaryExpression	makeUnary(ExpressionType unaryType, Expression operand, Type<?> type)
static UnaryExpression	makeUnary(ExpressionType unaryType, Expression operand, Type<?> type, MethodInfo method)
(package private) static boolean	methodArgumentsMatch(MethodInfo method, Type<?>... argumentTypes)
static BinaryExpression	modulo(Expression left, Expression right)
static BinaryExpression	modulo(Expression left, Expression right, MethodInfo method)
static BinaryExpression	moduloAssign(Expression left, Expression right)
static BinaryExpression	moduloAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	moduloAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
static BinaryExpression	multiply(Expression left, Expression right)
static BinaryExpression	multiply(Expression left, Expression right, MethodInfo method)
static BinaryExpression	multiplyAssign(Expression left, Expression right)
static BinaryExpression	multiplyAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	multiplyAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
static UnaryExpression	negate(Expression expression)
static UnaryExpression	negate(Expression expression, MethodInfo method)
static NewArrayExpression	newArrayBounds(Type<?> elementType, Expression dimension)
static NewArrayExpression	newArrayInit(Type<?> elementType, Expression... initializers)
static NewArrayExpression	newArrayInit(Type<?> elementType, ExpressionList<? extends Expression> initializers)
static UnaryExpression	not(Expression expression)
static UnaryExpression	not(Expression expression, MethodInfo method)
static BinaryExpression	notEqual(Expression left, Expression right)
static BinaryExpression	notEqual(Expression left, Expression right, MethodInfo method)
static UnaryExpression	onesComplement(Expression expression)
static UnaryExpression	onesComplement(Expression expression, MethodInfo method)
static BinaryExpression	or(Expression left, Expression right)
static BinaryExpression	or(Expression left, Expression right, MethodInfo method)
static BinaryExpression	orAssign(Expression left, Expression right)
static BinaryExpression	orAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	orAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
static BinaryExpression	orElse(Expression left, Expression right)
static BinaryExpression	orElse(Expression first, Expression... rest)
static BinaryExpression	orElse(Expression left, Expression right, MethodInfo method)
static ParameterExpression	parameter(Type<?> type)
static ParameterExpression	parameter(Type<?> type, java.lang.String name)
(package private) static boolean	parameterIsAssignable(Type<?> parameterType, Type<?> argumentType)
static ParameterExpressionList	parameters(ParameterExpression... parameters)
(package private) static Type<?>	performBinaryNumericPromotion(Type<?> leftType, Type<?> rightType)
static UnaryExpression	postDecrementAssign(Expression expression)
static UnaryExpression	postDecrementAssign(Expression expression, MethodInfo method)
static UnaryExpression	postIncrementAssign(Expression expression)
static UnaryExpression	postIncrementAssign(Expression expression, MethodInfo method)
static UnaryExpression	preDecrementAssign(Expression expression)
static UnaryExpression	preDecrementAssign(Expression expression, MethodInfo method)
static UnaryExpression	preIncrementAssign(Expression expression)
static UnaryExpression	preIncrementAssign(Expression expression, MethodInfo method)
Expression	reduce()	Reduces this node to a simpler expression.
Expression	reduceAndCheck()	Reduces this node to a simpler expression.
Expression	reduceExtensions()	Reduces the expression to a known node type (i.e.
static BinaryExpression	referenceEqual(Expression left, Expression right)
static BinaryExpression	referenceNotEqual(Expression left, Expression right)
(package private) static <T extends Expression> T	returnObject(java.lang.Class<T> clazz, java.lang.Object objectOrCollection)
static BinaryExpression	rightShift(Expression left, Expression right)
static BinaryExpression	rightShift(Expression left, Expression right, MethodInfo method)
static BinaryExpression	rightShiftAssign(Expression left, Expression right)
static BinaryExpression	rightShiftAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	rightShiftAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
static RuntimeVariablesExpression	runtimeVariables(ParameterExpression... variables)
static RuntimeVariablesExpression	runtimeVariables(ParameterExpressionList variables)
static Expression	self(Type<?> type)
static BinaryExpression	subtract(Expression left, Expression right)
static BinaryExpression	subtract(Expression left, Expression right, MethodInfo method)
static BinaryExpression	subtractAssign(Expression left, Expression right)
static BinaryExpression	subtractAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	subtractAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
static SwitchCase	switchCase(Expression body, Expression... testValues)
static SwitchCase	switchCase(Expression body, ExpressionList<? extends Expression> testValues)
java.lang.String	toString()
static TryExpression	tryCatch(Expression body, CatchBlock... handlers)
static TryExpression	tryCatchFinally(Expression body, Expression finallyBlock, CatchBlock... handlers)
static TryExpression	tryFinally(Expression body, Expression finallyBlock)
static TypeBinaryExpression	typeEqual(Expression expression, Type<?> type)
private static Type<?>[]	types(Expression... expressions)
private static Type<?>[]	types(java.lang.Iterable<? extends Expression> expressions)
static UnaryExpression	unaryPlus(Expression expression)
static UnaryExpression	unaryPlus(Expression expression, MethodInfo method)
static UnaryExpression	unbox(Expression expression)
static UnaryExpression	unbox(Expression expression, Type<?> type)
static BinaryExpression	unsignedRightShift(Expression left, Expression right)
static BinaryExpression	unsignedRightShift(Expression left, Expression right, MethodInfo method)
static BinaryExpression	unsignedRightShiftAssign(Expression left, Expression right)
static BinaryExpression	unsignedRightShiftAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	unsignedRightShiftAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
private static void	validateArgumentCount(MethodBase method, ExpressionType nodeKind, int count, TypeList parameterTypes)
private static <T extends Expression> ExpressionList<T>	validateArgumentTypes(MethodBase method, ExpressionType nodeKind, ExpressionList<T> arguments)
private static void	validateCallTargetType(Type<?> targetType, MethodInfo method)
private static Type<?>	validateCoalesceArgumentTypes(Type<?> left, Type<?> right)
private static void	validateGoto(LabelTarget target, Expression value, java.lang.String targetParameter, java.lang.String valueParameter)
private static void	validateGotoType(Type<?> expectedType, Expression value, java.lang.String valueParameter)
private static <T> void	validateLambdaArgs(Type<T> interfaceType, Expression body, ParameterExpressionList parameters)
private static <T extends Expression> T	validateOneArgument(MethodBase method, ExpressionType nodeKind, T arg, Type<?> parameterType)
private static void	validateOpAssignConversionLambda(LambdaExpression<?> conversion, Expression left, MethodInfo method, ExpressionType nodeType)
private static void	validateOperator(MethodInfo method)
private static void	validateStaticOrInstanceMethod(Expression instance, MethodInfo method)
private static void	validateSwitchCaseType(Expression caseBody, boolean customType, Type<?> resultType, java.lang.String parameterName)
private static void	validateTryAndCatchHaveSameType(Type<?> type, Expression tryBody, ReadOnlyList<CatchBlock> handlers)
(package private) static void	validateVariables(ParameterExpressionList varList, java.lang.String collectionName)
static ParameterExpression	variable(Type<?> type)
static ParameterExpression	variable(Type<?> type, java.lang.String name)
static ParameterExpressionList	variables(ParameterExpression... parameters)
private static void	verifyCanRead(Expression[] items, java.lang.String parameterName)
private static void	verifyCanRead(Expression expression, java.lang.String parameterName)
private static void	verifyCanRead(java.lang.Iterable<? extends Expression> items, java.lang.String parameterName)
private static void	verifyCanWrite(Expression expression, java.lang.String parameterName)
private static void	verifyCanWrite(java.lang.Iterable<? extends Expression> items, java.lang.String parameterName)
private static void	verifyTypeBinaryExpressionOperand(Expression expression, Type<?> type)
protected Expression	visitChildren(ExpressionVisitor visitor)	Reduces the node and then calls the visitor on the reduced expression.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

UNMODIFIABLE_LIST_CLASS

private static final java.lang.Class<?> UNMODIFIABLE_LIST_CLASS

StaticMemberBindingFlags

private static final java.util.Set<BindingFlags> StaticMemberBindingFlags

InstanceMemberBindingFlags

private static final java.util.Set<BindingFlags> InstanceMemberBindingFlags

Constructor Detail

Expression

protected Expression()

Method Detail

getNodeType

public ExpressionType getNodeType()

Returns the node type of this Expression.

Returns:

the ExpressionType that represents this expression.

getType

public Type<?> getType()

Gets the static type of the expression that this Expression represents.

Returns:

the Type that represents the static type of the expression.

canReduce

public boolean canReduce()

Indicates that the node can be reduced to a simpler node. If this returns true, reduce() can be called to produce the reduced form.

Returns:

true if the node can be reduced; otherwise, false.

reduce

public Expression reduce()

Reduces this node to a simpler expression. If canReduce() returns true, this should return a valid expression. This method is allowed to return another node which itself must be reduced.

Returns:

the reduced expression.

reduceAndCheck

public final Expression reduceAndCheck()

Reduces this node to a simpler expression. If canReduce() returns true, this should return a valid expression. This method is allowed to return another node which itself must be reduced. Unlike reduce(), this method checks that the reduced node satisfies certain invariants.

Returns:

the reduced expression.

reduceExtensions

public final Expression reduceExtensions()

Reduces the expression to a known node type (i.e. not an Extension node or simply returns the expression if it is already a known type.

Returns:

the reduced expression.

accept

protected Expression accept(ExpressionVisitor visitor)

Dispatches to the specific visit method for this node type. For example, BinaryExpression will call into ExpressionVisitor.visitBinary().

Parameters:

visitor - the visitor to visit this node.

Returns:

the result of visiting this node.

visitChildren

protected Expression visitChildren(ExpressionVisitor visitor)

Reduces the node and then calls the visitor on the reduced expression. Throws an exception if the node isn't reducible.

Parameters:

visitor - an expression visitor

Returns:

the expression being visited, or an expression which should replace it in the tree.

getDebugView

public final java.lang.String getDebugView()

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object

empty

public static Expression empty()

self

public static Expression self(Type<?> type)

base

public static Expression base(Type<?> type)

label

public static LabelTarget label()

label

public static LabelTarget label(java.lang.String name)

label

public static LabelTarget label(Type<?> type)

label

public static LabelTarget label(Type<?> type,
                                java.lang.String name)

label

public static LabelExpression label(LabelTarget target)

label

public static LabelExpression label(LabelTarget target,
                                    Expression defaultValue)

makeBreak

public static GotoExpression makeBreak(LabelTarget target)

makeBreak

public static GotoExpression makeBreak(LabelTarget target,
                                       Expression value)

makeBreak

public static GotoExpression makeBreak(LabelTarget target,
                                       Type<?> type)

makeBreak

public static GotoExpression makeBreak(LabelTarget target,
                                       Expression value,
                                       Type<?> type)

makeContinue

public static GotoExpression makeContinue(LabelTarget target)

makeContinue

public static GotoExpression makeContinue(LabelTarget target,
                                          Type<?> type)

makeReturn

public static GotoExpression makeReturn(LabelTarget target)

makeReturn

public static GotoExpression makeReturn(LabelTarget target,
                                        Type<?> type)

makeReturn

public static GotoExpression makeReturn(LabelTarget target,
                                        Expression value)

makeReturn

public static GotoExpression makeReturn(LabelTarget target,
                                        Expression value,
                                        Type<?> type)

makeGoto

public static GotoExpression makeGoto(LabelTarget target)

makeGoto

public static GotoExpression makeGoto(LabelTarget target,
                                      Type<?> type)

makeGoto

public static GotoExpression makeGoto(LabelTarget target,
                                      Expression value)

makeGoto

public static GotoExpression makeGoto(LabelTarget target,
                                      Expression value,
                                      Type<?> type)

makeGoto

public static GotoExpression makeGoto(GotoExpressionKind kind,
                                      LabelTarget target,
                                      Expression value,
                                      Type<?> type)

loop

public static LoopExpression loop(Expression body)

loop

public static LoopExpression loop(Expression body,
                                  LabelTarget breakTarget)

loop

public static LoopExpression loop(Expression body,
                                  LabelTarget breakTarget,
                                  LabelTarget continueLabel)

forEach

public static ForEachExpression forEach(ParameterExpression variable,
                                        Expression sequence,
                                        Expression body)

forEach

public static ForEachExpression forEach(ParameterExpression variable,
                                        Expression sequence,
                                        Expression body,
                                        LabelTarget breakTarget)

forEach

public static ForEachExpression forEach(ParameterExpression variable,
                                        Expression sequence,
                                        Expression body,
                                        LabelTarget breakTarget,
                                        LabelTarget continueTarget)

makeFor

public static ForExpression makeFor(ParameterExpression variable,
                                    Expression initializer,
                                    Expression test,
                                    Expression step,
                                    Expression body)

makeFor

public static ForExpression makeFor(ParameterExpression variable,
                                    Expression initializer,
                                    Expression test,
                                    Expression step,
                                    Expression body,
                                    LabelTarget breakTarget)

makeFor

public static ForExpression makeFor(ParameterExpression variable,
                                    Expression initializer,
                                    Expression test,
                                    Expression step,
                                    Expression body,
                                    LabelTarget breakTarget,
                                    LabelTarget continueTarget)

makeNew

public static NewExpression makeNew(Type<?> type,
                                    Expression... parameters)

makeNew

public static NewExpression makeNew(ConstructorInfo constructor)

makeNew

public static NewExpression makeNew(ConstructorInfo constructor,
                                    Expression... parameters)

makeNew

public static NewExpression makeNew(ConstructorInfo constructor,
                                    ExpressionList<? extends Expression> parameters)

newArrayInit

public static NewArrayExpression newArrayInit(Type<?> elementType,
                                              Expression... initializers)

newArrayInit

public static NewArrayExpression newArrayInit(Type<?> elementType,
                                              ExpressionList<? extends Expression> initializers)

newArrayBounds

public static NewArrayExpression newArrayBounds(Type<?> elementType,
                                                Expression dimension)

concat

public static ConcatExpression concat(Expression first,
                                      Expression second)

concat

public static ConcatExpression concat(Expression first,
                                      Expression second,
                                      Expression... operands)

concat

public static ConcatExpression concat(ExpressionList<? extends Expression> operands)

makeCatch

public static CatchBlock makeCatch(Type<?> type,
                                   Expression body)

makeCatch

public static CatchBlock makeCatch(ParameterExpression variable,
                                   Expression body)

makeCatch

public static CatchBlock makeCatch(Type<?> type,
                                   Expression body,
                                   Expression filter)

makeCatch

public static CatchBlock makeCatch(ParameterExpression variable,
                                   Expression body,
                                   Expression filter)

makeCatch

public static CatchBlock makeCatch(Type<?> type,
                                   ParameterExpression variable,
                                   Expression body,
                                   Expression filter)

makeCatch

public static CatchBlock makeCatch(Type<?> type,
                                   ParameterExpression variable,
                                   Expression body)

tryFinally

public static TryExpression tryFinally(Expression body,
                                       Expression finallyBlock)

tryCatch

public static TryExpression tryCatch(Expression body,
                                     CatchBlock... handlers)

makeTry

public static TryExpression makeTry(Type<?> type,
                                    Expression body,
                                    CatchBlock... handlers)

tryCatchFinally

public static TryExpression tryCatchFinally(Expression body,
                                            Expression finallyBlock,
                                            CatchBlock... handlers)

makeTry

public static TryExpression makeTry(Type<?> type,
                                    Expression body,
                                    Expression finallyBlock,
                                    CatchBlock... handlers)

makeTry

public static TryExpression makeTry(Type<?> type,
                                    Expression body,
                                    ReadOnlyList<CatchBlock> catchBlocks,
                                    Expression finallyBlock)

runtimeVariables

public static RuntimeVariablesExpression runtimeVariables(ParameterExpression... variables)

runtimeVariables

public static RuntimeVariablesExpression runtimeVariables(ParameterExpressionList variables)

condition

public static ConditionalExpression condition(Expression test,
                                              Expression ifTrue,
                                              Expression ifFalse)

condition

public static ConditionalExpression condition(Expression test,
                                              Expression ifTrue,
                                              Expression ifFalse,
                                              Type<?> type)

ifThen

public static ConditionalExpression ifThen(Expression test,
                                           Expression ifTrue)

ifThenElse

public static ConditionalExpression ifThenElse(Expression test,
                                               Expression ifTrue,
                                               Expression ifFalse)

makeMemberAccess

public static MemberExpression makeMemberAccess(Expression target,
                                                MemberInfo member)

field

public static MemberExpression field(Expression target,
                                     FieldInfo field)

field

public static MemberExpression field(FieldInfo field)

field

public static MemberExpression field(Type<?> declaringType,
                                     java.lang.String fieldName)

field

public static MemberExpression field(Expression target,
                                     java.lang.String fieldName)

constant

public static ConstantExpression constant(java.lang.Object value)

constant

public static ConstantExpression constant(java.lang.Object value,
                                          Type<?> type)

classConstant

public static ConstantExpression classConstant(Type<?> value)

parameters

public static ParameterExpressionList parameters(ParameterExpression... parameters)

variables

public static ParameterExpressionList variables(ParameterExpression... parameters)

parameter

public static ParameterExpression parameter(Type<?> type)

variable

public static ParameterExpression variable(Type<?> type)

parameter

public static ParameterExpression parameter(Type<?> type,
                                            java.lang.String name)

variable

public static ParameterExpression variable(Type<?> type,
                                           java.lang.String name)

makeUnary

public static UnaryExpression makeUnary(ExpressionType unaryType,
                                        Expression operand,
                                        Type<?> type)

makeUnary

public static UnaryExpression makeUnary(ExpressionType unaryType,
                                        Expression operand,
                                        Type<?> type,
                                        MethodInfo method)

negate

public static UnaryExpression negate(Expression expression)

negate

public static UnaryExpression negate(Expression expression,
                                     MethodInfo method)

not

public static UnaryExpression not(Expression expression)

not

public static UnaryExpression not(Expression expression,
                                  MethodInfo method)

isFalse

public static UnaryExpression isFalse(Expression expression)

isFalse

public static UnaryExpression isFalse(Expression expression,
                                      MethodInfo method)

isTrue

public static UnaryExpression isTrue(Expression expression)

isTrue

public static UnaryExpression isTrue(Expression expression,
                                     MethodInfo method)

onesComplement

public static UnaryExpression onesComplement(Expression expression)

onesComplement

public static UnaryExpression onesComplement(Expression expression,
                                             MethodInfo method)

arrayLength

public static UnaryExpression arrayLength(Expression array)

convert

public static UnaryExpression convert(Expression expression,
                                      Type<?> type)

convert

public static UnaryExpression convert(Expression expression,
                                      Type<?> type,
                                      MethodInfo method)

isNull

public static UnaryExpression isNull(Expression expression)

isNotNull

public static UnaryExpression isNotNull(Expression expression)

makeThrow

public static UnaryExpression makeThrow(Expression expression)

makeThrow

public static UnaryExpression makeThrow(Expression value,
                                        Type<?> type)

unaryPlus

public static UnaryExpression unaryPlus(Expression expression)

unaryPlus

public static UnaryExpression unaryPlus(Expression expression,
                                        MethodInfo method)

box

public static Expression box(Expression expression)

unbox

public static UnaryExpression unbox(Expression expression)

unbox

public static UnaryExpression unbox(Expression expression,
                                    Type<?> type)

increment

public static UnaryExpression increment(Expression expression)

increment

public static UnaryExpression increment(Expression expression,
                                        MethodInfo method)

decrement

public static UnaryExpression decrement(Expression expression)

decrement

public static UnaryExpression decrement(Expression expression,
                                        MethodInfo method)

preIncrementAssign

public static UnaryExpression preIncrementAssign(Expression expression)

preIncrementAssign

public static UnaryExpression preIncrementAssign(Expression expression,
                                                 MethodInfo method)

postIncrementAssign

public static UnaryExpression postIncrementAssign(Expression expression)

postIncrementAssign

public static UnaryExpression postIncrementAssign(Expression expression,
                                                  MethodInfo method)

preDecrementAssign

public static UnaryExpression preDecrementAssign(Expression expression)

preDecrementAssign

public static UnaryExpression preDecrementAssign(Expression expression,
                                                 MethodInfo method)

postDecrementAssign

public static UnaryExpression postDecrementAssign(Expression expression)

postDecrementAssign

public static UnaryExpression postDecrementAssign(Expression expression,
                                                  MethodInfo method)

block

public static BlockExpression block(Expression arg0,
                                    Expression arg1)

block

public static BlockExpression block(Expression arg0,
                                    Expression arg1,
                                    Expression arg2)

block

public static BlockExpression block(Expression arg0,
                                    Expression arg1,
                                    Expression arg2,
                                    Expression arg3)

block

public static BlockExpression block(Expression arg0,
                                    Expression arg1,
                                    Expression arg2,
                                    Expression arg3,
                                    Expression arg4)

block

public static BlockExpression block(Expression... expressions)

block

public static BlockExpression block(ExpressionList<? extends Expression> expressions)

block

public static BlockExpression block(ParameterExpression[] variables,
                                    Expression... expressions)

block

public static BlockExpression block(ParameterExpressionList variables,
                                    Expression... expressions)

block

public static BlockExpression block(ParameterExpressionList variables,
                                    ExpressionList<? extends Expression> expressions)

block

public static BlockExpression block(Type<?> type,
                                    Expression... expressions)

block

public static BlockExpression block(Type<?> type,
                                    ExpressionList<? extends Expression> expressions)

block

public static BlockExpression block(Type<?> type,
                                    ParameterExpression[] variables,
                                    Expression... expressions)

block

public static BlockExpression block(Type<?> type,
                                    ParameterExpressionList variables,
                                    Expression... expressions)

block

public static BlockExpression block(Type<?> type,
                                    ParameterExpressionList variables,
                                    ExpressionList<? extends Expression> expressions)

makeBinary

public static BinaryExpression makeBinary(ExpressionType binaryType,
                                          Expression... rest)

makeBinary

public static BinaryExpression makeBinary(ExpressionType binaryType,
                                          Expression first,
                                          Expression... rest)

makeBinary

public static BinaryExpression makeBinary(ExpressionType binaryType,
                                          Expression left,
                                          Expression right)

makeBinary

public static BinaryExpression makeBinary(ExpressionType binaryType,
                                          Expression left,
                                          Expression right,
                                          MethodInfo method)

makeBinary

public static BinaryExpression makeBinary(ExpressionType binaryType,
                                          Expression left,
                                          Expression right,
                                          MethodInfo method,
                                          LambdaExpression<?> conversion)

add

public static BinaryExpression add(Expression left,
                                   Expression right)

add

public static BinaryExpression add(Expression left,
                                   Expression right,
                                   MethodInfo method)

coalesce

public static BinaryExpression coalesce(Expression left,
                                        Expression right)

coalesce

public static BinaryExpression coalesce(Expression left,
                                        Expression right,
                                        LambdaExpression<?> conversion)

subtract

public static BinaryExpression subtract(Expression left,
                                        Expression right)

subtract

public static BinaryExpression subtract(Expression left,
                                        Expression right,
                                        MethodInfo method)

multiply

public static BinaryExpression multiply(Expression left,
                                        Expression right)

multiply

public static BinaryExpression multiply(Expression left,
                                        Expression right,
                                        MethodInfo method)

divide

public static BinaryExpression divide(Expression left,
                                      Expression right)

divide

public static BinaryExpression divide(Expression left,
                                      Expression right,
                                      MethodInfo method)

modulo

public static BinaryExpression modulo(Expression left,
                                      Expression right)

modulo

public static BinaryExpression modulo(Expression left,
                                      Expression right,
                                      MethodInfo method)

leftShift

public static BinaryExpression leftShift(Expression left,
                                         Expression right)

leftShift

public static BinaryExpression leftShift(Expression left,
                                         Expression right,
                                         MethodInfo method)

rightShift

public static BinaryExpression rightShift(Expression left,
                                          Expression right)

rightShift

public static BinaryExpression rightShift(Expression left,
                                          Expression right,
                                          MethodInfo method)

unsignedRightShift

public static BinaryExpression unsignedRightShift(Expression left,
                                                  Expression right)

unsignedRightShift

public static BinaryExpression unsignedRightShift(Expression left,
                                                  Expression right,
                                                  MethodInfo method)

and

public static BinaryExpression and(Expression left,
                                   Expression right)

and

public static BinaryExpression and(Expression left,
                                   Expression right,
                                   MethodInfo method)

or

public static BinaryExpression or(Expression left,
                                  Expression right)

or

public static BinaryExpression or(Expression left,
                                  Expression right,
                                  MethodInfo method)

exclusiveOr

public static BinaryExpression exclusiveOr(Expression left,
                                           Expression right)

exclusiveOr

public static BinaryExpression exclusiveOr(Expression left,
                                           Expression right,
                                           MethodInfo method)

andAlso

public static BinaryExpression andAlso(Expression left,
                                       Expression right)

andAlso

public static BinaryExpression andAlso(Expression first,
                                       Expression... rest)

andAlso

public static BinaryExpression andAlso(Expression left,
                                       Expression right,
                                       MethodInfo method)

orElse

public static BinaryExpression orElse(Expression left,
                                      Expression right)

orElse

public static BinaryExpression orElse(Expression first,
                                      Expression... rest)

orElse

public static BinaryExpression orElse(Expression left,
                                      Expression right,
                                      MethodInfo method)

lessThan

public static BinaryExpression lessThan(Expression left,
                                        Expression right)

lessThan

public static BinaryExpression lessThan(Expression left,
                                        Expression right,
                                        MethodInfo method)

lessThanOrEqual

public static BinaryExpression lessThanOrEqual(Expression left,
                                               Expression right)

lessThanOrEqual

public static BinaryExpression lessThanOrEqual(Expression left,
                                               Expression right,
                                               MethodInfo method)

greaterThan

public static BinaryExpression greaterThan(Expression left,
                                           Expression right)

greaterThan

public static BinaryExpression greaterThan(Expression left,
                                           Expression right,
                                           MethodInfo method)

greaterThanOrEqual

public static BinaryExpression greaterThanOrEqual(Expression left,
                                                  Expression right)

greaterThanOrEqual

public static BinaryExpression greaterThanOrEqual(Expression left,
                                                  Expression right,
                                                  MethodInfo method)

equal

public static BinaryExpression equal(Expression left,
                                     Expression right)

equal

public static BinaryExpression equal(Expression left,
                                     Expression right,
                                     MethodInfo method)

notEqual

public static BinaryExpression notEqual(Expression left,
                                        Expression right)

notEqual

public static BinaryExpression notEqual(Expression left,
                                        Expression right,
                                        MethodInfo method)

referenceEqual

public static BinaryExpression referenceEqual(Expression left,
                                              Expression right)

referenceNotEqual

public static BinaryExpression referenceNotEqual(Expression left,
                                                 Expression right)

arrayIndex

public static BinaryExpression arrayIndex(Expression array,
                                          Expression index)

assign

public static BinaryExpression assign(Expression left,
                                      Expression right)

addAssign

public static BinaryExpression addAssign(Expression left,
                                         Expression right)

addAssign

public static BinaryExpression addAssign(Expression left,
                                         Expression right,
                                         MethodInfo method)

addAssign

public static BinaryExpression addAssign(Expression left,
                                         Expression right,
                                         MethodInfo method,
                                         LambdaExpression<?> conversion)

subtractAssign

public static BinaryExpression subtractAssign(Expression left,
                                              Expression right)

subtractAssign

public static BinaryExpression subtractAssign(Expression left,
                                              Expression right,
                                              MethodInfo method)

subtractAssign

public static BinaryExpression subtractAssign(Expression left,
                                              Expression right,
                                              MethodInfo method,
                                              LambdaExpression<?> conversion)

multiplyAssign

public static BinaryExpression multiplyAssign(Expression left,
                                              Expression right)

multiplyAssign

public static BinaryExpression multiplyAssign(Expression left,
                                              Expression right,
                                              MethodInfo method)

multiplyAssign

public static BinaryExpression multiplyAssign(Expression left,
                                              Expression right,
                                              MethodInfo method,
                                              LambdaExpression<?> conversion)

divideAssign

public static BinaryExpression divideAssign(Expression left,
                                            Expression right)

divideAssign

public static BinaryExpression divideAssign(Expression left,
                                            Expression right,
                                            MethodInfo method)

divideAssign

public static BinaryExpression divideAssign(Expression left,
                                            Expression right,
                                            MethodInfo method,
                                            LambdaExpression<?> conversion)

moduloAssign

public static BinaryExpression moduloAssign(Expression left,
                                            Expression right)

moduloAssign

public static BinaryExpression moduloAssign(Expression left,
                                            Expression right,
                                            MethodInfo method)

moduloAssign

public static BinaryExpression moduloAssign(Expression left,
                                            Expression right,
                                            MethodInfo method,
                                            LambdaExpression<?> conversion)

leftShiftAssign

public static BinaryExpression leftShiftAssign(Expression left,
                                               Expression right)

leftShiftAssign

public static BinaryExpression leftShiftAssign(Expression left,
                                               Expression right,
                                               MethodInfo method)

leftShiftAssign

public static BinaryExpression leftShiftAssign(Expression left,
                                               Expression right,
                                               MethodInfo method,
                                               LambdaExpression<?> conversion)

rightShiftAssign

public static BinaryExpression rightShiftAssign(Expression left,
                                                Expression right)

rightShiftAssign

public static BinaryExpression rightShiftAssign(Expression left,
                                                Expression right,
                                                MethodInfo method)

rightShiftAssign

public static BinaryExpression rightShiftAssign(Expression left,
                                                Expression right,
                                                MethodInfo method,
                                                LambdaExpression<?> conversion)

unsignedRightShiftAssign

public static BinaryExpression unsignedRightShiftAssign(Expression left,
                                                        Expression right)

unsignedRightShiftAssign

public static BinaryExpression unsignedRightShiftAssign(Expression left,
                                                        Expression right,
                                                        MethodInfo method)

unsignedRightShiftAssign

public static BinaryExpression unsignedRightShiftAssign(Expression left,
                                                        Expression right,
                                                        MethodInfo method,
                                                        LambdaExpression<?> conversion)

orAssign

public static BinaryExpression orAssign(Expression left,
                                        Expression right)

orAssign

public static BinaryExpression orAssign(Expression left,
                                        Expression right,
                                        MethodInfo method)

orAssign

public static BinaryExpression orAssign(Expression left,
                                        Expression right,
                                        MethodInfo method,
                                        LambdaExpression<?> conversion)

andAssign

public static BinaryExpression andAssign(Expression left,
                                         Expression right)

andAssign

public static BinaryExpression andAssign(Expression left,
                                         Expression right,
                                         MethodInfo method)

andAssign

public static BinaryExpression andAssign(Expression left,
                                         Expression right,
                                         MethodInfo method,
                                         LambdaExpression<?> conversion)

exclusiveOrAssign

public static BinaryExpression exclusiveOrAssign(Expression left,
                                                 Expression right)

exclusiveOrAssign

public static BinaryExpression exclusiveOrAssign(Expression left,
                                                 Expression right,
                                                 MethodInfo method)

exclusiveOrAssign

public static BinaryExpression exclusiveOrAssign(Expression left,
                                                 Expression right,
                                                 MethodInfo method,
                                                 LambdaExpression<?> conversion)

instanceOf

public static TypeBinaryExpression instanceOf(Expression expression,
                                              Type<?> type)

typeEqual

public static TypeBinaryExpression typeEqual(Expression expression,
                                             Type<?> type)

lambda

public static LambdaExpression<?> lambda(java.lang.String name,
                                         Expression body,
                                         ParameterExpression... parameters)

lambda

public static LambdaExpression<?> lambda(Expression body,
                                         ParameterExpression... parameters)

lambda

public static LambdaExpression<?> lambda(Expression body,
                                         boolean tailCall,
                                         ParameterExpression... parameters)

lambda

public static LambdaExpression<?> lambda(java.lang.String name,
                                         Expression body,
                                         boolean tailCall,
                                         ParameterExpression... parameters)

lambda

public static LambdaExpression<?> lambda(Expression body,
                                         ParameterExpressionList parameters)

lambda

public static LambdaExpression<?> lambda(Expression body,
                                         boolean tailCall,
                                         ParameterExpressionList parameters)

lambda

public static <T> LambdaExpression<T> lambda(Type<?> interfaceType,
                                             java.lang.String name,
                                             Expression body,
                                             ParameterExpression... parameters)

lambda

public static <T> LambdaExpression<T> lambda(Type<?> interfaceType,
                                             Expression body,
                                             ParameterExpression... parameters)

lambda

public static <T> LambdaExpression<T> lambda(Type<?> interfaceType,
                                             Expression body,
                                             boolean tailCall,
                                             ParameterExpression... parameters)

lambda

public static <T> LambdaExpression<T> lambda(Type<?> interfaceType,
                                             java.lang.String name,
                                             Expression body,
                                             boolean tailCall,
                                             ParameterExpression... parameters)

lambda

public static <T> LambdaExpression<T> lambda(Type<?> interfaceType,
                                             Expression body,
                                             ParameterExpressionList parameters)

lambda

public static <T> LambdaExpression<T> lambda(Type<?> interfaceType,
                                             Expression body,
                                             boolean tailCall,
                                             ParameterExpressionList parameters)

lambda

public static <T> LambdaExpression<T> lambda(Type<?> interfaceType,
                                             java.lang.String name,
                                             Expression body,
                                             boolean tailCall,
                                             ParameterExpressionList parameters)

invoke

public static InvocationExpression invoke(Expression expression,
                                          Expression... arguments)

invoke

public static InvocationExpression invoke(Expression expression,
                                          ExpressionList<? extends Expression> arguments)

call

public static MethodCallExpression call(MethodInfo method,
                                        Expression... arguments)

call

public static MethodCallExpression call(MethodInfo method,
                                        ExpressionList<? extends Expression> arguments)

call

public static MethodCallExpression call(Expression target,
                                        MethodInfo method,
                                        Expression... arguments)

call

public static MethodCallExpression call(Expression target,
                                        MethodInfo method,
                                        ExpressionList<? extends Expression> arguments)

call

public static MethodCallExpression call(Expression target,
                                        java.lang.String methodName,
                                        Expression... arguments)

call

public static MethodCallExpression call(Expression target,
                                        java.lang.String methodName,
                                        TypeList typeArguments,
                                        Expression... arguments)

call

public static MethodCallExpression call(Expression target,
                                        java.lang.String methodName,
                                        TypeList typeArguments,
                                        ExpressionList<? extends Expression> arguments)

call

public static MethodCallExpression call(Type<?> declaringType,
                                        java.lang.String methodName,
                                        Expression... arguments)

call

public static MethodCallExpression call(Type<?> declaringType,
                                        java.lang.String methodName,
                                        TypeList typeArguments,
                                        Expression... arguments)

call

public static MethodCallExpression call(Type<?> declaringType,
                                        java.lang.String methodName,
                                        TypeList typeArguments,
                                        ExpressionList<? extends Expression> arguments)

adaptArguments

private static ExpressionList<? extends Expression> adaptArguments(MethodInfo method,
                                                                   ExpressionList<? extends Expression> arguments)

defaultValue

public static DefaultValueExpression defaultValue(Type<?> type)

switchCase

public static SwitchCase switchCase(Expression body,
                                    Expression... testValues)

switchCase

public static SwitchCase switchCase(Expression body,
                                    ExpressionList<? extends Expression> testValues)

makeSwitch

public static SwitchExpression makeSwitch(Expression switchValue,
                                          SwitchCase... cases)

makeSwitch

public static SwitchExpression makeSwitch(Expression switchValue,
                                          SwitchOptions options,
                                          SwitchCase... cases)

makeSwitch

public static SwitchExpression makeSwitch(Expression switchValue,
                                          Expression defaultBody,
                                          SwitchCase... cases)

makeSwitch

public static SwitchExpression makeSwitch(Expression switchValue,
                                          SwitchOptions options,
                                          Expression defaultBody,
                                          SwitchCase... cases)

makeSwitch

public static SwitchExpression makeSwitch(Expression switchValue,
                                          Expression defaultBody,
                                          MethodInfo comparison,
                                          SwitchCase... cases)

makeSwitch

public static SwitchExpression makeSwitch(Type<?> type,
                                          Expression switchValue,
                                          Expression defaultBody,
                                          SwitchCase... cases)

makeSwitch

public static SwitchExpression makeSwitch(Expression switchValue,
                                          SwitchOptions options,
                                          Expression defaultBody,
                                          MethodInfo comparison,
                                          SwitchCase... cases)

makeSwitch

public static SwitchExpression makeSwitch(Type<?> type,
                                          Expression switchValue,
                                          SwitchOptions options,
                                          Expression defaultBody,
                                          SwitchCase... cases)

makeSwitch

public static SwitchExpression makeSwitch(Type<?> type,
                                          Expression switchValue,
                                          Expression defaultBody,
                                          MethodInfo comparison,
                                          SwitchCase... cases)

makeSwitch

public static SwitchExpression makeSwitch(Type<?> type,
                                          Expression switchValue,
                                          SwitchOptions options,
                                          Expression defaultBody,
                                          MethodInfo comparison,
                                          SwitchCase... cases)

makeSwitch

public static SwitchExpression makeSwitch(Expression switchValue,
                                          Expression defaultBody,
                                          MethodInfo comparison,
                                          ReadOnlyList<SwitchCase> cases)

makeSwitch

public static SwitchExpression makeSwitch(Expression switchValue,
                                          SwitchOptions options,
                                          Expression defaultBody,
                                          MethodInfo comparison,
                                          ReadOnlyList<SwitchCase> cases)

makeSwitch

public static SwitchExpression makeSwitch(Type<?> type,
                                          Expression switchValue,
                                          SwitchOptions options,
                                          Expression defaultBody,
                                          MethodInfo comparison,
                                          ReadOnlyList<SwitchCase> cases)

arrayToList

static <T extends Expression> ExpressionList<T> arrayToList(T[] expressions)

arrayToReadOnlyList

static <T> ReadOnlyList<T> arrayToReadOnlyList(T[] items)

arrayToList

static ParameterExpressionList arrayToList(ParameterExpression[] parameters)

verifyCanRead

private static void verifyCanRead(Expression expression,
                                  java.lang.String parameterName)

verifyCanRead

private static void verifyCanRead(java.lang.Iterable<? extends Expression> items,
                                  java.lang.String parameterName)

verifyCanRead

private static void verifyCanRead(Expression[] items,
                                  java.lang.String parameterName)

verifyCanWrite

private static void verifyCanWrite(Expression expression,
                                   java.lang.String parameterName)

verifyCanWrite

private static void verifyCanWrite(java.lang.Iterable<? extends Expression> items,
                                   java.lang.String parameterName)

validateVariables

static void validateVariables(ParameterExpressionList varList,
                              java.lang.String collectionName)

getMethodBasedUnaryOperator

private static UnaryExpression getMethodBasedUnaryOperator(ExpressionType unaryType,
                                                           Expression operand,
                                                           MethodInfo method)

getMethodBasedUnaryOperatorOrThrow

private static UnaryExpression getMethodBasedUnaryOperatorOrThrow(ExpressionType unaryType,
                                                                  java.lang.String methodName,
                                                                  Expression operand)

getMethodBasedUnaryOperatorOrThrow

private static UnaryExpression getMethodBasedUnaryOperatorOrThrow(ExpressionType unaryType,
                                                                  Expression operand,
                                                                  java.lang.String... methodNames)

getMethodBasedUnaryOperator

private static UnaryExpression getMethodBasedUnaryOperator(ExpressionType unaryType,
                                                           java.lang.String methodName,
                                                           Expression operand)

validateOperator

private static void validateOperator(MethodInfo method)

getMethodBasedCoercionOrThrow

private static UnaryExpression getMethodBasedCoercionOrThrow(ExpressionType coercionType,
                                                             Expression expression,
                                                             Type<?> convertToType)

getMethodBasedCoercion

private static UnaryExpression getMethodBasedCoercion(ExpressionType coercionType,
                                                      Expression expression,
                                                      Type<?> convertToType)

getMethodBasedCoercionOperator

private static UnaryExpression getMethodBasedCoercionOperator(ExpressionType unaryType,
                                                              Expression operand,
                                                              Type<?> convertToType,
                                                              MethodInfo method)

makeOpAssignUnary

private static UnaryExpression makeOpAssignUnary(ExpressionType kind,
                                                 Expression expression,
                                                 MethodInfo method)

parameterIsAssignable

static boolean parameterIsAssignable(Type<?> parameterType,
                                     Type<?> argumentType)

getMethodValidated

static MethodInfo getMethodValidated(Type<?> type,
                                     java.lang.String name,
                                     java.util.Set<BindingFlags> bindingFlags,
                                     CallingConvention callingConvention,
                                     Type<?>... parameterTypes)

methodArgumentsMatch

static boolean methodArgumentsMatch(MethodInfo method,
                                    Type<?>... argumentTypes)

ensureUnmodifiable

static <T> java.util.List<T> ensureUnmodifiable(java.util.List<T> list)

returnObject

static <T extends Expression> T returnObject(java.lang.Class<T> clazz,
                                             java.lang.Object objectOrCollection)

aggregateBinary

private static BinaryExpression aggregateBinary(ExpressionType binaryType,
                                                ImmutableList<Expression> operands)

verifyTypeBinaryExpressionOperand

private static void verifyTypeBinaryExpressionOperand(Expression expression,
                                                      Type<?> type)

getInvokeMethod

static MethodInfo getInvokeMethod(Expression expression)

getInvokeMethod

static MethodInfo getInvokeMethod(Type<?> interfaceType,
                                  boolean throwOnError)

getEqualityComparisonOperator

private static BinaryExpression getEqualityComparisonOperator(ExpressionType binaryType,
                                                              java.lang.String opName,
                                                              Expression left,
                                                              Expression right)

getBinaryOperatorMethod

private static MethodInfo getBinaryOperatorMethod(ExpressionType binaryType,
                                                  Type<?> leftType,
                                                  Type<?> rightType,
                                                  java.lang.String name)

getBinaryOperatorStaticMethod

private static MethodInfo getBinaryOperatorStaticMethod(ExpressionType binaryType,
                                                        Type<?> leftType,
                                                        Type<?> rightType,
                                                        java.lang.String name)

getMethodBasedBinaryOperator

private static BinaryExpression getMethodBasedBinaryOperator(ExpressionType binaryType,
                                                             java.lang.String name,
                                                             Expression left,
                                                             Expression right)

getCompareMethodBasedBinaryOperator

private static BinaryExpression getCompareMethodBasedBinaryOperator(ExpressionType binaryType,
                                                                    Expression left,
                                                                    Expression right)

getEqualsMethodBasedBinaryOperator

private static BinaryExpression getEqualsMethodBasedBinaryOperator(ExpressionType binaryType,
                                                                   Expression left,
                                                                   Expression right)

getMethodBasedBinaryOperator

private static BinaryExpression getMethodBasedBinaryOperator(ExpressionType binaryType,
                                                             Expression left,
                                                             Expression right,
                                                             MethodInfo method)

getStaticMethodBasedBinaryOperator

private static BinaryExpression getStaticMethodBasedBinaryOperator(ExpressionType binaryType,
                                                                   Expression left,
                                                                   Expression right,
                                                                   MethodInfo method)

getMethodBasedBinaryOperatorOrThrow

private static BinaryExpression getMethodBasedBinaryOperatorOrThrow(ExpressionType binaryType,
                                                                    java.lang.String name,
                                                                    Expression left,
                                                                    Expression right)

getMethodBasedAssignOperator

private static BinaryExpression getMethodBasedAssignOperator(ExpressionType binaryType,
                                                             java.lang.String name,
                                                             Expression left,
                                                             Expression right,
                                                             LambdaExpression<?> conversion)

getMethodBasedAssignOperatorOrThrow

private static BinaryExpression getMethodBasedAssignOperatorOrThrow(ExpressionType binaryType,
                                                                    java.lang.String name,
                                                                    Expression left,
                                                                    Expression right,
                                                                    LambdaExpression<?> conversion)

getMethodBasedAssignOperator

private static BinaryExpression getMethodBasedAssignOperator(ExpressionType binaryType,
                                                             Expression left,
                                                             Expression right,
                                                             MethodInfo method,
                                                             LambdaExpression<?> conversion)

validateOpAssignConversionLambda

private static void validateOpAssignConversionLambda(LambdaExpression<?> conversion,
                                                     Expression left,
                                                     MethodInfo method,
                                                     ExpressionType nodeType)

getComparisonOperator

private static BinaryExpression getComparisonOperator(ExpressionType binaryType,
                                                      Expression left,
                                                      Expression right)

isNullConstant

private static boolean isNullConstant(Expression e)

isNullComparison

private static boolean isNullComparison(Expression left,
                                        Expression right)

validateStaticOrInstanceMethod

private static void validateStaticOrInstanceMethod(Expression instance,
                                                   MethodInfo method)

validateCallTargetType

private static void validateCallTargetType(Type<?> targetType,
                                           MethodInfo method)

validateArgumentTypes

private static <T extends Expression> ExpressionList<T> validateArgumentTypes(MethodBase method,
                                                                              ExpressionType nodeKind,
                                                                              ExpressionList<T> arguments)

validateOneArgument

private static <T extends Expression> T validateOneArgument(MethodBase method,
                                                            ExpressionType nodeKind,
                                                            T arg,
                                                            Type<?> parameterType)

validateArgumentCount

private static void validateArgumentCount(MethodBase method,
                                          ExpressionType nodeKind,
                                          int count,
                                          TypeList parameterTypes)

validateLambdaArgs

private static <T> void validateLambdaArgs(Type<T> interfaceType,
                                           Expression body,
                                           ParameterExpressionList parameters)

validateGoto

private static void validateGoto(LabelTarget target,
                                 Expression value,
                                 java.lang.String targetParameter,
                                 java.lang.String valueParameter)

validateGotoType

private static void validateGotoType(Type<?> expectedType,
                                     Expression value,
                                     java.lang.String valueParameter)

validateTryAndCatchHaveSameType

private static void validateTryAndCatchHaveSameType(Type<?> type,
                                                    Expression tryBody,
                                                    ReadOnlyList<CatchBlock> handlers)

validateSwitchCaseType

private static void validateSwitchCaseType(Expression caseBody,
                                           boolean customType,
                                           Type<?> resultType,
                                           java.lang.String parameterName)

findField

private static FieldInfo findField(Type<?> declaringType,
                                   java.lang.String fieldName,
                                   java.util.Set<BindingFlags> flags)

types

private static Type<?>[] types(Expression... expressions)

types

private static Type<?>[] types(java.lang.Iterable<? extends Expression> expressions)

findMethod

private static MethodInfo findMethod(Type<?> type,
                                     java.lang.String methodName,
                                     TypeList typeArguments,
                                     ExpressionList<? extends Expression> arguments,
                                     java.util.Set<BindingFlags> flags)

findBestMethod

private static int findBestMethod(MemberList<?> methods,
                                  TypeList typeArgs,
                                  ExpressionList<? extends Expression> arguments)

isCompatible

private static boolean isCompatible(MethodBase m,
                                    ExpressionList<? extends Expression> arguments)

applyTypeArgs

private static MethodInfo applyTypeArgs(MethodInfo m,
                                        TypeList typeArgs)

performBinaryNumericPromotion

static Type<?> performBinaryNumericPromotion(Type<?> leftType,
                                             Type<?> rightType)

validateCoalesceArgumentTypes

private static Type<?> validateCoalesceArgumentTypes(Type<?> left,
                                                     Type<?> right)