Uses of Class
com.strobel.reflection.MethodInfo

Packages that use MethodInfo

Package	Description
com.strobel.expressions
com.strobel.reflection
com.strobel.reflection.emit
com.strobel.util

Uses of MethodInfo in com.strobel.expressions

Fields in com.strobel.expressions declared as MethodInfo

Modifier and Type	Field	Description
private final MethodInfo	SwitchExpression._comparison
private final MethodInfo	CompareMethodBasedLogicalBinaryExpression._method
private final MethodInfo	Delegate._method
private final MethodInfo	EqualsMethodBasedLogicalBinaryExpression._method
private final MethodInfo	MethodBinaryExpression._method
private final MethodInfo	MethodCallExpression._method
private final MethodInfo	UnaryExpression._method

Methods in com.strobel.expressions that return MethodInfo

Modifier and Type	Method	Description
private static MethodInfo	Expression.applyTypeArgs(MethodInfo m, TypeList typeArgs)
final MethodInfo	LambdaExpression.compileToMethod(TypeBuilder<?> typeBuilder)
final MethodInfo	LambdaExpression.compileToMethod(TypeBuilder<?> typeBuilder, String name)
final MethodInfo	LambdaExpression.compileToMethod(TypeBuilder<?> typeBuilder, String name, int modifiers)
private static MethodInfo	Expression.findMethod(Type<?> type, String methodName, TypeList typeArguments, ExpressionList<? extends Expression> arguments, Set<BindingFlags> flags)
private static MethodInfo	Expression.getBinaryOperatorMethod(ExpressionType binaryType, Type<?> leftType, Type<?> rightType, String name)
private static MethodInfo	Expression.getBinaryOperatorStaticMethod(ExpressionType binaryType, Type<?> leftType, Type<?> rightType, String name)
final MethodInfo	SwitchExpression.getComparison()
(package private) static MethodInfo	Expression.getInvokeMethod(Expression expression)
(package private) static MethodInfo	Expression.getInvokeMethod(Type<?> interfaceType, boolean throwOnError)
MethodInfo	BinaryExpression.getMethod()
final MethodInfo	CompareMethodBasedLogicalBinaryExpression.getMethod()
final MethodInfo	Delegate.getMethod()
MethodInfo	EqualsMethodBasedLogicalBinaryExpression.getMethod()
final MethodInfo	MethodBinaryExpression.getMethod()
final MethodInfo	MethodCallExpression.getMethod()
final MethodInfo	UnaryExpression.getMethod()	Gets the implementing method for the unary operation.
(package private) static MethodInfo	Expression.getMethodValidated(Type<?> type, String name, Set<BindingFlags> bindingFlags, CallingConvention callingConvention, Type<?>... parameterTypes)

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

Modifier and Type	Method	Description
private static ExpressionList<? extends Expression>	Expression.adaptArguments(MethodInfo method, ExpressionList<? extends Expression> arguments)
static BinaryExpression	Expression.add(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.addAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.addAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
static BinaryExpression	Expression.and(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.andAlso(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.andAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.andAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
private static MethodInfo	Expression.applyTypeArgs(MethodInfo m, TypeList typeArgs)
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(MethodInfo method, Expression... arguments)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static MethodCallExpression	Expression.call(MethodInfo method, ExpressionList<? extends Expression> arguments)
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, MethodInfo method)
static BinaryExpression	Expression.divide(Expression left, Expression right, MethodInfo method)
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.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.emitMethodCall(MethodInfo method, IArgumentProvider args, Type<?> objectType, int flags)
static BinaryExpression	Expression.equal(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.exclusiveOr(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.exclusiveOrAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.exclusiveOrAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
private static BinaryExpression	Expression.getMethodBasedAssignOperator(ExpressionType binaryType, Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
private static BinaryExpression	Expression.getMethodBasedBinaryOperator(ExpressionType binaryType, Expression left, Expression right, MethodInfo method)
private static UnaryExpression	Expression.getMethodBasedCoercionOperator(ExpressionType unaryType, Expression operand, Type<?> convertToType, MethodInfo method)
private static UnaryExpression	Expression.getMethodBasedUnaryOperator(ExpressionType unaryType, Expression operand, MethodInfo method)
private static BinaryExpression	Expression.getStaticMethodBasedBinaryOperator(ExpressionType binaryType, Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.greaterThan(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.greaterThanOrEqual(Expression left, Expression right, MethodInfo method)
static UnaryExpression	Expression.increment(Expression expression, MethodInfo method)
static UnaryExpression	Expression.isFalse(Expression expression, MethodInfo method)
static UnaryExpression	Expression.isTrue(Expression expression, MethodInfo method)
static BinaryExpression	Expression.leftShift(Expression left, Expression right, MethodInfo method)
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, MethodInfo method)
static BinaryExpression	Expression.lessThanOrEqual(Expression left, Expression right, MethodInfo method)
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)
private static UnaryExpression	Expression.makeOpAssignUnary(ExpressionType kind, Expression expression, MethodInfo method)
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, 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(Type<?> type, Expression switchValue, Expression defaultBody, MethodInfo comparison, 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.makeUnary(ExpressionType unaryType, Expression operand, Type<?> type, MethodInfo method)
(package private) static boolean	Expression.methodArgumentsMatch(MethodInfo method, Type<?>... argumentTypes)
static BinaryExpression	Expression.modulo(Expression left, Expression right, MethodInfo method)
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, MethodInfo method)
static BinaryExpression	Expression.multiplyAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.multiplyAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
static UnaryExpression	Expression.negate(Expression expression, MethodInfo method)
static UnaryExpression	Expression.not(Expression expression, MethodInfo method)
static BinaryExpression	Expression.notEqual(Expression left, Expression right, MethodInfo method)
static UnaryExpression	Expression.onesComplement(Expression expression, MethodInfo method)
static BinaryExpression	Expression.or(Expression left, Expression right, MethodInfo method)
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, MethodInfo method)
static UnaryExpression	Expression.postDecrementAssign(Expression expression, MethodInfo method)
static UnaryExpression	Expression.postIncrementAssign(Expression expression, MethodInfo method)
static UnaryExpression	Expression.preDecrementAssign(Expression expression, MethodInfo method)
static UnaryExpression	Expression.preIncrementAssign(Expression expression, MethodInfo method)
static BinaryExpression	Expression.rightShift(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.rightShiftAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.rightShiftAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
static BinaryExpression	Expression.subtract(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.subtractAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.subtractAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
static UnaryExpression	Expression.unaryPlus(Expression expression, MethodInfo method)
static BinaryExpression	Expression.unsignedRightShift(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.unsignedRightShiftAssign(Expression left, Expression right, MethodInfo method)
static BinaryExpression	Expression.unsignedRightShiftAssign(Expression left, Expression right, MethodInfo method, LambdaExpression<?> conversion)
private static void	Expression.validateCallTargetType(Type<?> targetType, MethodInfo method)
private static void	Expression.validateOpAssignConversionLambda(LambdaExpression<?> conversion, Expression left, MethodInfo method, ExpressionType nodeType)
private static void	Expression.validateOperator(MethodInfo method)
private static void	Expression.validateStaticOrInstanceMethod(Expression instance, MethodInfo method)

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

Modifier	Constructor	Description
	CompareMethodBasedLogicalBinaryExpression(ExpressionType operator, Expression left, Expression right, MethodInfo method)
(package private)	Delegate(T instance, MethodInfo method)
	EqualsMethodBasedLogicalBinaryExpression(ExpressionType operator, Expression left, Expression right, MethodInfo method)
(package private)	InstanceMethodCallExpressionN(MethodInfo method, Expression target, ExpressionList<? extends Expression> arguments)
	MethodBinaryExpression(ExpressionType operator, Expression left, Expression right, Type type, MethodInfo method)
(package private)	MethodCallExpression(MethodInfo method)
(package private)	MethodCallExpressionN(MethodInfo method, ExpressionList<? extends Expression> arguments)
(package private)	OpAssignMethodConversionBinaryExpression(ExpressionType nodeType, Expression left, Expression right, Type type, MethodInfo method, LambdaExpression<?> conversion)
	SwitchExpression(Type type, Expression switchValue, Expression defaultBody, MethodInfo comparison, ReadOnlyList<SwitchCase> cases, SwitchOptions options)
(package private)	UnaryExpression(ExpressionType nodeType, Expression operand, Type type, MethodInfo method)

Uses of MethodInfo in com.strobel.reflection

Subclasses of MethodInfo in com.strobel.reflection

Modifier and Type	Class	Description
(package private) final class	DelegatingMethodInfo
final class	DynamicMethod
(package private) final class	ErasedMethod
(package private) final class	GenericMethod
(package private) class	ReflectedMethod
(package private) final class	RuntimeMethodInfo

Subclasses with type arguments of type MethodInfo in com.strobel.reflection

Modifier and Type	Class	Description
final class	MethodList

Fields in com.strobel.reflection declared as MethodInfo

Modifier and Type	Field	Description
private final MethodInfo	ErasedMethod._baseMethod
private final MethodInfo	ReflectedMethod._baseMethod
private final MethodInfo	RuntimeMethodInfo._baseMethod
private MethodInfo	GenericParameter._declaringMethod
protected MethodInfo	MethodInfo._erasedMethodDefinition
private final MethodInfo	GenericMethod._genericMethodDefinition
private final MethodInfo	DelegatingMethodInfo._methodInfo
private static final MethodInfo[]	MethodInfo.EMPTY_METHODS
protected static final MethodInfo[]	Type.EmptyMethods

Methods in com.strobel.reflection that return MethodInfo

Modifier and Type	Method	Description
(package private) static MethodInfo	MethodInfo.declaredOn(MethodInfo method, Type<?> declaringType, Type<?> reflectedType)
static MethodInfo[]	MethodInfo.emptyMethods()
MethodInfo	DelegatingMethodInfo.findBaseMethod(Type<?> relativeTo)
MethodInfo	MethodInfo.findBaseMethod(Type<?> relativeTo)
MethodInfo	DelegatingMethodInfo.findOverriddenMethod()
MethodInfo	MethodInfo.findOverriddenMethod()
MethodInfo	GenericParameter.getDeclaringMethod()
MethodInfo	DelegatingMethodInfo.getErasedMethodDefinition()
MethodInfo	MethodInfo.getErasedMethodDefinition()
MethodInfo	ReflectedMethod.getErasedMethodDefinition()
MethodInfo	RuntimeMethodInfo.getErasedMethodDefinition()
MethodInfo	DelegatingMethodInfo.getGenericMethodDefinition()
MethodInfo	GenericMethod.getGenericMethodDefinition()
MethodInfo	MethodInfo.getGenericMethodDefinition()
MethodInfo	PrimitiveType.getMethod(String name, Set<BindingFlags> bindingFlags, CallingConvention callingConvention, Type<?>... parameterTypes)
final MethodInfo	Type.getMethod(String name, Type<?>... parameterTypes)
MethodInfo	Type.getMethod(String name, Set<BindingFlags> bindingFlags, CallingConvention callingConvention, Type<?>... parameterTypes)
final MethodInfo	Type.getMethod(String name, Set<BindingFlags> bindingFlags, Type<?>... parameterTypes)
MethodInfo	DelegatingMethodInfo.makeGenericMethod(Type<?>... typeArguments)
MethodInfo	DelegatingMethodInfo.makeGenericMethod(TypeList typeArguments)
MethodInfo	MethodInfo.makeGenericMethod(Type<?>... typeArguments)
MethodInfo	MethodInfo.makeGenericMethod(TypeList typeArguments)
(package private) static MethodInfo	MethodInfo.reflectedOn(MethodInfo method, Type<?> reflectedType)
private static MethodInfo	DelegatingMethodInfo.unwrap(MethodInfo method)
MethodInfo	TypeBinder.visitMethod(Type<?> declaringType, MethodInfo method, TypeBindings bindings)
MethodInfo	TypeEraser.visitMethod(Type<?> declaringType, MethodInfo method, TypeBindings bindings)

Methods in com.strobel.reflection with parameters of type MethodInfo

Modifier and Type	Method	Description
(package private) static MethodInfo	MethodInfo.declaredOn(MethodInfo method, Type<?> declaringType, Type<?> reflectedType)
(package private) MethodBase	RuntimeTypeCache.getConstructor(Type<? super T> declaringType, MethodInfo constructor)
(package private) MethodBase	RuntimeTypeCache.getMethod(Type<? super T> declaringType, MethodInfo method)
static boolean	Helper.hasSameArgs(MethodInfo t, MethodInfo p)
private static boolean	Helper.isOverridableIn(MethodInfo method, Type<?> origin)
static boolean	Helper.isSubSignature(MethodInfo t, MethodInfo p)
static RuntimeException	Error.notGenericMethod(MethodInfo method)
static RuntimeException	Error.notGenericMethodDefinition(MethodInfo method)
private static boolean	RuntimeTypeCache.MemberInfoCache.overrideExists(MethodInfo method, ArrayList<? extends MethodInfo> methods)
static boolean	Helper.overrides(MethodInfo baseMethod, MethodInfo ancestorMethod)
static boolean	Helper.overrides(MethodInfo method, MethodInfo other, boolean checkResult)
(package private) static MethodInfo	MethodInfo.reflectedOn(MethodInfo method, Type<?> reflectedType)
static boolean	Helper.resultSubtype(MethodInfo t, MethodInfo s)
static boolean	Helper.returnTypeSubstitutable(MethodInfo r1, MethodInfo r2)
void	GenericParameter.setDeclaringMethod(MethodInfo declaringMethod)
private static MethodInfo	DelegatingMethodInfo.unwrap(MethodInfo method)
MethodInfo	TypeBinder.visitMethod(Type<?> declaringType, MethodInfo method, TypeBindings bindings)
MethodInfo	TypeEraser.visitMethod(Type<?> declaringType, MethodInfo method, TypeBindings bindings)

Method parameters in com.strobel.reflection with type arguments of type MethodInfo

Modifier and Type	Method	Description
private static boolean	RuntimeTypeCache.MemberInfoCache.overrideExists(MethodInfo method, ArrayList<? extends MethodInfo> methods)

Constructors in com.strobel.reflection with parameters of type MethodInfo

Modifier	Constructor	Description
(package private)	DelegatingMethodInfo(MethodInfo method, Type<?> reflectedType)
(package private)	DelegatingMethodInfo(MethodInfo method, Type<?> declaringType, Type<?> reflectedType)
(package private)	ErasedMethod(MethodInfo baseMethod, Type<?> declaringType, ParameterList parameters, Type<?> returnType, TypeList thrownTypes, TypeBindings typeBindings)
(package private)	GenericMethod(TypeBindings typeBindings, MethodInfo genericMethodDefinition)
(package private)	GenericParameter(String name, MethodInfo declaringMethod, Type<?> upperBound, int position)
protected	GenericParameter(String name, MethodInfo declaringMethod, Type<?> upperBound, Type<?> lowerBound, int position)
	MethodList(MethodInfo... elements)
	MethodList(MethodInfo[] elements, int offset, int length)
(package private)	ReflectedMethod(MethodInfo baseMethod, Type<?> declaringType, Type<?> reflectedType, Method rawMethod, ParameterList parameters, Type<?> returnType, TypeList thrownTypes, TypeBindings bindings)
(package private)	ReflectedMethod(MethodInfo baseMethod, Type<?> declaringType, Method rawMethod, ParameterList parameters, Type<?> returnType, TypeList thrownTypes, TypeBindings bindings)
(package private)	RuntimeMethodInfo(MethodInfo baseMethod, Method rawMethod, Type<?> declaringType, RuntimeTypeCache<?> reflectedTypeCache, int modifiers, Set<BindingFlags> bindingFlags, ParameterList parameters, Type<?> returnType, TypeList thrownTypes, TypeBindings typeBindings)

Constructor parameters in com.strobel.reflection with type arguments of type MethodInfo

Modifier	Constructor	Description
	MethodList(List<? extends MethodInfo> elements)

Uses of MethodInfo in com.strobel.reflection.emit

Subclasses of MethodInfo in com.strobel.reflection.emit

Modifier and Type	Class	Description
final class	MethodBuilder

Fields in com.strobel.reflection.emit declared as MethodInfo

Modifier and Type	Field	Description
private final MethodInfo	LocalBuilder._methodBuilder
(package private) final MethodInfo	TypeBuilder.MethodOverride.baseMethod
(package private) MethodInfo	MethodBuilder.generatedMethod
private static final MethodInfo	CodeGenerator.ObjectEqualsMethod
private static final MethodInfo	CodeGenerator.ObjectHashCodeMethod
private static final MethodInfo	CodeGenerator.StringCharAtMethod
private static final MethodInfo	CodeGenerator.StringLengthMethod

Methods in com.strobel.reflection.emit that return MethodInfo

Modifier and Type	Method	Description
MethodInfo	GenericParameterBuilder.getDeclaringMethod()
MethodInfo	MethodBuilder.getErasedMethodDefinition()
MethodInfo	GenericParameterBuilder.getMethod(String name, Set<BindingFlags> bindingFlags, CallingConvention callingConvention, Type<?>... parameterTypes)
MethodInfo	TypeBuilder.getMethod(String name, Set<BindingFlags> bindingFlags, CallingConvention callingConvention, Type<?>... parameterTypes)
(package private) MethodInfo	LocalBuilder.getMethodBuilder()

Methods in com.strobel.reflection.emit with parameters of type MethodInfo

Modifier and Type	Method	Description
void	CodeGenerator.call(OpCode opCode, MethodInfo method)
void	CodeGenerator.call(MethodInfo method)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void	TypeBuilder.defineMethodOverride(MethodInfo override, MethodInfo baseMethod)
void	CodeGenerator.emit(OpCode opCode, MethodInfo method)
ConstantPool.InterfaceMethodReference	ConstantPool.getInterfaceMethodReference(MethodInfo method)
(package private) static boolean	TypeBuilder.isBridgeMethodNeeded(MethodInfo baseMethod, MethodInfo override)

Constructors in com.strobel.reflection.emit with parameters of type MethodInfo

Modifier	Constructor	Description
	LocalBuilder(int localIndex, String name, Type localType, MethodInfo methodBuilder)
private	MethodOverride(MethodBuilder override, MethodInfo baseMethod)

Uses of MethodInfo in com.strobel.util

Methods in com.strobel.util that return MethodInfo

Modifier and Type	Method	Description
static MethodInfo	TypeUtils.getBoxMethod(Type<?> type)
static MethodInfo	TypeUtils.getCoercionMethod(Type<?> source, Type<?> destination)
static MethodInfo	TypeUtils.getUnboxMethod(Type<?> type)
static MethodInfo	TypeUtils.getUnboxMethod(Type<?> boxedType, Type<?> unboxedType)

Methods in com.strobel.util with parameters of type MethodInfo

Modifier and Type	Method	Description
static boolean	TypeUtils.isValidInvocationTargetType(MethodInfo method, Type<?> targetType)