Uses of Class
com.strobel.expressions.Expression

Packages that use Expression

Package	Description
com.strobel.compilerservices
com.strobel.expressions

Uses of Expression in com.strobel.compilerservices

Methods in com.strobel.compilerservices with parameters of type Expression

Modifier and Type	Method	Description
abstract void	DebugInfoGenerator.markSequencePoint(LambdaExpression<?> method, int bytecodeOffset, Expression sequencePoint)
void	DebugInfoGenerator.markSequencePoint(LambdaExpression<?> method, MethodBase methodBase, CodeGenerator generator, Expression sequencePoint)

Uses of Expression in com.strobel.expressions

Classes in com.strobel.expressions with type parameters of type Expression

Modifier and Type	Class	Description
class	ExpressionList<T extends Expression>

Subclasses of Expression in com.strobel.expressions

Modifier and Type	Class	Description
(package private) final class	AssignBinaryExpression	Optimized assignment node; only holds onto children.
class	BinaryExpression
(package private) final class	Block2
(package private) final class	Block3
(package private) final class	Block4
(package private) final class	Block5
class	BlockExpression
(package private) class	BlockN
(package private) final class	CoalesceConversionBinaryExpression	Coalesce with conversion.
(package private) final class	CompareMethodBasedLogicalBinaryExpression
final class	ConcatExpression
class	ConditionalExpression
class	ConstantExpression	Represents an expression that has a constant value.
final class	DefaultValueExpression
(package private) final class	EqualsMethodBasedLogicalBinaryExpression
(package private) final class	FieldExpression	Represents accessing a field.
final class	ForEachExpression
final class	ForExpression
(package private) class	FullConditionalExpression
(package private) class	FullConditionalExpressionWithType
final class	GotoExpression
(package private) final class	InstanceMethodCallExpressionN
final class	InvocationExpression
final class	LabelExpression
final class	LambdaExpression<T>
(package private) class	LogicalBinaryExpression	Optimized representation of simple logical expressions: && || == != > < >= <=
final class	LoopExpression
class	MemberExpression	Represents accessing a field.
(package private) class	MethodBinaryExpression
class	MethodCallExpression
(package private) final class	MethodCallExpressionN
(package private) final class	NewArrayBoundsExpression
class	NewArrayExpression
(package private) final class	NewArrayInitExpression
final class	NewExpression
(package private) final class	OpAssignMethodConversionBinaryExpression
class	ParameterExpression	Represents a named parameter expression.
(package private) class	PrimitiveConstantExpression
(package private) final class	PrimitiveParameterExpression
final class	RuntimeVariablesExpression
(package private) final class	Scope1
(package private) class	ScopeExpression
(package private) class	ScopeN
(package private) final class	ScopeWithType
(package private) final class	SelfExpression
(package private) class	SimpleBinaryExpression
(package private) static final class	StackSpiller.SpilledExpressionBlock	A special subtype of BlockExpression that indicates to the compiler that this block is a spilled expression and should not allow jumps in.
(package private) final class	SuperExpression
final class	SwitchExpression
final class	TryExpression
final class	TypeBinaryExpression
(package private) class	TypedConstantExpression
(package private) final class	TypedParameterExpression
final class	UnaryExpression	Represents an expression that has a unary operator.

Subclasses with type arguments of type Expression in com.strobel.expressions

Modifier and Type	Class	Description
(package private) final class	BlockExpressionList

Fields in com.strobel.expressions declared as Expression

Modifier and Type	Field	Description
private final Expression	BlockExpressionList._arg0
private final Expression	Block2._arg1
private final Expression	Block3._arg1
private final Expression	Block4._arg1
private final Expression	Block5._arg1
private final Expression	Block3._arg2
private final Expression	Block4._arg2
private final Expression	Block5._arg2
private final Expression	Block4._arg3
private final Expression	Block5._arg3
private final Expression	Block5._arg4
private final Expression	CatchBlock._body
private final Expression	ForEachExpression._body
private final Expression	ForExpression._body
private final Expression	LambdaExpression._body
private final Expression	LoopExpression._body
private final Expression	SwitchCase._body
private final Expression	TryExpression._body
private final Expression	SwitchExpression._defaultBody
private final Expression	LabelExpression._defaultValue
private final T[]	ExpressionList._expressions
private final Expression[]	StackSpiller.ChildRewriter._expressions
private final Expression	CatchBlock._filter
private final Expression	TryExpression._finallyBlock
private final Expression	FullConditionalExpression._ifFalse
private final Expression	ConditionalExpression._ifTrue
private final Expression	ForExpression._initializer
private final Expression	InvocationExpression._lambda
private final Expression	BinaryExpression._left
private final Expression	TypeBinaryExpression._operand
private final Expression	UnaryExpression._operand
private final Expression	BinaryExpression._right
private final Expression	ForEachExpression._sequence
private final Expression	ForExpression._step
private final Expression	SwitchExpression._switchValue
private final Expression	InstanceMethodCallExpressionN._target
private final Expression	MemberExpression._target
private final Expression	ConditionalExpression._test
private final Expression	ForExpression._test
private final Expression	GotoExpression._value
private final Expression	StackSpiller.Result.Node

Fields in com.strobel.expressions with type parameters of type Expression

Modifier and Type	Field	Description
private final ExpressionList<? extends Expression>	InstanceMethodCallExpressionN._arguments
private final ExpressionList<? extends Expression>	InvocationExpression._arguments
private final ExpressionList<? extends Expression>	MethodCallExpressionN._arguments
private final ExpressionList<? extends Expression>	NewExpression._arguments
private final ExpressionList<? extends Expression>	ScopeN._body
private List<Expression>	StackSpiller.ChildRewriter._comma
private final ExpressionList<? extends Expression>	BlockN._expressions
private final ExpressionList<? extends Expression>	NewArrayExpression._expressions
private final ExpressionList<? extends Expression>	ConcatExpression._operands
private final ExpressionList<? extends Expression>	SwitchCase._testValues
private static final Selector<? super Expression, Type<?>>	Functions.EXPRESSION_TYPE
private final Consumer<? extends Expression>	DebugViewWriter.VISITOR_BLOCK

Methods in com.strobel.expressions with type parameters of type Expression

Modifier and Type	Method	Description
(package private) static <T extends Expression> ExpressionList<T>	Expression.arrayToList(T[] expressions)
private static <T extends Expression> T[]	StackSpiller.clone(ExpressionList<T> original, int max)
static <T extends Expression> ExpressionList<T>	ExpressionList.empty()
(package private) static <E extends Expression> Selector<? super E, Type<?>>	Functions.expressionType()
static <T extends Expression> IllegalStateException	Error.mustRewriteToSameNode(String callerName, Class<T> type, String overrideMethodName)
(package private) static <T extends Expression> T	Expression.returnObject(Class<T> clazz, Object objectOrCollection)
private static <T extends Expression> ExpressionList<T>	Expression.validateArgumentTypes(MethodBase method, ExpressionType nodeKind, ExpressionList<T> arguments)
private static <T extends Expression> T	Expression.validateOneArgument(MethodBase method, ExpressionType nodeKind, T arg, Type<?> parameterType)
<T extends Expression> T	ExpressionStringBuilder.visitAndConvert(T node, String callerName)
protected <T extends Expression> T	ExpressionVisitor.visitAndConvert(T node, String callerName)
<T extends Expression> ExpressionList<T>	ExpressionStringBuilder.visitAndConvertList(ExpressionList<T> nodes, String callerName)
protected <T extends Expression> ExpressionList<T>	ExpressionVisitor.visitAndConvertList(ExpressionList<T> nodes, String callerName)
private <T extends Expression> void	DebugViewWriter.visitExpressions(char open, char separator, ExpressionList<T> expressions)
private <T extends Expression> void	DebugViewWriter.visitExpressions(char open, char separator, ExpressionList<T> expressions, Consumer<T> visit)
private <T extends Expression> void	DebugViewWriter.visitExpressions(char open, ExpressionList<T> expressions)
private <T extends Expression> void	ExpressionStringBuilder.visitExpressions(char open, ExpressionList<T> expressions, char close)
private <T extends Expression> Consumer<T>	DebugViewWriter.visitorBlock()

Methods in com.strobel.expressions that return Expression

Modifier and Type	Method	Description
protected Expression	BinaryExpression.accept(ExpressionVisitor visitor)
protected Expression	BlockExpression.accept(ExpressionVisitor visitor)
protected Expression	ConcatExpression.accept(ExpressionVisitor visitor)
protected Expression	ConditionalExpression.accept(ExpressionVisitor visitor)
protected Expression	ConstantExpression.accept(ExpressionVisitor visitor)
protected Expression	DefaultValueExpression.accept(ExpressionVisitor visitor)
protected Expression	Expression.accept(ExpressionVisitor visitor)	Dispatches to the specific visit method for this node type.
protected Expression	ForEachExpression.accept(ExpressionVisitor visitor)
protected Expression	ForExpression.accept(ExpressionVisitor visitor)
protected final Expression	GotoExpression.accept(ExpressionVisitor visitor)
protected Expression	InvocationExpression.accept(ExpressionVisitor visitor)
protected final Expression	LabelExpression.accept(ExpressionVisitor visitor)
protected Expression	LambdaExpression.accept(ExpressionVisitor visitor)
protected final Expression	LoopExpression.accept(ExpressionVisitor visitor)
protected Expression	MemberExpression.accept(ExpressionVisitor visitor)
protected Expression	MethodCallExpression.accept(ExpressionVisitor visitor)
protected final Expression	NewArrayExpression.accept(ExpressionVisitor visitor)
protected final Expression	NewExpression.accept(ExpressionVisitor visitor)
protected Expression	ParameterExpression.accept(ExpressionVisitor visitor)
protected Expression	RuntimeVariablesExpression.accept(ExpressionVisitor visitor)
protected final Expression	SwitchExpression.accept(ExpressionVisitor visitor)
protected final Expression	TryExpression.accept(ExpressionVisitor visitor)
protected final Expression	TypeBinaryExpression.accept(ExpressionVisitor visitor)
protected final Expression	UnaryExpression.accept(ExpressionVisitor visitor)
static Expression	Expression.base(Type<?> type)
static Expression	Expression.box(Expression expression)
private static <T extends Expression> T[]	StackSpiller.clone(ExpressionList<T> original, int max)
(package private) static Expression	BinaryExpression.create(ExpressionType nodeType, Expression left, Expression right, Type type, MethodInfo method, LambdaExpression<?> conversion)
static Expression	Expression.empty()	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Expression	BlockExpressionList.get(int index)
(package private) Expression	StackSpiller.ChildRewriter.get(int index)
Expression	IArgumentProvider.getArgument(int index)
final Expression	InstanceMethodCallExpressionN.getArgument(int index)
Expression	InvocationExpression.getArgument(int index)
Expression	MethodCallExpression.getArgument(int index)
final Expression	MethodCallExpressionN.getArgument(int index)
final Expression	NewExpression.getArgument(int index)
final Expression	CatchBlock.getBody()
Expression	ForEachExpression.getBody()
Expression	ForExpression.getBody()
final Expression	LambdaExpression.getBody()
final Expression	LoopExpression.getBody()
final Expression	SwitchCase.getBody()
final Expression	TryExpression.getBody()
final Expression	SwitchExpression.getDefaultBody()
final Expression	LabelExpression.getDefaultValue()
private Expression	LambdaCompiler.getEqualityOperand(Expression expression)
(package private) final Expression	Block2.getExpression(int index)
(package private) final Expression	Block3.getExpression(int index)
(package private) final Expression	Block4.getExpression(int index)
(package private) final Expression	Block5.getExpression(int index)
(package private) Expression	BlockExpression.getExpression(int index)
(package private) final Expression	BlockN.getExpression(int index)
Expression	InvocationExpression.getExpression()
(package private) final Expression	Scope1.getExpression(int index)
(package private) final Expression	ScopeN.getExpression(int index)
final Expression	CatchBlock.getFilter()
final Expression	TryExpression.getFinallyBlock()
Expression	ConditionalExpression.getIfFalse()
Expression	FullConditionalExpression.getIfFalse()
final Expression	ConditionalExpression.getIfTrue()
Expression	ForExpression.getInitializer()
final Expression	BinaryExpression.getLeft()
Expression	StackSpiller.Result.getNode()
final Expression	TypeBinaryExpression.getOperand()
final Expression	UnaryExpression.getOperand()	Gets the implementing method for the unary operation.
final Expression	BlockExpression.getResult()
final Expression	BinaryExpression.getRight()
Expression	ForEachExpression.getSequence()
Expression	ForExpression.getStep()
final Expression	SwitchExpression.getSwitchValue()
final Expression	InstanceMethodCallExpressionN.getTarget()
final Expression	MemberExpression.getTarget()
Expression	MethodCallExpression.getTarget()
final Expression	ConditionalExpression.getTest()
Expression	ForExpression.getTest()
final Expression	GotoExpression.getValue()
private static Expression	StackSpiller.makeBlock(ExpressionList<? extends Expression> expressions)	Creates a special block that is marked as not allowing jumps in.
(package private) static Expression	Optimizer.optimize(Expression node)
Expression	BinaryExpression.reduce()
final Expression	CompareMethodBasedLogicalBinaryExpression.reduce()
Expression	ConcatExpression.reduce()
Expression	Expression.reduce()	Reduces this node to a simpler expression.
Expression	ForEachExpression.reduce()
Expression	ForExpression.reduce()
Expression	SwitchExpression.reduce()
final Expression	TypeBinaryExpression.reduce()
final Expression	UnaryExpression.reduce()
final Expression	Expression.reduceAndCheck()	Reduces this node to a simpler expression.
private Expression	Optimizer.reduceBooleanConstantComparison(BinaryExpression node)
private Expression	TypeBinaryExpression.reduceConstantTypeEqual()
private Expression	Optimizer.reduceDoubleNot(UnaryExpression node)
final Expression	Expression.reduceExtensions()	Reduces the expression to a known node type (i.e.
private Expression	ForEachExpression.reduceForArray()
private Expression	ForEachExpression.reduceForIterable()
private Expression	BinaryExpression.reduceMember()
private Expression	UnaryExpression.reduceMember()
private Expression	Optimizer.reduceNullConstantCheck(UnaryExpression node)
private Expression	Optimizer.reduceNullConstantComparison(BinaryExpression node)
private Expression	TypeBinaryExpression.reduceParameterTypeEqual(ParameterExpression value)
(package private) final Expression	TypeBinaryExpression.reduceTypeEqual()
private Expression	BinaryExpression.reduceVariable()
private Expression	UnaryExpression.reduceVariable()
(package private) final Expression	ConcatExpression.rewrite(ExpressionList<? extends Expression> operands)
private Expression	SwitchExpression.rewriteEnumSwitch()
private Expression	SwitchExpression.rewriteStringSwitch()
static Expression	Expression.self(Type<?> type)
T[]	ExpressionList.toArray()
Expression	ExpressionStringBuilder.visit(Expression node)
Expression	ExpressionVisitor.visit(Expression node)
protected Expression	DebugViewWriter.visitBinary(BinaryExpression node)
protected Expression	ExpressionStringBuilder.visitBinary(BinaryExpression node)
protected Expression	ExpressionVisitor.visitBinary(BinaryExpression node)
protected Expression	Optimizer.visitBinary(BinaryExpression node)
protected Expression	DebugViewWriter.visitBlock(BlockExpression node)
protected Expression	ExpressionStringBuilder.visitBlock(BlockExpression node)
protected Expression	ExpressionVisitor.visitBlock(BlockExpression node)
protected Expression	VariableBinder.visitBlock(BlockExpression node)
protected Expression	ConcatExpression.visitChildren(ExpressionVisitor visitor)
protected Expression	Expression.visitChildren(ExpressionVisitor visitor)	Reduces the node and then calls the visitor on the reduced expression.
protected Expression	ForEachExpression.visitChildren(ExpressionVisitor visitor)
protected Expression	ForExpression.visitChildren(ExpressionVisitor visitor)
protected Expression	DebugViewWriter.visitConcat(ConcatExpression node)
protected Expression	ExpressionStringBuilder.visitConcat(ConcatExpression node)
protected Expression	ExpressionVisitor.visitConcat(ConcatExpression node)
protected Expression	DebugViewWriter.visitConditional(ConditionalExpression node)
protected Expression	ExpressionStringBuilder.visitConditional(ConditionalExpression node)
protected Expression	ExpressionVisitor.visitConditional(ConditionalExpression node)
protected Expression	DebugViewWriter.visitConstant(ConstantExpression node)
protected Expression	ExpressionStringBuilder.visitConstant(ConstantExpression node)
protected Expression	ExpressionVisitor.visitConstant(ConstantExpression node)
protected Expression	VariableBinder.visitConstant(ConstantExpression node)
protected Expression	DebugViewWriter.visitDefaultValue(DefaultValueExpression node)
protected Expression	ExpressionStringBuilder.visitDefaultValue(DefaultValueExpression node)
protected Expression	ExpressionVisitor.visitDefaultValue(DefaultValueExpression node)
protected Expression	DebugViewWriter.visitExtension(Expression node)
protected Expression	ExpressionStringBuilder.visitExtension(Expression node)
protected Expression	ExpressionVisitor.visitExtension(Expression node)
protected Expression	DebugViewWriter.visitFor(ForExpression node)
protected Expression	ExpressionStringBuilder.visitFor(ForExpression node)
protected Expression	ExpressionVisitor.visitFor(ForExpression node)
protected Expression	DebugViewWriter.visitForEach(ForEachExpression node)
protected Expression	ExpressionStringBuilder.visitForEach(ForEachExpression node)
protected Expression	ExpressionVisitor.visitForEach(ForEachExpression node)
protected Expression	DebugViewWriter.visitGoto(GotoExpression node)
protected Expression	ExpressionStringBuilder.visitGoto(GotoExpression node)
protected Expression	ExpressionVisitor.visitGoto(GotoExpression node)
protected Expression	DebugViewWriter.visitInvocation(InvocationExpression node)
protected Expression	ExpressionStringBuilder.visitInvocation(InvocationExpression node)
protected Expression	ExpressionVisitor.visitInvocation(InvocationExpression node)
protected Expression	VariableBinder.visitInvocation(InvocationExpression node)
protected Expression	DebugViewWriter.visitLabel(LabelExpression node)
protected Expression	ExpressionStringBuilder.visitLabel(LabelExpression node)
protected Expression	ExpressionVisitor.visitLabel(LabelExpression node)
protected <T> Expression	ExpressionVisitor.visitLambda(LambdaExpression<T> node)
protected Expression	DebugViewWriter.visitLoop(LoopExpression node)
protected Expression	ExpressionStringBuilder.visitLoop(LoopExpression node)
protected Expression	ExpressionVisitor.visitLoop(LoopExpression node)
protected Expression	DebugViewWriter.visitMember(MemberExpression node)
protected Expression	ExpressionStringBuilder.visitMember(MemberExpression node)
protected Expression	ExpressionVisitor.visitMember(MemberExpression node)
protected Expression	DebugViewWriter.visitMethodCall(MethodCallExpression node)
protected Expression	ExpressionStringBuilder.visitMethodCall(MethodCallExpression node)
protected Expression	ExpressionVisitor.visitMethodCall(MethodCallExpression node)
protected Expression	DebugViewWriter.visitNew(NewExpression node)
protected Expression	ExpressionStringBuilder.visitNew(NewExpression node)
protected Expression	ExpressionVisitor.visitNew(NewExpression node)
protected Expression	DebugViewWriter.visitNewArray(NewArrayExpression node)
protected Expression	ExpressionStringBuilder.visitNewArray(NewArrayExpression node)
protected Expression	ExpressionVisitor.visitNewArray(NewArrayExpression node)
protected Expression	DebugViewWriter.visitParameter(ParameterExpression node)
protected Expression	ExpressionStringBuilder.visitParameter(ParameterExpression node)
protected Expression	ExpressionVisitor.visitParameter(ParameterExpression node)
protected Expression	VariableBinder.visitParameter(ParameterExpression node)
protected Expression	DebugViewWriter.visitRuntimeVariables(RuntimeVariablesExpression node)
protected Expression	ExpressionVisitor.visitRuntimeVariables(RuntimeVariablesExpression node)
protected Expression	VariableBinder.visitRuntimeVariables(RuntimeVariablesExpression node)
protected Expression	DebugViewWriter.visitSwitch(SwitchExpression node)
protected Expression	ExpressionStringBuilder.visitSwitch(SwitchExpression node)
protected Expression	ExpressionVisitor.visitSwitch(SwitchExpression node)
protected Expression	DebugViewWriter.visitTry(TryExpression node)
protected Expression	ExpressionStringBuilder.visitTry(TryExpression node)
protected Expression	ExpressionVisitor.visitTry(TryExpression node)
protected Expression	DebugViewWriter.visitTypeBinary(TypeBinaryExpression node)
protected Expression	ExpressionStringBuilder.visitTypeBinary(TypeBinaryExpression node)
protected Expression	ExpressionVisitor.visitTypeBinary(TypeBinaryExpression node)
protected Expression	DebugViewWriter.visitUnary(UnaryExpression node)
protected Expression	ExpressionStringBuilder.visitUnary(UnaryExpression node)
protected Expression	ExpressionVisitor.visitUnary(UnaryExpression node)
protected Expression	Optimizer.visitUnary(UnaryExpression node)
protected Expression	VariableBinder.visitUnary(UnaryExpression node)

Methods in com.strobel.expressions that return types with arguments of type Expression

Modifier and Type	Method	Description
private static ExpressionList<? extends Expression>	Expression.adaptArguments(MethodInfo method, ExpressionList<? extends Expression> arguments)
ExpressionList<Expression>	BlockExpressionList.add(int index, Expression expression)
ExpressionList<Expression>	BlockExpressionList.add(Expression expression)
ExpressionList<Expression>	BlockExpressionList.addAll(int index, ExpressionList<Expression> c)
ExpressionList<Expression>	BlockExpressionList.addAll(ExpressionList<Expression> c)
(package private) ExpressionList<? extends Expression>	StackSpiller.ChildRewriter.get(int first, int last)
ExpressionList<? extends Expression>	InvocationExpression.getArguments()
final ExpressionList<? extends Expression>	MethodCallExpression.getArguments()
final ExpressionList<? extends Expression>	NewExpression.getArguments()
final ExpressionList<? extends Expression>	BlockExpression.getExpressions()
final ExpressionList<? extends Expression>	NewArrayExpression.getExpressions()
ExpressionList<? extends Expression>	ConcatExpression.getOperands()
(package private) final ExpressionList<? extends Expression>	InstanceMethodCallExpressionN.getOrMakeArguments()
(package private) ExpressionList<? extends Expression>	MethodCallExpression.getOrMakeArguments()
(package private) final ExpressionList<? extends Expression>	MethodCallExpressionN.getOrMakeArguments()
(package private) final ExpressionList<? extends Expression>	Block2.getOrMakeExpressions()
(package private) final ExpressionList<? extends Expression>	Block3.getOrMakeExpressions()
(package private) final ExpressionList<? extends Expression>	Block4.getOrMakeExpressions()
(package private) final ExpressionList<? extends Expression>	Block5.getOrMakeExpressions()
(package private) ExpressionList<? extends Expression>	BlockExpression.getOrMakeExpressions()
(package private) final ExpressionList<? extends Expression>	BlockN.getOrMakeExpressions()
(package private) final ExpressionList<? extends Expression>	Scope1.getOrMakeExpressions()
(package private) final ExpressionList<? extends Expression>	ScopeN.getOrMakeExpressions()
ExpressionList<Expression>	BlockExpressionList.getRange(int fromIndex, int toIndex)
final ExpressionList<? extends Expression>	SwitchCase.getTestValues()
private ExpressionList<? extends Expression>	VariableBinder.mergeScopes(Expression node)
protected ExpressionList<Expression>	BlockExpressionList.newInstance(Expression[] expressions)
ExpressionList<Expression>	BlockExpressionList.remove(int index)
ExpressionList<Expression>	BlockExpressionList.remove(Expression expression)
ExpressionList<Expression>	BlockExpressionList.removeAll(ExpressionList<? extends Expression> c)
ExpressionList<Expression>	BlockExpressionList.replace(int index, Expression expression)
ExpressionList<Expression>	BlockExpressionList.retainAll(ExpressionList<? extends Expression> c)
(package private) static ExpressionList<? extends Expression>	BlockExpression.returnReadOnlyExpressions(BlockExpression provider, Object expressionOrCollection)
(package private) final ExpressionList<? extends Expression>	ExpressionVisitor.visit(ExpressionList<? extends Expression> nodes)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
(package private) final ExpressionList<? extends Expression>	ExpressionVisitor.visitArguments(IArgumentProvider nodes)

Methods in com.strobel.expressions with parameters of type Expression

Modifier and Type	Method	Description
ExpressionList<Expression>	BlockExpressionList.add(int index, Expression expression)
ExpressionList<Expression>	BlockExpressionList.add(Expression expression)
static BinaryExpression	Expression.add(Expression left, Expression right)
static BinaryExpression	Expression.add(Expression left, Expression right, MethodInfo method)
(package private) void	StackSpiller.ChildRewriter.add(Expression node)
final ExpressionList<T>	ExpressionList.addAll(int index, T... expressions)
final ExpressionList<T>	ExpressionList.addAll(T... expressions)
static BinaryExpression	Expression.addAssign(Expression left, Expression right)
static BinaryExpression	Expression.addAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.addAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
private static AnalyzeTypeIsResult	ConstantCheck.analyzeInstanceOf(Expression operand, Type<?> testType)
static BinaryExpression	Expression.and(Expression left, Expression right)
static BinaryExpression	Expression.and(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.andAlso(Expression left, Expression right)
static BinaryExpression	Expression.andAlso(Expression first, Expression... rest)
static BinaryExpression	Expression.andAlso(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.andAssign(Expression left, Expression right)
static BinaryExpression	Expression.andAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.andAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
static BinaryExpression	Expression.arrayIndex(Expression array, Expression index)
static UnaryExpression	Expression.arrayLength(Expression array)
(package private) static <T extends Expression> ExpressionList<T>	Expression.arrayToList(T[] expressions)
static BinaryExpression	Expression.assign(Expression left, Expression right)
static BlockExpression	Expression.block(Expression... expressions)
static BlockExpression	Expression.block(Expression arg0, Expression arg1)
static BlockExpression	Expression.block(Expression arg0, Expression arg1, Expression arg2)
static BlockExpression	Expression.block(Expression arg0, Expression arg1, Expression arg2, Expression arg3)
static BlockExpression	Expression.block(Expression arg0, Expression arg1, Expression arg2, Expression arg3, Expression arg4)
static BlockExpression	Expression.block(ParameterExpression[] variables, Expression... expressions)
static BlockExpression	Expression.block(ParameterExpressionList variables, Expression... expressions)
static BlockExpression	Expression.block(Type<?> type, Expression... expressions)
static BlockExpression	Expression.block(Type<?> type, ParameterExpression[] variables, Expression... expressions)
static BlockExpression	Expression.block(Type<?> type, ParameterExpressionList variables, Expression... expressions)
static Expression	Expression.box(Expression expression)
static MethodCallExpression	Expression.call(Expression target, MethodInfo method, Expression... arguments)
static MethodCallExpression	Expression.call(Expression target, MethodInfo method, ExpressionList<? extends Expression> arguments)
static MethodCallExpression	Expression.call(Expression target, String methodName, Expression... arguments)
static MethodCallExpression	Expression.call(Expression target, String methodName, TypeList typeArguments, Expression... arguments)
static MethodCallExpression	Expression.call(Expression target, String methodName, TypeList typeArguments, ExpressionList<? extends Expression> arguments)
static MethodCallExpression	Expression.call(MethodInfo method, Expression... arguments)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static MethodCallExpression	Expression.call(Type<?> declaringType, String methodName, Expression... arguments)
static MethodCallExpression	Expression.call(Type<?> declaringType, String methodName, TypeList typeArguments, Expression... arguments)
static BinaryExpression	Expression.coalesce(Expression left, Expression right)
static BinaryExpression	Expression.coalesce(Expression left, Expression right, LambdaExpression<?> conversion)
static ConcatExpression	Expression.concat(Expression first, Expression second)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static ConcatExpression	Expression.concat(Expression first, Expression second, Expression... operands)
static ConditionalExpression	Expression.condition(Expression test, Expression ifTrue, Expression ifFalse)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static ConditionalExpression	Expression.condition(Expression test, Expression ifTrue, Expression ifFalse, Type<?> type)
static UnaryExpression	Expression.convert(Expression expression, Type<?> type)
static UnaryExpression	Expression.convert(Expression expression, Type<?> type, MethodInfo method)
(package private) static Expression	BinaryExpression.create(ExpressionType nodeType, Expression left, Expression right, Type type, MethodInfo method, LambdaExpression<?> conversion)
static UnaryExpression	Expression.decrement(Expression expression)
static UnaryExpression	Expression.decrement(Expression expression, MethodInfo method)
private void	LambdaCompiler.defineBlockLabels(Expression node)
static BinaryExpression	Expression.divide(Expression left, Expression right)
static BinaryExpression	Expression.divide(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.divideAssign(Expression left, Expression right)
static BinaryExpression	Expression.divideAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.divideAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
private void	LambdaCompiler.emitAndAlsoBinaryExpression(Expression expr, int flags)
private void	LambdaCompiler.emitAssignBinaryExpression(Expression expr)
private void	LambdaCompiler.emitBinaryExpression(Expression expr)
private void	LambdaCompiler.emitBinaryExpression(Expression expr, int flags)
private void	LambdaCompiler.emitBlockExpression(Expression expr, int flags)
private void	LambdaCompiler.emitCoalesceBinaryExpression(Expression expr)
private void	LambdaCompiler.emitConditionalExpression(Expression expr, int flags)
private void	LambdaCompiler.emitConstantExpression(Expression expr)
private void	LambdaCompiler.emitConvertUnaryExpression(Expression expr, int flags)
private void	LambdaCompiler.emitDefaultValueExpression(Expression node)
(package private) void	LambdaCompiler.emitExpression(Expression node)
private void	LambdaCompiler.emitExpression(Expression node, int flags)
private void	LambdaCompiler.emitExpressionAndBranch(boolean branchValue, Expression node, Label label)
private void	LambdaCompiler.emitExpressionAsType(Expression node, Type type, int flags)
private void	LambdaCompiler.emitExpressionAsVoid(Expression node)
private void	LambdaCompiler.emitExpressionAsVoid(Expression node, int flags)
private int	LambdaCompiler.emitExpressionStart(Expression node)
private void	LambdaCompiler.emitExtensionExpression(Expression node)
private void	LambdaCompiler.emitGotoExpression(Expression expr, int flags)
private void	LambdaCompiler.emitInvocationExpression(Expression expr, int flags)
private void	LambdaCompiler.emitLabelExpression(Expression expr, int flags)
private void	LambdaCompiler.emitLambdaExpression(Expression expr)
private void	LambdaCompiler.emitLoopExpression(Expression expr)
private void	LambdaCompiler.emitMemberExpression(Expression expr)
private void	LambdaCompiler.emitMethodCall(Expression target, MethodInfo method, IArgumentProvider methodCallExpr)
private void	LambdaCompiler.emitMethodCall(Expression target, MethodInfo method, IArgumentProvider expr, int flags)
private void	LambdaCompiler.emitMethodCall(Expression target, MethodInfo method, MethodCallExpression expr, int flags)
private void	LambdaCompiler.emitMethodCallExpression(Expression expr)
private void	LambdaCompiler.emitMethodCallExpression(Expression expr, int flags)
private void	LambdaCompiler.emitNewArrayExpression(Expression expr)
private void	LambdaCompiler.emitNewExpression(Expression expr)
private void	LambdaCompiler.emitOrElseBinaryExpression(Expression expr, int flags)
private void	LambdaCompiler.emitParameterExpression(Expression expr)
private void	LambdaCompiler.emitRuntimeVariablesExpression(Expression expr)
private void	LambdaCompiler.emitSwitchExpression(Expression expr, int flags)
private void	LambdaCompiler.emitThrowUnaryExpression(Expression expr)
private void	LambdaCompiler.emitTryExpression(Expression expr)
private void	LambdaCompiler.emitTypeBinaryExpression(Expression expr)
private void	LambdaCompiler.emitUnaryExpression(Expression expr, int flags)
private void	LambdaCompiler.emitUnboxUnaryExpression(Expression expr)
private void	LambdaCompiler.emitUnreachable(Expression node, int flags)
static BinaryExpression	Expression.equal(Expression left, Expression right)
static BinaryExpression	Expression.equal(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.exclusiveOr(Expression left, Expression right)
static BinaryExpression	Expression.exclusiveOr(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.exclusiveOrAssign(Expression left, Expression right)
static BinaryExpression	Expression.exclusiveOrAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.exclusiveOrAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
(package private) static String	ExpressionStringBuilder.expressionToString(Expression node)
static MemberExpression	Expression.field(Expression target, FieldInfo field)
static MemberExpression	Expression.field(Expression target, String fieldName)
(package private) StackSpiller.Result	StackSpiller.ChildRewriter.Finish(Expression expr)
static ForEachExpression	Expression.forEach(ParameterExpression variable, Expression sequence, Expression body)
static ForEachExpression	Expression.forEach(ParameterExpression variable, Expression sequence, Expression body, LabelTarget breakTarget)
static ForEachExpression	Expression.forEach(ParameterExpression variable, Expression sequence, Expression body, LabelTarget breakTarget, LabelTarget continueTarget)
private UnaryExpression	UnaryExpression.functionalOp(Expression operand)
private static BinaryExpression	Expression.getCompareMethodBasedBinaryOperator(ExpressionType binaryType, Expression left, Expression right)
private static BinaryExpression	Expression.getComparisonOperator(ExpressionType binaryType, Expression left, Expression right)
private static BinaryExpression	Expression.getEqualityComparisonOperator(ExpressionType binaryType, String opName, Expression left, Expression right)
private Expression	LambdaCompiler.getEqualityOperand(Expression expression)
private static BinaryExpression	Expression.getEqualsMethodBasedBinaryOperator(ExpressionType binaryType, Expression left, Expression right)
(package private) static MethodInfo	Expression.getInvokeMethod(Expression expression)
private static BinaryExpression	Expression.getMethodBasedAssignOperator(ExpressionType binaryType, Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
private static BinaryExpression	Expression.getMethodBasedAssignOperator(ExpressionType binaryType, String name, Expression left, Expression right, LambdaExpression<?> conversion)
private static BinaryExpression	Expression.getMethodBasedAssignOperatorOrThrow(ExpressionType binaryType, String name, Expression left, Expression right, LambdaExpression<?> conversion)
private static BinaryExpression	Expression.getMethodBasedBinaryOperator(ExpressionType binaryType, Expression left, Expression right, MethodInfo method)
private static BinaryExpression	Expression.getMethodBasedBinaryOperator(ExpressionType binaryType, String name, Expression left, Expression right)
private static BinaryExpression	Expression.getMethodBasedBinaryOperatorOrThrow(ExpressionType binaryType, String name, Expression left, Expression right)
private static UnaryExpression	Expression.getMethodBasedCoercion(ExpressionType coercionType, Expression expression, Type<?> convertToType)
private static UnaryExpression	Expression.getMethodBasedCoercionOperator(ExpressionType unaryType, Expression operand, Type<?> convertToType, MethodInfo method)
private static UnaryExpression	Expression.getMethodBasedCoercionOrThrow(ExpressionType coercionType, Expression expression, Type<?> convertToType)
private static UnaryExpression	Expression.getMethodBasedUnaryOperator(ExpressionType unaryType, Expression operand, MethodInfo method)
private static UnaryExpression	Expression.getMethodBasedUnaryOperator(ExpressionType unaryType, String methodName, Expression operand)
private static UnaryExpression	Expression.getMethodBasedUnaryOperatorOrThrow(ExpressionType unaryType, Expression operand, String... methodNames)
private static UnaryExpression	Expression.getMethodBasedUnaryOperatorOrThrow(ExpressionType unaryType, String methodName, Expression operand)
private static int	DebugViewWriter.getOperatorPrecedence(Expression node)
private static BinaryExpression	Expression.getStaticMethodBasedBinaryOperator(ExpressionType binaryType, Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.greaterThan(Expression left, Expression right)
static BinaryExpression	Expression.greaterThan(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.greaterThanOrEqual(Expression left, Expression right)
static BinaryExpression	Expression.greaterThanOrEqual(Expression left, Expression right, MethodInfo method)
static ConditionalExpression	Expression.ifThen(Expression test, Expression ifTrue)
static ConditionalExpression	Expression.ifThenElse(Expression test, Expression ifTrue, Expression ifFalse)
static UnaryExpression	Expression.increment(Expression expression)
static UnaryExpression	Expression.increment(Expression expression, MethodInfo method)
int	BlockExpressionList.indexOf(Expression item)
static TypeBinaryExpression	Expression.instanceOf(Expression expression, Type<?> type)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static InvocationExpression	Expression.invoke(Expression expression, Expression... arguments)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static InvocationExpression	Expression.invoke(Expression expression, ExpressionList<? extends Expression> arguments)
(package private) static boolean	ConstantCheck.isFalse(Expression e)
static UnaryExpression	Expression.isFalse(Expression expression)
static UnaryExpression	Expression.isFalse(Expression expression, MethodInfo method)
static UnaryExpression	Expression.isNotNull(Expression expression)
(package private) static boolean	ConstantCheck.isNull(Expression e)
static UnaryExpression	Expression.isNull(Expression expression)
private static boolean	Expression.isNullComparison(Expression left, Expression right)
private static boolean	Expression.isNullConstant(Expression e)
private static boolean	DebugViewWriter.isSimpleExpression(Expression node)
(package private) static boolean	ConstantCheck.isStringLiteral(Expression e)
(package private) static boolean	ConstantCheck.isTrue(Expression e)
static UnaryExpression	Expression.isTrue(Expression expression)
static UnaryExpression	Expression.isTrue(Expression expression, MethodInfo method)
static LabelExpression	Expression.label(LabelTarget target, Expression defaultValue)
static LambdaExpression<?>	Expression.lambda(Expression body, boolean tailCall, ParameterExpression... parameters)
static LambdaExpression<?>	Expression.lambda(Expression body, boolean tailCall, ParameterExpressionList parameters)
static LambdaExpression<?>	Expression.lambda(Expression body, ParameterExpression... parameters)
static LambdaExpression<?>	Expression.lambda(Expression body, ParameterExpressionList parameters)
static <T> LambdaExpression<T>	Expression.lambda(Type<?> interfaceType, Expression body, boolean tailCall, ParameterExpression... parameters)
static <T> LambdaExpression<T>	Expression.lambda(Type<?> interfaceType, Expression body, boolean tailCall, ParameterExpressionList parameters)
static <T> LambdaExpression<T>	Expression.lambda(Type<?> interfaceType, Expression body, ParameterExpression... parameters)
static <T> LambdaExpression<T>	Expression.lambda(Type<?> interfaceType, Expression body, ParameterExpressionList parameters)
static <T> LambdaExpression<T>	Expression.lambda(Type<?> interfaceType, String name, Expression body, boolean tailCall, ParameterExpression... parameters)
static <T> LambdaExpression<T>	Expression.lambda(Type<?> interfaceType, String name, Expression body, boolean tailCall, ParameterExpressionList parameters)
static <T> LambdaExpression<T>	Expression.lambda(Type<?> interfaceType, String name, Expression body, ParameterExpression... parameters)
static LambdaExpression<?>	Expression.lambda(String name, Expression body, boolean tailCall, ParameterExpression... parameters)
static LambdaExpression<?>	Expression.lambda(String name, Expression body, ParameterExpression... parameters)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int	BlockExpressionList.lastIndexOf(Expression expression)
static BinaryExpression	Expression.leftShift(Expression left, Expression right)
static BinaryExpression	Expression.leftShift(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.leftShiftAssign(Expression left, Expression right)
static BinaryExpression	Expression.leftShiftAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.leftShiftAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
static BinaryExpression	Expression.lessThan(Expression left, Expression right)
static BinaryExpression	Expression.lessThan(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.lessThanOrEqual(Expression left, Expression right)
static BinaryExpression	Expression.lessThanOrEqual(Expression left, Expression right, MethodInfo method)
static LoopExpression	Expression.loop(Expression body)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static LoopExpression	Expression.loop(Expression body, LabelTarget breakTarget)
static LoopExpression	Expression.loop(Expression body, LabelTarget breakTarget, LabelTarget continueLabel)
(package private) static ConditionalExpression	ConditionalExpression.make(Expression test, Expression ifTrue, Expression ifFalse, Type type)
(package private) static MemberExpression	MemberExpression.make(Expression expression, MemberInfo member)
static BinaryExpression	Expression.makeBinary(ExpressionType binaryType, Expression... rest)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static BinaryExpression	Expression.makeBinary(ExpressionType binaryType, Expression left, Expression right)
static BinaryExpression	Expression.makeBinary(ExpressionType binaryType, Expression first, Expression... rest)
static BinaryExpression	Expression.makeBinary(ExpressionType binaryType, Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.makeBinary(ExpressionType binaryType, Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
static GotoExpression	Expression.makeBreak(LabelTarget target, Expression value)
static GotoExpression	Expression.makeBreak(LabelTarget target, Expression value, Type<?> type)
static CatchBlock	Expression.makeCatch(ParameterExpression variable, Expression body)
static CatchBlock	Expression.makeCatch(ParameterExpression variable, Expression body, Expression filter)
static CatchBlock	Expression.makeCatch(Type<?> type, Expression body)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static CatchBlock	Expression.makeCatch(Type<?> type, Expression body, Expression filter)
static CatchBlock	Expression.makeCatch(Type<?> type, ParameterExpression variable, Expression body)
static CatchBlock	Expression.makeCatch(Type<?> type, ParameterExpression variable, Expression body, Expression filter)
static ForExpression	Expression.makeFor(ParameterExpression variable, Expression initializer, Expression test, Expression step, Expression body)
static ForExpression	Expression.makeFor(ParameterExpression variable, Expression initializer, Expression test, Expression step, Expression body, LabelTarget breakTarget)
static ForExpression	Expression.makeFor(ParameterExpression variable, Expression initializer, Expression test, Expression step, Expression body, LabelTarget breakTarget, LabelTarget continueTarget)
static GotoExpression	Expression.makeGoto(GotoExpressionKind kind, LabelTarget target, Expression value, Type<?> type)
static GotoExpression	Expression.makeGoto(LabelTarget target, Expression value)
static GotoExpression	Expression.makeGoto(LabelTarget target, Expression value, Type<?> type)
static MemberExpression	Expression.makeMemberAccess(Expression target, MemberInfo member)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static NewExpression	Expression.makeNew(ConstructorInfo constructor, Expression... parameters)
static NewExpression	Expression.makeNew(Type<?> type, Expression... parameters)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private static UnaryExpression	Expression.makeOpAssignUnary(ExpressionType kind, Expression expression, MethodInfo method)
static GotoExpression	Expression.makeReturn(LabelTarget target, Expression value)
static GotoExpression	Expression.makeReturn(LabelTarget target, Expression value, Type<?> type)
static SwitchExpression	Expression.makeSwitch(Expression switchValue, Expression defaultBody, SwitchCase... cases)
static SwitchExpression	Expression.makeSwitch(Expression switchValue, Expression defaultBody, MethodInfo comparison, ReadOnlyList<SwitchCase> cases)
static SwitchExpression	Expression.makeSwitch(Expression switchValue, Expression defaultBody, MethodInfo comparison, SwitchCase... cases)
static SwitchExpression	Expression.makeSwitch(Expression switchValue, SwitchCase... cases)
static SwitchExpression	Expression.makeSwitch(Expression switchValue, SwitchOptions options, Expression defaultBody, SwitchCase... cases)
static SwitchExpression	Expression.makeSwitch(Expression switchValue, SwitchOptions options, Expression defaultBody, MethodInfo comparison, ReadOnlyList<SwitchCase> cases)
static SwitchExpression	Expression.makeSwitch(Expression switchValue, SwitchOptions options, Expression defaultBody, MethodInfo comparison, SwitchCase... cases)
static SwitchExpression	Expression.makeSwitch(Expression switchValue, SwitchOptions options, SwitchCase... cases)
static SwitchExpression	Expression.makeSwitch(Type<?> type, Expression switchValue, Expression defaultBody, SwitchCase... cases)
static SwitchExpression	Expression.makeSwitch(Type<?> type, Expression switchValue, Expression defaultBody, MethodInfo comparison, SwitchCase... cases)
static SwitchExpression	Expression.makeSwitch(Type<?> type, Expression switchValue, SwitchOptions options, Expression defaultBody, SwitchCase... cases)
static SwitchExpression	Expression.makeSwitch(Type<?> type, Expression switchValue, SwitchOptions options, Expression defaultBody, MethodInfo comparison, ReadOnlyList<SwitchCase> cases)
static SwitchExpression	Expression.makeSwitch(Type<?> type, Expression switchValue, SwitchOptions options, Expression defaultBody, MethodInfo comparison, SwitchCase... cases)
static UnaryExpression	Expression.makeThrow(Expression expression)
static UnaryExpression	Expression.makeThrow(Expression value, Type<?> type)
static TryExpression	Expression.makeTry(Type<?> type, Expression body, ReadOnlyList<CatchBlock> catchBlocks, Expression finallyBlock)
static TryExpression	Expression.makeTry(Type<?> type, Expression body, CatchBlock... handlers)
static TryExpression	Expression.makeTry(Type<?> type, Expression body, Expression finallyBlock, CatchBlock... handlers)
static UnaryExpression	Expression.makeUnary(ExpressionType unaryType, Expression operand, Type<?> type)
static UnaryExpression	Expression.makeUnary(ExpressionType unaryType, Expression operand, Type<?> type, MethodInfo method)
private ExpressionList<? extends Expression>	VariableBinder.mergeScopes(Expression node)
static BinaryExpression	Expression.modulo(Expression left, Expression right)
static BinaryExpression	Expression.modulo(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.moduloAssign(Expression left, Expression right)
static BinaryExpression	Expression.moduloAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.moduloAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
static BinaryExpression	Expression.multiply(Expression left, Expression right)
static BinaryExpression	Expression.multiply(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.multiplyAssign(Expression left, Expression right)
static BinaryExpression	Expression.multiplyAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.multiplyAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
private static boolean	DebugViewWriter.needsParentheses(Expression parent, Expression child)
static UnaryExpression	Expression.negate(Expression expression)
static UnaryExpression	Expression.negate(Expression expression, MethodInfo method)
static NewArrayExpression	Expression.newArrayBounds(Type<?> elementType, Expression dimension)
static NewArrayExpression	Expression.newArrayInit(Type<?> elementType, Expression... initializers)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
protected ExpressionList<Expression>	BlockExpressionList.newInstance(Expression[] expressions)
protected ExpressionList<T>	ExpressionList.newInstance(T[] expressions)
static UnaryExpression	Expression.not(Expression expression)
static UnaryExpression	Expression.not(Expression expression, MethodInfo method)
private static boolean	LambdaCompiler.notEmpty(Expression node)
static BinaryExpression	Expression.notEqual(Expression left, Expression right)
static BinaryExpression	Expression.notEqual(Expression left, Expression right, MethodInfo method)
static UnaryExpression	Expression.onesComplement(Expression expression)
static UnaryExpression	Expression.onesComplement(Expression expression, MethodInfo method)
(package private) static Expression	Optimizer.optimize(Expression node)
static BinaryExpression	Expression.or(Expression left, Expression right)
static BinaryExpression	Expression.or(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.orAssign(Expression left, Expression right)
static BinaryExpression	Expression.orAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.orAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
static BinaryExpression	Expression.orElse(Expression left, Expression right)
static BinaryExpression	Expression.orElse(Expression first, Expression... rest)
static BinaryExpression	Expression.orElse(Expression left, Expression right, MethodInfo method)
private void	DebugViewWriter.outMember(Expression node, Expression instance, MemberInfo member)
private void	ExpressionStringBuilder.outMember(Expression instance, MemberInfo member)
private void	DebugViewWriter.parenthesizedVisit(Expression parent, Expression nodeToVisit)
static UnaryExpression	Expression.postDecrementAssign(Expression expression)
static UnaryExpression	Expression.postDecrementAssign(Expression expression, MethodInfo method)
static UnaryExpression	Expression.postIncrementAssign(Expression expression)
static UnaryExpression	Expression.postIncrementAssign(Expression expression, MethodInfo method)
static UnaryExpression	Expression.preDecrementAssign(Expression expression)
static UnaryExpression	Expression.preDecrementAssign(Expression expression, MethodInfo method)
static UnaryExpression	Expression.preIncrementAssign(Expression expression)
static UnaryExpression	Expression.preIncrementAssign(Expression expression, MethodInfo method)
static BinaryExpression	Expression.referenceEqual(Expression left, Expression right)
static BinaryExpression	Expression.referenceNotEqual(Expression left, Expression right)
ExpressionList<Expression>	BlockExpressionList.remove(Expression expression)
final ExpressionList<T>	ExpressionList.removeAll(T... expressions)
ExpressionList<Expression>	BlockExpressionList.replace(int index, Expression expression)
private static <T> Type<T>	LambdaExpression.resolveDelegateType(Expression body, ParameterExpressionList parameters)
final ExpressionList<T>	ExpressionList.retainAll(T... expressions)
(package private) BlockExpression	Block2.rewrite(ParameterExpressionList variables, Expression[] args)
(package private) BlockExpression	Block3.rewrite(ParameterExpressionList variables, Expression[] args)
(package private) BlockExpression	Block4.rewrite(ParameterExpressionList variables, Expression[] args)
(package private) BlockExpression	Block5.rewrite(ParameterExpressionList variables, Expression[] args)
(package private) BlockExpression	BlockExpression.rewrite(ParameterExpressionList variables, Expression[] args)
(package private) BlockExpression	BlockN.rewrite(ParameterExpressionList variables, Expression[] args)
(package private) final MethodCallExpression	InstanceMethodCallExpressionN.rewrite(Expression target, ExpressionList<? extends Expression> arguments)
(package private) MethodCallExpression	MethodCallExpression.rewrite(Expression target, ExpressionList<? extends Expression> arguments)
(package private) final MethodCallExpression	MethodCallExpressionN.rewrite(Expression target, ExpressionList<? extends Expression> arguments)
(package private) final BlockExpression	Scope1.rewrite(ParameterExpressionList variables, Expression[] args)
(package private) BlockExpression	ScopeN.rewrite(ParameterExpressionList variables, Expression[] args)
(package private) final BlockExpression	ScopeWithType.rewrite(ParameterExpressionList variables, Expression[] args)
(package private) BlockExpression	StackSpiller.SpilledExpressionBlock.rewrite(ParameterExpressionList variables, Expression[] args)
private StackSpiller.Result	StackSpiller.rewriteAssignBinaryExpression(Expression expr, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteBinaryExpression(Expression expr, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteBlockExpression(Expression expr, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteConditionalExpression(Expression expr, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteExpression(Expression node, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteExpressionFreeTemps(Expression expression, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteExtensionExpression(Expression expr, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteGotoExpression(Expression expr, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteInvocationExpression(Expression expr, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteLabelExpression(Expression expr, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteLambdaExpression(Expression expr, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteLogicalBinaryExpression(Expression expr, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteLoopExpression(Expression expr, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteMemberExpression(Expression expr, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteMethodCallExpression(Expression expr, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteNewArrayExpression(Expression expr, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteNewExpression(Expression expr, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteReducibleExpression(Expression expr, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteSwitchExpression(Expression expr, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteThrowUnaryExpression(Expression expr, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteTryExpression(Expression expr, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteTypeBinaryExpression(Expression expr, StackSpiller.Stack stack)
private StackSpiller.Result	StackSpiller.rewriteUnaryExpression(Expression expr, StackSpiller.Stack stack)
static BinaryExpression	Expression.rightShift(Expression left, Expression right)
static BinaryExpression	Expression.rightShift(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.rightShiftAssign(Expression left, Expression right)
static BinaryExpression	Expression.rightShiftAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.rightShiftAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
private static boolean	LambdaCompiler.significant(Expression node)
static BinaryExpression	Expression.subtract(Expression left, Expression right)
static BinaryExpression	Expression.subtract(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.subtractAssign(Expression left, Expression right)
static BinaryExpression	Expression.subtractAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.subtractAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
static SwitchCase	Expression.switchCase(Expression body, Expression... testValues)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static SwitchCase	Expression.switchCase(Expression body, ExpressionList<? extends Expression> testValues)
private ParameterExpression	StackSpiller.toTemp(Expression expression, StrongBox<Expression> save)
static TryExpression	Expression.tryCatch(Expression body, CatchBlock... handlers)
static TryExpression	Expression.tryCatchFinally(Expression body, Expression finallyBlock, CatchBlock... handlers)
static TryExpression	Expression.tryFinally(Expression body, Expression finallyBlock)
private boolean	LambdaCompiler.tryPushLabelBlock(Expression node)
static TypeBinaryExpression	Expression.typeEqual(Expression expression, Type<?> type)
private static Type<?>[]	Expression.types(Expression... expressions)
static UnaryExpression	Expression.unaryPlus(Expression expression)
static UnaryExpression	Expression.unaryPlus(Expression expression, MethodInfo method)
static UnaryExpression	Expression.unbox(Expression expression)
static UnaryExpression	Expression.unbox(Expression expression, Type<?> type)
static BinaryExpression	Expression.unsignedRightShift(Expression left, Expression right)
static BinaryExpression	Expression.unsignedRightShift(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.unsignedRightShiftAssign(Expression left, Expression right)
static BinaryExpression	Expression.unsignedRightShiftAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.unsignedRightShiftAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
BinaryExpression	BinaryExpression.update(Expression left, LambdaExpression<?> conversion, Expression right)
final CatchBlock	CatchBlock.update(ParameterExpression variable, Expression filter, Expression body)
ConditionalExpression	ConditionalExpression.update(Expression test, Expression ifTrue, Expression ifFalse)
ForEachExpression	ForEachExpression.update(ParameterExpression variable, Expression sequence, Expression body, LabelTarget breakTarget, LabelTarget continueTarget)
ForExpression	ForExpression.update(ParameterExpression variable, Expression initializer, Expression test, Expression step, Expression body, LabelTarget breakTarget, LabelTarget continueTarget)
final GotoExpression	GotoExpression.update(LabelTarget target, Expression value)
final LabelExpression	LabelExpression.update(LabelTarget target, Expression defaultValue)
final LambdaExpression<T>	LambdaExpression.update(Expression body, ParameterExpressionList parameters)
final LoopExpression	LoopExpression.update(LabelTarget breakLabel, LabelTarget continueLabel, Expression body)
final MemberExpression	MemberExpression.update(Expression target)
MethodCallExpression	MethodCallExpression.update(Expression target, ExpressionList<? extends Expression> arguments)
final SwitchCase	SwitchCase.update(ExpressionList<? extends Expression> testValues, Expression body)
final SwitchExpression	SwitchExpression.update(Expression switchValue, ReadOnlyList<SwitchCase> cases, Expression defaultBody, SwitchOptions options)
final TryExpression	TryExpression.update(Expression body, ReadOnlyList<CatchBlock> handlers, Expression finallyBlock)
final TypeBinaryExpression	TypeBinaryExpression.update(Expression operand)
final UnaryExpression	UnaryExpression.update(Expression operand)
private static void	Expression.validateGoto(LabelTarget target, Expression value, String targetParameter, String valueParameter)
private static void	Expression.validateGotoType(Type<?> expectedType, Expression value, String valueParameter)
private static <T> void	Expression.validateLambdaArgs(Type<T> interfaceType, Expression body, ParameterExpressionList parameters)
private static void	Expression.validateOpAssignConversionLambda(LambdaExpression<?> conversion, Expression left, MethodInfo method, ExpressionType nodeType)
private static void	Expression.validateStaticOrInstanceMethod(Expression instance, MethodInfo method)
private static void	Expression.validateSwitchCaseType(Expression caseBody, boolean customType, Type<?> resultType, String parameterName)
private static void	Expression.validateTryAndCatchHaveSameType(Type<?> type, Expression tryBody, ReadOnlyList<CatchBlock> handlers)
private static void	Expression.verifyCanRead(Expression[] items, String parameterName)
private static void	Expression.verifyCanRead(Expression expression, String parameterName)
private static void	Expression.verifyCanWrite(Expression expression, String parameterName)
private static void	StackSpiller.verifyRewrite(StackSpiller.Result result, Expression node)
private static void	Expression.verifyTypeBinaryExpressionOperand(Expression expression, Type<?> type)
Expression	ExpressionStringBuilder.visit(Expression node)
Expression	ExpressionVisitor.visit(Expression node)
protected Expression	DebugViewWriter.visitExtension(Expression node)
protected Expression	ExpressionStringBuilder.visitExtension(Expression node)
protected Expression	ExpressionVisitor.visitExtension(Expression node)
private void	DebugViewWriter.writeTo(Expression node)
(package private) static void	DebugViewWriter.writeTo(Expression node, StringBuilder writer)

Method parameters in com.strobel.expressions with type arguments of type Expression

Modifier and Type	Method	Description
private static ExpressionList<? extends Expression>	Expression.adaptArguments(MethodInfo method, ExpressionList<? extends Expression> arguments)
ExpressionList<Expression>	BlockExpressionList.addAll(int index, ExpressionList<Expression> c)
ExpressionList<Expression>	BlockExpressionList.addAll(ExpressionList<Expression> c)
private static BinaryExpression	Expression.aggregateBinary(ExpressionType binaryType, ImmutableList<Expression> operands)
static BlockExpression	Expression.block(ExpressionList<? extends Expression> expressions)
static BlockExpression	Expression.block(ParameterExpressionList variables, ExpressionList<? extends Expression> expressions)
static BlockExpression	Expression.block(Type<?> type, ExpressionList<? extends Expression> expressions)
static BlockExpression	Expression.block(Type<?> type, ParameterExpressionList variables, ExpressionList<? extends Expression> expressions)
static MethodCallExpression	Expression.call(Expression target, MethodInfo method, ExpressionList<? extends Expression> arguments)
static MethodCallExpression	Expression.call(Expression target, String methodName, TypeList typeArguments, ExpressionList<? extends Expression> arguments)
static MethodCallExpression	Expression.call(MethodInfo method, ExpressionList<? extends Expression> arguments)
static MethodCallExpression	Expression.call(Type<?> declaringType, String methodName, TypeList typeArguments, ExpressionList<? extends Expression> arguments)
static ConcatExpression	Expression.concat(ExpressionList<? extends Expression> operands)
private static int	Expression.findBestMethod(MemberList<?> methods, TypeList typeArgs, ExpressionList<? extends Expression> arguments)
private static MethodInfo	Expression.findMethod(Type<?> type, String methodName, TypeList typeArguments, ExpressionList<? extends Expression> arguments, Set<BindingFlags> flags)
protected void	ConcatExpression.flattenOperands(ListBuffer<Expression> operands)
static InvocationExpression	Expression.invoke(Expression expression, ExpressionList<? extends Expression> arguments)
private static boolean	Expression.isCompatible(MethodBase m, ExpressionList<? extends Expression> arguments)
(package private) static NewArrayExpression	NewArrayExpression.make(ExpressionType nodeType, Type type, ExpressionList<? extends Expression> expressions)
private static Expression	StackSpiller.makeBlock(ExpressionList<? extends Expression> expressions)	Creates a special block that is marked as not allowing jumps in.
static NewExpression	Expression.makeNew(ConstructorInfo constructor, ExpressionList<? extends Expression> parameters)
static NewArrayExpression	Expression.newArrayInit(Type<?> elementType, ExpressionList<? extends Expression> initializers)
ExpressionList<Expression>	BlockExpressionList.removeAll(ExpressionList<? extends Expression> c)
ExpressionList<Expression>	BlockExpressionList.retainAll(ExpressionList<? extends Expression> c)
(package private) final Expression	ConcatExpression.rewrite(ExpressionList<? extends Expression> operands)
(package private) final MethodCallExpression	InstanceMethodCallExpressionN.rewrite(Expression target, ExpressionList<? extends Expression> arguments)
(package private) InvocationExpression	InvocationExpression.rewrite(LambdaExpression lambda, ExpressionList<? extends Expression> arguments)
(package private) MethodCallExpression	MethodCallExpression.rewrite(Expression target, ExpressionList<? extends Expression> arguments)
(package private) final MethodCallExpression	MethodCallExpressionN.rewrite(Expression target, ExpressionList<? extends Expression> arguments)
static SwitchCase	Expression.switchCase(Expression body, ExpressionList<? extends Expression> testValues)
private ParameterExpression	StackSpiller.toTemp(Expression expression, StrongBox<Expression> save)
private static Type<?>[]	Expression.types(Iterable<? extends Expression> expressions)
final ConcatExpression	ConcatExpression.update(ExpressionList<? extends Expression> operands)
InvocationExpression	InvocationExpression.update(LambdaExpression lambda, ExpressionList<? extends Expression> arguments)
MethodCallExpression	MethodCallExpression.update(Expression target, ExpressionList<? extends Expression> arguments)
final NewArrayExpression	NewArrayExpression.update(ExpressionList<? extends Expression> expressions)
final NewExpression	NewExpression.update(ExpressionList<? extends Expression> arguments)
final SwitchCase	SwitchCase.update(ExpressionList<? extends Expression> testValues, Expression body)
private static void	Expression.verifyCanRead(Iterable<? extends Expression> items, String parameterName)
private static void	Expression.verifyCanWrite(Iterable<? extends Expression> items, String parameterName)
(package private) final ExpressionList<? extends Expression>	ExpressionVisitor.visit(ExpressionList<? extends Expression> nodes)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private void	ExpressionStringBuilder.visitList(ExpressionList<? extends Expression> expressions)

Constructors in com.strobel.expressions with parameters of type Expression

Modifier	Constructor	Description
	AssignBinaryExpression(Expression left, Expression right)
(package private)	BinaryExpression(Expression left, Expression right)
(package private)	Block2(Expression arg0, Expression arg1)
(package private)	Block3(Expression arg0, Expression arg1, Expression arg2)
(package private)	Block4(Expression arg0, Expression arg1, Expression arg2, Expression arg3)
(package private)	Block5(Expression arg0, Expression arg1, Expression arg2, Expression arg3, Expression arg4)
(package private)	BlockExpressionList(BlockExpression block, Expression arg0)
(package private)	CatchBlock(Type test, ParameterExpression variable, Expression body, Expression filter)
(package private)	CoalesceConversionBinaryExpression(Expression left, Expression right, LambdaExpression<?> conversion)
	CompareMethodBasedLogicalBinaryExpression(ExpressionType operator, Expression left, Expression right, MethodInfo method)
(package private)	ConditionalExpression(Expression test, Expression ifTrue)
	EqualsMethodBasedLogicalBinaryExpression(ExpressionType operator, Expression left, Expression right, MethodInfo method)
	ExpressionList(T... expressions)
(package private)	FieldExpression(Expression target, FieldInfo field)
(package private)	ForEachExpression(ParameterExpression variable, Expression sequence, Expression body, LabelTarget breakTarget, LabelTarget continueTarget)
(package private)	ForExpression(ParameterExpression variable, Expression initializer, Expression test, Expression step, Expression body, LabelTarget breakTarget, LabelTarget continueTarget)
(package private)	FullConditionalExpression(Expression test, Expression ifTrue, Expression ifFalse)
(package private)	FullConditionalExpressionWithType(Expression test, Expression ifTrue, Expression ifFalse, Type type)
(package private)	GotoExpression(GotoExpressionKind kind, LabelTarget target, Expression value, Type type)
(package private)	InstanceMethodCallExpressionN(MethodInfo method, Expression target, ExpressionList<? extends Expression> arguments)
(package private)	InvocationExpression(Expression lambda, ExpressionList<? extends Expression> arguments, Type returnType)
	LabelExpression(LabelTarget target, Expression defaultValue)
(package private)	LambdaExpression(Type<T> interfaceType, String name, Expression body, boolean tailCall, ParameterExpressionList parameters)
	LogicalBinaryExpression(ExpressionType operator, Expression left, Expression right)
(package private)	LoopExpression(Expression body, LabelTarget breakTarget, LabelTarget continueTarget)
(package private)	MemberExpression(Expression target)
	MethodBinaryExpression(ExpressionType operator, Expression left, Expression right, Type type, MethodInfo method)
(package private)	OpAssignMethodConversionBinaryExpression(ExpressionType nodeType, Expression left, Expression right, Type type, MethodInfo method, LambdaExpression<?> conversion)
(package private)	Result(StackSpiller.RewriteAction action, Expression node)
(package private)	Scope1(ParameterExpressionList variables, Expression body)
(package private)	SimpleBinaryExpression(ExpressionType nodeType, Expression left, Expression right, Type type)
(package private)	SwitchCase(Expression body, ExpressionList<? extends Expression> testValues)
	SwitchExpression(Type type, Expression switchValue, Expression defaultBody, MethodInfo comparison, ReadOnlyList<SwitchCase> cases, SwitchOptions options)
(package private)	TryExpression(Type type, Expression body, ReadOnlyList<CatchBlock> handlers, Expression finallyBlock)
(package private)	TypeBinaryExpression(Expression operand, Type typeOperand, ExpressionType nodeType)
(package private)	UnaryExpression(ExpressionType nodeType, Expression operand, Type type, MethodInfo method)

Constructor parameters in com.strobel.expressions with type arguments of type Expression

Modifier	Constructor	Description
(package private)	BlockN(ExpressionList<? extends Expression> expressions)
	ConcatExpression(ExpressionList<? extends Expression> operands)
(package private)	InstanceMethodCallExpressionN(MethodInfo method, Expression target, ExpressionList<? extends Expression> arguments)
(package private)	InvocationExpression(Expression lambda, ExpressionList<? extends Expression> arguments, Type returnType)
(package private)	MethodCallExpressionN(MethodInfo method, ExpressionList<? extends Expression> arguments)
(package private)	NewArrayBoundsExpression(Type type, ExpressionList<? extends Expression> expressions)
	NewArrayExpression(Type type, ExpressionList<? extends Expression> expressions)
(package private)	NewArrayInitExpression(Type type, ExpressionList<? extends Expression> expressions)
(package private)	NewExpression(ConstructorInfo constructor, ExpressionList<? extends Expression> arguments)
(package private)	ScopeN(ParameterExpressionList variables, ExpressionList<? extends Expression> body)
(package private)	ScopeWithType(ParameterExpressionList variables, ExpressionList<? extends Expression> expressions, Type<?> type)
(package private)	SpilledExpressionBlock(ExpressionList<? extends Expression> expressions)
(package private)	SwitchCase(Expression body, ExpressionList<? extends Expression> testValues)