Uses of Class
com.strobel.reflection.Type

Packages that use Type

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

Uses of Type in com.strobel.expressions

Fields in com.strobel.expressions declared as Type

Modifier and Type	Field	Description
private final Type<?>	CompilerScope.ElementBoxStorage._boxType
private final Type<?>	CompilerScope.LocalBoxStorage._boxType
private final Type<T>	LambdaExpression._interfaceType
private final Type	InvocationExpression._returnType
private final Type	LambdaExpression._returnType
private final Type	CatchBlock._test
private final Type	DefaultValueExpression._type
private final Type	FullConditionalExpressionWithType._type
private final Type	GotoExpression._type
private final Type	LabelTarget._type
private final Type	NewArrayExpression._type
private final Type	PrimitiveParameterExpression._type
private final Type<?>	ScopeWithType._type
private final Type<?>	SelfExpression._type
private final Type	SimpleBinaryExpression._type
private final Type<?>	SuperExpression._type
private final Type	SwitchExpression._type
private final Type	TryExpression._type
private final Type	TypedConstantExpression._type
private final Type	TypedParameterExpression._type
private final Type	UnaryExpression._type
private final Type	TypeBinaryExpression._typeOperand
(package private) static final Type<Closure>	LambdaCompiler.closureType
(package private) final Type<?>	BoundConstants.TypedConstant.type

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

Modifier and Type	Field	Description
private final KeyedQueue<Type<?>, LocalBuilder>	LambdaCompiler._freeLocals
private static final Selector<? super Expression, Type<?>>	Functions.EXPRESSION_TYPE
private static final Selector<Type<?>,String>	Functions.TYPE_NAME
private static final Cache<CustomDelegateTypeCache.CacheKey, Type<?>>	CustomDelegateTypeCache.TypeCache

Methods in com.strobel.expressions that return Type

Modifier and Type	Method	Description
private static Type<?>	CustomDelegateTypeCache.createDelegateType(Type<?> returnType, TypeList parameterTypes)
private Type<?>	LambdaCompiler.emitPrimitiveBinaryOp(ExpressionType op, Type leftType, Type rightType)
(package private) static Type<?>	CustomDelegateTypeCache.get(Type<?> returnType, TypeList parameterTypes)
private static Type<? extends IStrongBox>	CompilerScope.getBoxType(Type<?> type)
final Type	LambdaExpression.getReturnType()
final Type	CatchBlock.getTest()
final Type<?>	AssignBinaryExpression.getType()
Type<?>	BlockExpression.getType()
final Type<?>	CoalesceConversionBinaryExpression.getType()
final Type<?>	CompareMethodBasedLogicalBinaryExpression.getType()
Type<?>	ConcatExpression.getType()
Type<?>	ConditionalExpression.getType()
Type<?>	ConstantExpression.getType()
Type<?>	DefaultValueExpression.getType()
final Type<?>	EqualsMethodBasedLogicalBinaryExpression.getType()
Type<?>	Expression.getType()	Gets the static type of the expression that this Expression represents.
final Type<?>	FieldExpression.getType()
Type<?>	ForEachExpression.getType()
Type<?>	ForExpression.getType()
Type<?>	FullConditionalExpressionWithType.getType()
final Type<?>	GotoExpression.getType()
final Type<?>	InvocationExpression.getType()
final Type<?>	LabelExpression.getType()
final Type	LabelTarget.getType()
final Type<T>	LambdaExpression.getType()
final Type<?>	LogicalBinaryExpression.getType()
final Type<?>	LoopExpression.getType()
Type<?>	MethodCallExpression.getType()
final Type<?>	NewArrayExpression.getType()
final Type<?>	NewExpression.getType()
Type<?>	ParameterExpression.getType()
final Type<?>	PrimitiveConstantExpression.getType()
final Type<?>	PrimitiveParameterExpression.getType()
final Type<?>	RuntimeVariablesExpression.getType()
final Type<?>	ScopeWithType.getType()
Type<?>	SelfExpression.getType()
final Type<?>	SimpleBinaryExpression.getType()
Type<?>	SuperExpression.getType()
final Type<?>	SwitchExpression.getType()
final Type<?>	TryExpression.getType()
final Type<?>	TypeBinaryExpression.getType()
final Type<?>	TypedConstantExpression.getType()
final Type<?>	TypedParameterExpression.getType()
final Type<?>	UnaryExpression.getType()
final Type	TypeBinaryExpression.getTypeOperand()
(package private) static Type<?>	Expression.performBinaryNumericPromotion(Type<?> leftType, Type<?> rightType)
private static <T> Type<T>	LambdaExpression.resolveDelegateType(Expression body, ParameterExpressionList parameters)
private Type<?>	ForEachExpression.tryGetGenericEnumerableArgument()
private static Type<?>[]	Expression.types(Expression... expressions)
private static Type<?>[]	Expression.types(Iterable<? extends Expression> expressions)
private Type	LambdaCompiler.unboxLeftBinaryOperand(Type leftType, Type rightType)
private Type	LambdaCompiler.unboxRightBinaryOperand(Type rightType)
private static Type<?>	Expression.validateCoalesceArgumentTypes(Type<?> left, Type<?> right)

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

Modifier and Type	Method	Description
(package private) static <E extends Expression> Selector<? super E, Type<?>>	Functions.expressionType()
(package private) static Selector<Type<?>,String>	Functions.typeName()

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

Modifier and Type	Method	Description
(package private) void	BoundConstants.addReference(Object value, Type<?> type)
private static AnalyzeTypeIsResult	ConstantCheck.analyzeInstanceOf(Expression operand, Type<?> testType)
static Expression	Expression.base(Type<?> type)
static IllegalStateException	Error.binaryOperatorNotDefined(ExpressionType operator, Type leftType, Type rightType)
static BlockExpression	Expression.block(Type<?> type, Expression... expressions)
static BlockExpression	Expression.block(Type<?> type, ExpressionList<? extends Expression> expressions)
static BlockExpression	Expression.block(Type<?> type, ParameterExpression[] variables, Expression... expressions)
static BlockExpression	Expression.block(Type<?> type, ParameterExpressionList variables, Expression... expressions)
static BlockExpression	Expression.block(Type<?> type, ParameterExpressionList variables, ExpressionList<? extends Expression> expressions)
static MethodCallExpression	Expression.call(Type<?> declaringType, String methodName, Expression... arguments)
static MethodCallExpression	Expression.call(Type<?> declaringType, String methodName, TypeList typeArguments, Expression... arguments)
static MethodCallExpression	Expression.call(Type<?> declaringType, String methodName, TypeList typeArguments, ExpressionList<? extends Expression> arguments)
private static boolean	LambdaCompiler.canOptimizeSwitchType(Type<?> valueType)
static IllegalStateException	Error.catchVariableMustBeCompatibleWithCatchType(Type catchType, Type variableType)
static ConstantExpression	Expression.classConstant(Type<?> value)
private TypeKind	CustomDelegateTypeCache.CacheKey.coalesceKind(Type<?> type)
static IllegalStateException	Error.coercionOperatorNotDefined(Type sourceType, Type destinationType)
static ConditionalExpression	Expression.condition(Expression test, Expression ifTrue, Expression ifFalse, Type<?> type)
static ConstantExpression	Expression.constant(Object value, Type<?> type)
static UnaryExpression	Expression.convert(Expression expression, Type<?> type)
static UnaryExpression	Expression.convert(Expression expression, Type<?> type, MethodInfo method)
static IllegalStateException	Error.couldNotResolveConstructor(Type<?> type, Type<?>... parameterTypes)
(package private) static Expression	BinaryExpression.create(ExpressionType nodeType, Expression left, Expression right, Type type, MethodInfo method, LambdaExpression<?> conversion)
private static Type<?>	CustomDelegateTypeCache.createDelegateType(Type<?> returnType, TypeList parameterTypes)
private FieldBuilder	LambdaCompiler.createStaticField(String name, Type type)
static DefaultValueExpression	Expression.defaultValue(Type<?> type)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private void	LambdaCompiler.emitArithmeticBinaryOp(ExpressionType op, Type<?> operandType)
private void	LambdaCompiler.emitBinaryOperator(ExpressionType op, Type<?> leftType, Type<?> rightType, Type resultType)
(package private) void	BoundConstants.emitConstant(LambdaCompiler lc, Object value, Type<?> type)
private void	LambdaCompiler.emitConstant(Object value, Type<?> type)
private void	BoundConstants.emitConstantFromArray(LambdaCompiler lc, Object value, Type type)
private void	LambdaCompiler.emitConvertArithmeticResult(ExpressionType op, Type sourceType, Type resultType)
private void	LambdaCompiler.emitExpressionAsType(Expression node, Type type, int flags)
private void	LambdaCompiler.emitLiftedBooleanAnd(Type leftType, Type rightType)
private void	LambdaCompiler.emitLiftedBooleanOr(Type leftType, Type rightType)
private void	LambdaCompiler.emitLiftedRelational(ExpressionType op, Type leftType, Type rightType, Type resultType)
private void	LambdaCompiler.emitMethodCall(MethodInfo method, IArgumentProvider args, Type<?> objectType, int flags)
private Type<?>	LambdaCompiler.emitPrimitiveBinaryOp(ExpressionType op, Type leftType, Type rightType)
private void	LambdaCompiler.emitRelationalBranchOp(ExpressionType op, Type<?> operandType, boolean branch, Label label)
private void	LambdaCompiler.emitUnaryOperator(ExpressionType op, Type operandType, Type resultType)
private void	LambdaCompiler.emitUnboxingBinaryArithmetic(ExpressionType op, Type leftType, Type rightType, Type resultType)
private void	LambdaCompiler.emitUnboxingBinaryOp(ExpressionType op, Type leftType, Type rightType, Type resultType)
static IllegalArgumentException	Error.expressionTypeCannotInitializeArrayType(Type itemType, Type arrayElementType)
static IllegalStateException	Error.expressionTypeDoesNotMatchAssignment(Type leftType, Type rightType)
static IllegalStateException	Error.expressionTypeDoesNotMatchConstructorParameter(Type argType, Type parameterType)
static IllegalArgumentException	Error.expressionTypeDoesNotMatchLabel(Type valueType, Type expectedType)
static IllegalStateException	Error.expressionTypeDoesNotMatchMethodParameter(Type argType, Type parameterType, MethodBase method)
static IllegalStateException	Error.expressionTypeDoesNotMatchParameter(Type argType, Type parameterType)
static IllegalStateException	Error.expressionTypeDoesNotMatchReturn(Type bodyType, Type returnType)
static IllegalStateException	Error.expressionTypeNotInvokable(Type type)
static MemberExpression	Expression.field(Type<?> declaringType, String fieldName)
static IllegalStateException	Error.fieldDoesNotExistOnType(String fieldName, Type type)
private static FieldInfo	Expression.findField(Type<?> declaringType, String fieldName, Set<BindingFlags> flags)
private static MethodInfo	Expression.findMethod(Type<?> type, String methodName, TypeList typeArguments, ExpressionList<? extends Expression> arguments, Set<BindingFlags> flags)
private static String	CustomDelegateTypeCache.generateName(Type<?> returnType, TypeList parameterTypes)
static IllegalStateException	Error.genericMethodWithArgsDoesNotExistOnType(String methodName, Type type)
(package private) static Type<?>	CustomDelegateTypeCache.get(Type<?> returnType, TypeList parameterTypes)
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)
private static Type<? extends IStrongBox>	CompilerScope.getBoxType(Type<?> type)
private static char	CustomDelegateTypeCache.getCharacterCode(Type<?> type)
private static String	DebugViewWriter.getConstantValueSuffix(Type<?> type)
(package private) static MethodInfo	Expression.getInvokeMethod(Type<?> interfaceType, boolean throwOnError)
(package private) LocalBuilder	LambdaCompiler.getLocal(Type<?> type)
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)
(package private) static MethodInfo	Expression.getMethodValidated(Type<?> type, String name, Set<BindingFlags> bindingFlags, CallingConvention callingConvention, Type<?>... parameterTypes)
(package private) LocalBuilder	LambdaCompiler.getNamedLocal(Type type, ParameterExpression variable)
static IllegalStateException	Error.incorrectlyTypedSelfExpression(Type<?> expected, Type<?> actual)
static IllegalStateException	Error.incorrectlyTypedSuperExpression(Type<?> expected, Type<?> actual)
static TypeBinaryExpression	Expression.instanceOf(Expression expression, Type<?> type)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static LabelTarget	Expression.label(Type<?> type)
static LabelTarget	Expression.label(Type<?> type, String name)
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)
(package private) static ConditionalExpression	ConditionalExpression.make(Expression test, Expression ifTrue, Expression ifFalse, Type type)
(package private) static ConstantExpression	ConstantExpression.make(Object value, Type type)
(package private) static NewArrayExpression	NewArrayExpression.make(ExpressionType nodeType, Type type, ExpressionList<? extends Expression> expressions)
(package private) static ParameterExpression	ParameterExpression.make(Type type, String name)
static GotoExpression	Expression.makeBreak(LabelTarget target, Expression value, Type<?> type)
static GotoExpression	Expression.makeBreak(LabelTarget target, Type<?> type)
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 GotoExpression	Expression.makeContinue(LabelTarget target, Type<?> type)
static GotoExpression	Expression.makeGoto(GotoExpressionKind kind, LabelTarget target, Expression value, Type<?> type)
static GotoExpression	Expression.makeGoto(LabelTarget target, Expression value, Type<?> type)
static GotoExpression	Expression.makeGoto(LabelTarget target, Type<?> type)
static NewExpression	Expression.makeNew(Type<?> type, Expression... parameters)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static GotoExpression	Expression.makeReturn(LabelTarget target, Expression value, Type<?> type)
static GotoExpression	Expression.makeReturn(LabelTarget target, Type<?> type)
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)
private ParameterExpression	StackSpiller.makeTemp(Type type)
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)
(package private) static boolean	Expression.methodArgumentsMatch(MethodInfo method, Type<?>... argumentTypes)
static IllegalStateException	Error.methodDoesNotExistOnType(String methodName, Type type)
static IllegalStateException	Error.methodWithArgsDoesNotExistOnType(String methodName, Type type)
static IllegalStateException	Error.methodWithMoreThanOneMatch(String methodName, Type type)
static IllegalStateException	Error.mustRewriteChildToSameType(Type before, Type after, String callerName)
static NewArrayExpression	Expression.newArrayBounds(Type<?> elementType, Expression dimension)
static NewArrayExpression	Expression.newArrayInit(Type<?> elementType, Expression... initializers)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static NewArrayExpression	Expression.newArrayInit(Type<?> elementType, ExpressionList<? extends Expression> initializers)
static ParameterExpression	Expression.parameter(Type<?> type)
static ParameterExpression	Expression.parameter(Type<?> type, String name)
static IllegalStateException	Error.parameterExpressionNotValidForDelegate(Type parameterType, Type delegateParameterType)
(package private) static boolean	Expression.parameterIsAssignable(Type<?> parameterType, Type<?> argumentType)
(package private) static Type<?>	Expression.performBinaryNumericPromotion(Type<?> leftType, Type<?> rightType)
static IllegalStateException	Error.referenceEqualityNotDefined(Type leftType, Type rightType)
static Expression	Expression.self(Type<?> type)
static IllegalStateException	Error.targetAndMethodTypeMismatch(MethodBase method, Type targetType)
(package private) ParameterExpression	StackSpiller.TempMaker.temp(Type type)
static IllegalStateException	Error.testValueTypeDoesNotMatchComparisonMethodParameter(Type testValueType, Type parameterType)
static TypeBinaryExpression	Expression.typeEqual(Expression expression, Type<?> type)
static IllegalStateException	Error.unaryOperatorNotDefined(ExpressionType operator, Type operandType)
static UnaryExpression	Expression.unbox(Expression expression, Type<?> type)
private Type	LambdaCompiler.unboxLeftBinaryOperand(Type leftType, Type rightType)
static IllegalArgumentException	Error.unboxNotDefined(Type<?> boxedType, Type<?> unboxedType)
private Type	LambdaCompiler.unboxRightBinaryOperand(Type rightType)
static IllegalStateException	Error.undefinedVariable(String name, Type type, String currentLambdaName)
private static void	Expression.validateCallTargetType(Type<?> targetType, MethodInfo method)
private static void	ExpressionVisitor.validateChildType(Type before, Type after, String methodName)
private static Type<?>	Expression.validateCoalesceArgumentTypes(Type<?> left, Type<?> right)
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 <T extends Expression> T	Expression.validateOneArgument(MethodBase method, ExpressionType nodeKind, T arg, Type<?> parameterType)
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)
static ParameterExpression	Expression.variable(Type<?> type)
static ParameterExpression	Expression.variable(Type<?> type, String name)
private static void	Expression.verifyTypeBinaryExpressionOperand(Expression expression, Type<?> type)

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

Modifier	Constructor	Description
(package private)	CacheKey(Type<?> returnType, TypeList parameterTypes)
(package private)	CatchBlock(Type test, ParameterExpression variable, Expression body, Expression filter)
(package private)	DefaultValueExpression(Type type)
(package private)	FullConditionalExpressionWithType(Expression test, Expression ifTrue, Expression ifFalse, Type type)
(package private)	GotoExpression(GotoExpressionKind kind, LabelTarget target, Expression value, Type type)
(package private)	InvocationExpression(Expression lambda, ExpressionList<? extends Expression> arguments, Type returnType)
(package private)	LabelTarget(Type type, String name)
(package private)	LambdaExpression(Type<T> interfaceType, String name, Expression body, boolean tailCall, ParameterExpressionList parameters)
	MethodBinaryExpression(ExpressionType operator, Expression left, Expression right, Type type, MethodInfo method)
(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)	OpAssignMethodConversionBinaryExpression(ExpressionType nodeType, Expression left, Expression right, Type type, MethodInfo method, LambdaExpression<?> conversion)
(package private)	PrimitiveParameterExpression(Type type, String name)
(package private)	ScopeWithType(ParameterExpressionList variables, ExpressionList<? extends Expression> expressions, Type<?> type)
(package private)	SelfExpression(Type<?> type)
(package private)	SimpleBinaryExpression(ExpressionType nodeType, Expression left, Expression right, Type type)
(package private)	SuperExpression(Type<?> type)
	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)	TypedConstant(Object value, Type<?> type)
(package private)	TypedConstantExpression(Object value, Type type)
(package private)	TypedParameterExpression(Type type, String name)
(package private)	UnaryExpression(ExpressionType nodeType, Expression operand, Type type, MethodInfo method)

Uses of Type in com.strobel.reflection

Subclasses of Type in com.strobel.reflection

Modifier and Type	Class	Description
(package private) final class	ArrayType<T>
(package private) final class	BottomType
(package private) final class	CapturedType<T>
(package private) final class	CompoundType<T>
(package private) final class	ErasedType<T>
(package private) class	GenericParameter<T>
(package private) final class	GenericType<T>
(package private) final class	NullType
(package private) final class	PrimitiveType<T>
(package private) class	ReflectedType<T>
(package private) final class	RuntimeType<T>
(package private) class	WildcardType<T>

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

Modifier and Type	Class	Description
private static final class	Helper.Adapter
class	TypeList
class	TypeMapper<T>
class	TypeMapping
class	TypeRelation

Fields in com.strobel.reflection declared as Type

Modifier and Type	Field	Description
private static Type<?>	Helper._arraySuperType
private final Type<T>	RuntimeType._basedOn
private final Type<T>	CompoundType._baseType
private Type<?>	ErasedType._baseType
private Type<?>	GenericType._baseType
private Type<? super T>	ReflectedType._baseType
private Type<? super T>	RuntimeType._baseType
private final Type<?>	CapturedType._declaringType
private final Type<?>	DelegatingMethodInfo._declaringType
private final Type<?>	ErasedField._declaringType
private final Type<?>	ErasedMethod._declaringType
private Type<?>	GenericParameter._declaringType
private final Type	RawMember._declaringType
private final Type<?>	ReflectedConstructor._declaringType
private final Type<?>	ReflectedField._declaringType
private final Type<?>	ReflectedMethod._declaringType
private Type<?>	ReflectedType._declaringType
private final Type<?>	RuntimeFieldInfo._declaringType
private final Type<?>	RuntimeMethodInfo._declaringType
private final Type<?>	ArrayType._elementType
private Type<?>	RuntimeTypeCache._enclosingType
private final Type<T>	WildcardType._extendsBound
private final Type<?>	ErasedField._fieldType
private final Type<?>	ReflectedField._fieldType
private final Type<?>	RuntimeFieldInfo._fieldType
private final Type<?>	GenericType._genericTypeDefinition
private final Type<?>	CapturedType._lowerBound
private Type<?>	GenericParameter._lowerBound
private final Type<?>	ErasedType._originalType
private final Type<?>	ParameterInfo._parameterType
private final Type<?>	DelegatingMethodInfo._reflectedType
private final Type<?>	ReflectedField._reflectedType
private final Type<?>	ReflectedMethod._reflectedType
private final Type<?>	RuntimeType._reflectedType
private final Type<?>	SignatureType._returnType
private final Type<T>	RuntimeTypeCache._runtimeType
private final Type<?>	WildcardType._superBound
private final Type<?>	CapturedType._upperBound
private Type<?>	GenericParameter._upperBound
private final Type<?>	CapturedType._wildcard
static final Type<Annotation>	Types.Annotation
static final Type<ArrayList>	Types.ArrayList
static final Type<BigDecimal>	Types.BigDecimal
static final Type<BigInteger>	Types.BigInteger
static final Type<Boolean>	PrimitiveTypes.Boolean
static final Type<Boolean>	Types.Boolean
static final Type<BooleanBox>	Types.BooleanBox
static final Type<?>	Type.Bottom	Deprecated. Use Type.bottomType() instead.
(package private) static final Type<?>	Type.LazyConstants.Bottom
static final Type<Byte>	PrimitiveTypes.Byte
static final Type<Byte>	Types.Byte
static final Type<ByteBox>	Types.ByteBox
static final Type<Callable>	Types.Callable
static final Type<Character>	PrimitiveTypes.Character
static final Type<Character>	Types.Character
static final Type<CharacterBox>	Types.CharacterBox
static final Type<Class>	Types.Class
static final Type<ClassLoader>	Types.ClassLoader
static final Type<Cloneable>	Types.Cloneable
static final Type<Collection>	Types.Collection
static final Type<Comparable>	Types.Comparable
static final Type<Comparer>	Types.Comparer
static final Type<Date>	Types.Date
static final Type<Double>	PrimitiveTypes.Double
static final Type<Double>	Types.Double
static final Type<DoubleBox>	Types.DoubleBox
static final Type<?>[]	Type.EmptyTypes
static final Type<Enum>	Types.Enum
static final Type<Error>	Types.Error
static final Type<Exception>	Types.Exception
static final Type<Float>	PrimitiveTypes.Float
static final Type<Float>	Types.Float
static final Type<FloatBox>	Types.FloatBox
static final Type<HashMap>	Types.HashMap
static final Type<HashSet>	Types.HashSet
static final Type<IllegalArgumentException>	Types.IllegalArgumentException
static final Type<IllegalStateException>	Types.IllegalStateException
static final Type<Integer>	PrimitiveTypes.Integer
static final Type<Integer>	Types.Integer
static final Type<IntegerBox>	Types.IntegerBox
static final Type<Iterable>	Types.Iterable
static final Type<Iterator>	Types.Iterator
static final Type<List>	Types.List
static final Type<Long>	PrimitiveTypes.Long
static final Type<Long>	Types.Long
static final Type<LongBox>	Types.LongBox
static final Type<Map>	Types.Map
static final Type<MethodHandle>	Types.MethodHandle
(package private) static final Type<?>	Type.LazyConstants.NullType
static final Type<?>	Type.NullType	Deprecated. Use Type.nullType() instead.
static final Type<Number>	Types.Number
static final Type<Object>	Types.Object
static final Type<Objects>	Types.Objects
(package private) static final Type<?>[]	Type.PRIMITIVE_TYPES
private static final Type<?>[]	TypeParser.PRIMITIVE_TYPES
static final Type<Runnable>	Types.Runnable
static final Type<RuntimeException>	Types.RuntimeException
static final Type<Serializable>	Types.Serializable
static final Type<Set>	Types.Set
static final Type<Short>	PrimitiveTypes.Short
static final Type<Short>	Types.Short
static final Type<ShortBox>	Types.ShortBox
static final Type<String>	Types.String
static final Type<StringBuffer>	Types.StringBuffer
static final Type<StringBuilder>	Types.StringBuilder
static final Type<StrongBox>	Types.StrongBox
static final Type<System>	Types.System
(package private) final Type<?>	Helper.TypePair.t1
(package private) final Type<?>	Helper.TypePair.t2
static final Type<Throwable>	Types.Throwable
(package private) final Type<?>	TypeBinder.CacheEntry.type
static final Type<Type>	Types.Type
static final Type<UUID>	Types.UUID
static final Type<Void>	PrimitiveTypes.Void

Fields in com.strobel.reflection with type parameters of type Type

Modifier and Type	Field	Description
private final LinkedHashMap<Type<?>,Type<?>>	TypeCache._arrayMap
private final LinkedHashMap<Type<?>,Type<?>>	TypeCache._arrayMap
private final LinkedHashMap<String,Type<?>>	TypeCache._definitionMap
private final Map<Type,Type<?>>	Resolver.Frame._elementTypeMap
private RuntimeTypeCache.MemberInfoCache<Type<?>>	RuntimeTypeCache._interfaceCache
private final LinkedHashMap<TypeCache.Key, Type<?>>	TypeCache._map
private RuntimeTypeCache.MemberInfoCache<Type<?>>	RuntimeTypeCache._nestedTypeCache
private final ArrayList<Type<?>>	Resolver.Frame._typeArguments
private static final List<Type<?>>	PrimitiveTypes.AllPrimitives
private static final TypeVisitor<Type<?>,Type<?>>	Helper.AsSuperVisitor
private static final TypeVisitor<Type<?>,Type<?>>	Helper.AsSuperVisitor
private static final Map<Type<?>, ImmutableList<Type<?>>>	Helper.closureCache
private static final Map<Type<?>, ImmutableList<Type<?>>>	Helper.closureCache
(package private) ListBuffer<Type<?>>	Helper.Adapter.from
private static final SimpleVisitor<ImmutableList<Type<?>>, ImmutableList<Type<?>>>	Helper.InterfacesVisitor
private static final SimpleVisitor<ImmutableList<Type<?>>, ImmutableList<Type<?>>>	Helper.InterfacesVisitor
(package private) Map<Type<?>,Type<?>>	Helper.Adapter.mapping
(package private) Map<Type<?>,Type<?>>	Helper.Adapter.mapping
private static final UnaryTypeVisitor<Type<?>>	Helper.SuperTypeVisitor
(package private) ListBuffer<Type<?>>	Helper.Adapter.to
static final Type<Type>	Types.Type

Methods in com.strobel.reflection that return Type

Modifier and Type	Method	Description
private static Type<?>	Helper.arraySuperType()
static Type<?>	Helper.asOuterSuper(Type<?> t, Type<?> type)
static Type<?>	Helper.asSuper(Type<?> type, Type<?> other)
Type<?>	Type.asSuperTypeOf(Type<?> type)
static Type<?>	Type.bottomType()
static Type<?>	Helper.capture(Type<?> t)
protected Type<Object[]>	BottomType.createArrayType()
protected Type<T[]>	PrimitiveType.createArrayType()
protected Type<T[]>	Type.createArrayType()
static Type<?>	Helper.elementType(Type<?> t)
static Type<?>	Helper.erasure(Type<?> t)
private static Type<?>	Helper.erasure(Type<?> t, boolean recurse)
static Type<?>	Helper.erasureRecursive(Type<?> t)
Type<?>	TypeCache.find(TypeCache.Key key)
<T> Type<T>	TypeCache.find(Class<T> clazz)
Type	TypeBindings.findBoundType(String genericParameterName)
Type	TypeBindings.findGenericParameter(String genericParameterName)
(package private) Type<?>	Resolver.Frame.findType(Type e)
private static Type<?>	TypeParser.finishTopLevelType(String s, MutableInteger position)
static Type<?>	Type.forName(String name)
static Type<?>	Type.forName(String name, boolean throwOnError)
<T> Type<T[]>	TypeCache.getArrayType(Type<T> elementType)
Type<? super T>	CompoundType.getBaseType()
Type<? super T>	ErasedType.getBaseType()
Type<? super T>	GenericType.getBaseType()
Type<? super T>	ReflectedType.getBaseType()
Type<? super T>	RuntimeType.getBaseType()
Type<? super T>	Type.getBaseType()
Type	TypeBindings.getBoundType(int index)
Type	TypeBindings.getBoundType(Type genericParameter)
Type<?>	ArrayType.getDeclaringType()
Type<?>	BottomType.getDeclaringType()
Type<?>	CapturedType.getDeclaringType()
Type<?>	CompoundType.getDeclaringType()
Type<?>	DelegatingMethodInfo.getDeclaringType()
Type<?>	DynamicMethod.getDeclaringType()
Type<?>	ErasedField.getDeclaringType()
Type<?>	ErasedMethod.getDeclaringType()
Type<?>	ErasedType.getDeclaringType()
Type<?>	GenericMethod.getDeclaringType()
Type<?>	GenericParameter.getDeclaringType()
Type<?>	GenericType.getDeclaringType()
abstract Type<?>	MemberInfo.getDeclaringType()
Type<?>	NullType.getDeclaringType()
Type<?>	PrimitiveType.getDeclaringType()
final Type	RawMember.getDeclaringType()
Type<?>	ReflectedConstructor.getDeclaringType()
Type<?>	ReflectedField.getDeclaringType()
Type<?>	ReflectedMethod.getDeclaringType()
Type<?>	ReflectedType.getDeclaringType()
Type<?>	RuntimeConstructorInfo.getDeclaringType()
Type<?>	RuntimeFieldInfo.getDeclaringType()
Type<?>	RuntimeMethodInfo.getDeclaringType()
Type<?>	RuntimeType.getDeclaringType()
Type<?>	WildcardType.getDeclaringType()
Type<?>	ArrayType.getElementType()
Type<?>	Type.getElementType()
(package private) Type<?>	RuntimeTypeCache.getEnclosingType()
final Type<?>	Type.getErasedType()
Type<?>	CapturedType.getExtendsBound()
Type<?>	CompoundType.getExtendsBound()
Type<?>	GenericParameter.getExtendsBound()
Type<?>	Type.getExtendsBound()
Type<?>	WildcardType.getExtendsBound()
Type<?>	ErasedField.getFieldType()
abstract Type<?>	FieldInfo.getFieldType()
Type<?>	ReflectedField.getFieldType()
Type<?>	RuntimeFieldInfo.getFieldType()
Type	TypeBindings.getGenericParameter(int index)
<T> Type<T>	TypeCache.getGenericType(Type<T> type, TypeList typeArguments)
Type<?>	ArrayType.getGenericTypeDefinition()
Type<?>	ErasedType.getGenericTypeDefinition()
Type<?>	GenericType.getGenericTypeDefinition()
Type<?>	ReflectedType.getGenericTypeDefinition()
Type<?>	RuntimeType.getGenericTypeDefinition()
Type<?>	Type.getGenericTypeDefinition()
abstract Type<?>	LocalVariableInfo.getLocalType()
(package private) Type<?>	Type.getMostSpecificType(Type<?> t1, Type<?> t2)
final Type<?>	Type.getNestedType(String fullName)
Type<?>	Type.getNestedType(String fullName, Set<BindingFlags> bindingFlags)
private Type<?>[]	Type.getNestedTypeCandidates(String fullName, Set<BindingFlags> bindingFlags, boolean allowPrefixLookup)
Type<?>	ParameterInfo.getParameterType()
Type<?>	DelegatingMethodInfo.getReflectedType()
Type<?>	ErasedField.getReflectedType()
Type<?>	ErasedMethod.getReflectedType()
Type<?>	MemberInfo.getReflectedType()
Type<?>	ReflectedField.getReflectedType()
Type<?>	ReflectedMethod.getReflectedType()
Type<?>	RuntimeConstructorInfo.getReflectedType()
Type<?>	RuntimeFieldInfo.getReflectedType()
Type<?>	RuntimeMethodInfo.getReflectedType()
Type<?>	RuntimeType.getReflectedType()
(package private) Type<?>	RuntimeTypeCache.MemberInfoCache.getReflectedType()
Type<?>	Resolver.Frame.getResult()
Type<?>	DelegatingMethodInfo.getReturnType()
Type<?>	DynamicMethod.getReturnType()
Type<?>	ErasedMethod.getReturnType()
Type<?>	GenericMethod.getReturnType()
abstract Type<?>	MethodInfo.getReturnType()
Type<?>	ReflectedMethod.getReturnType()
Type<?>	RuntimeMethodInfo.getReturnType()
final Type<?>	SignatureType.getReturnType()
(package private) Type<?>	Type.getRootElementType()	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
(package private) Type<T>	RuntimeTypeCache.getRuntimeType()
Type<?>	CapturedType.getSuperBound()
Type<?>	GenericParameter.getSuperBound()
Type<?>	Type.getSuperBound()
Type<?>	WildcardType.getSuperBound()
static <T> Type<T>	Type.getType(T object)
final Type<?>	Type.getUnderlyingType()
protected Type<?>	ErasedType.getUnderlyingTypeCore()
protected Type<?>	Type.getUnderlyingTypeCore()
Type<?>	CapturedType.getWildcard()
Type<?>	ICapturedType.getWildcard()
static Type<?>	Helper.glb(Type<?> t, Type<?> p)
static Type<?>	Helper.lowerBound(Type<?> t)
final Type<T[]>	Type.makeArrayType()	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static <T> Type<T[]>	Type.makeArrayType(Type<T> elementType)
static Type<?>	Type.makeCompoundType(Type<?> baseType, TypeList interfaces)
static Type<?>	Type.makeCompoundType(TypeList bounds)
private static <T> Type<T>	Type.makeCompoundTypeCore(Type<T> baseType, TypeList interfaces)
static <T> Type<? extends T>	Type.makeExtendsWildcard(Type<T> bound)
final <U extends T> Type<U>	Type.makeGenericType(Type<?>... typeArguments)
final <U extends T> Type<U>	Type.makeGenericType(TypeList typeArguments)
protected Type<?>	ReflectedType.makeGenericTypeCore(TypeList typeArguments)
protected Type<?>	Type.makeGenericTypeCore(TypeList typeArguments)
static <T> Type<? super T>	Type.makeSuperWildcard(Type<T> bound)
static Type<?>	Type.nullType()
static <T> Type<T>	Type.of(Class<T> clazz)
(package private) static <T> Type<T>	Type.of(Type type)
static Type<?>	TypeParser.parse(String value)
static Type<?>	TypeParser.parseSignature(String signature)
private static Type<?>	TypeParser.parseTopLevelSignature(String s, MutableInteger position)
private static Type<?>	TypeParser.parseTypeArgument(String s, MutableInteger position, Type<?> genericType, int typeArgumentIndex)
Type<?>	Resolver.resolve(Type type)
private Type<?>	GenericMethod.resolveBindings(Type<?> type)
private static Type<?>	Type.resolveClassType(Class<?> actualClass)
private Type<?>	Resolver.resolveExisting(Resolver.Frame frame, Type type, boolean resolve)
(package private) Type<?>	Resolver.Frame.resolveType(Type t)
private Type<?>	Resolver.Frame.resolveTypeCore(Type t)
static Type<?>	Helper.substitute(Type<?> type, ImmutableList<Type<?>> genericParameters, ImmutableList<Type<?>> typeArguments)
static Type<?>	Helper.substitute(Type<?> type, TypeBindings bindings)
static Type<?>	Helper.substitute(Type<?> type, TypeList genericParameters, TypeList typeArguments)
protected static Type<?>	Type.substitute(Type<?> type, TypeBindings typeBindings)
static Type<?>	Helper.superType(Type<?> t)
(package private) static Type<?>	Type.tryFind(Type type)
static Type<?>	Helper.upperBound(Type<?> t)
private Type<?>	Resolver.visit(ReflectedType<?> type, Resolver.Frame frame, int flags)
private Type<?>	Resolver.visit(Type type, Resolver.Frame frame)
Type<?>	TypeEraser.visit(Type<?> type)
Type<?>	TypeBinder.visitArrayType(Type<?> type, TypeBindings bindings)
Type<?>	TypeEraser.visitArrayType(Type<?> type, TypeBindings bindings)
private Type<?>	Resolver.visitClass(Class<?> c, Resolver.Frame frame)
Type<?>	TypeBinder.visitClassType(Type<?> type, TypeBindings bindings)
Type<?>	TypeEraser.visitClassType(Type<?> type, TypeBindings bindings)
private Type<?>	Resolver.visitConstructor(Constructor<?> c, Resolver.Frame frame)
Type<?>	Resolver.visitField(Field field, Resolver.Frame frame)
private Type<?>	Resolver.visitGenericArrayType(GenericArrayType type, Resolver.Frame frame)
private Type<?>	Resolver.visitMethod(Method m, Resolver.Frame frame)
private Type<?>	Resolver.visitParameterizedType(ParameterizedType type, Resolver.Frame frame)
Type<?>	TypeMapper.visitType(Type<?> type, T parameter)
Type<?>	TypeBinder.visitTypeParameter(Type<?> type, TypeBindings bindings)
Type<?>	TypeEraser.visitTypeParameter(Type<?> type, TypeBindings bindings)
protected Type<?>	TypeBinder.visitTypeParameterCore(Type<?> type, TypeBindings bindings)
private Type<?>	Resolver.visitTypeVariable(TypeVariable<?> type, Resolver.Frame frame)
private Type<?>	Resolver.visitWildcardType(WildcardType w, Resolver.Frame frame)
Type<?>	TypeBinder.visitWildcardType(Type<?> type, TypeBindings bindings)
Type<?>	TypeEraser.visitWildcardType(Type<?> type, TypeBindings bindings)

Methods in com.strobel.reflection that return types with arguments of type Type

Modifier and Type	Method	Description
static List<Type<?>>	PrimitiveTypes.allPrimitives()
static ImmutableList<Type<?>>	Helper.closure(Type<?> t)
private static ImmutableList<Type<?>>	Helper.closureMin(ImmutableList<Type<?>> cl)
(package private) ArrayList<Type<?>>	RuntimeTypeCache.getInterfaceList(MemberListType listType, String name)
(package private) ArrayList<Type<?>>	RuntimeTypeCache.getNestedTypeList(MemberListType listType, String name)
(package private) List<Type<?>>	Resolver.Frame.getTypeArguments()
static ImmutableList<Type<?>>	Helper.insert(ImmutableList<Type<?>> cl, Type<?> t)
static ImmutableList<Type<?>>	Helper.interfaces(Type<?> type)
private ArrayList<Type<?>>	RuntimeTypeCache.MemberInfoCache.populateInterfaces(RuntimeTypeCache.Filter filter)
private ArrayList<Type<?>>	RuntimeTypeCache.MemberInfoCache.populateNestedClasses(RuntimeTypeCache.Filter filter)
static ImmutableList<Type<?>>	Helper.union(ImmutableList<Type<?>> cl1, ImmutableList<Type<?>> cl2)

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

Modifier and Type	Method	Description
static void	Helper.adapt(Type<?> source, Type<?> target, ListBuffer<Type<?>> from, ListBuffer<Type<?>> to)
void	Helper.Adapter.adapt(Type<?> source, Type<?> target)
private void	Helper.Adapter.adaptRecursive(Type<?> source, Type<?> target)
private static void	Helper.adaptSelf(Type<?> t, ListBuffer<Type<?>> from, ListBuffer<Type<?>> to)
void	TypeCache.add(Type<?> type)
(package private) MethodBase	RuntimeTypeCache.MemberInfoCache.addMethod(Type<?> declaringType, MethodBase method, RuntimeTypeCache.CacheType cacheType)
static MemberInfo	Helper.asMemberOf(Type<?> type, MemberInfo member)
static Type<?>	Helper.asOuterSuper(Type<?> t, Type<?> type)
static Type<?>	Helper.asSuper(Type<?> type, Type<?> other)
Type<?>	Type.asSuperTypeOf(Type<?> type)
static Type<?>	Helper.capture(Type<?> t)
static ImmutableList<Type<?>>	Helper.closure(Type<?> t)
boolean	TypeBindings.containsBoundType(Type type)
boolean	ConstructorInfo.containsGenericParameter(Type<?> genericParameter)
abstract boolean	MethodBase.containsGenericParameter(Type<?> genericParameter)
boolean	MethodInfo.containsGenericParameter(Type<?> genericParameter)
final boolean	SignatureType.containsGenericParameter(Type<?> genericParameter)
boolean	Type.containsGenericParameter(Type<?> genericParameter)
boolean	TypeBindings.containsGenericParameter(Type type)
final boolean	TypeList.containsGenericParameter(Type<?> genericParameter)
final boolean	TypeList.containsSubTypeOf(Type<?> type)
final boolean	TypeList.containsSuperTypeOf(Type<?> type)
(package private) static boolean	Helper.containsType(Type<?> t, Type<?> p)
final boolean	TypeList.containsTypeAssignableFrom(Type<?> type)
private static boolean	Helper.containsTypeEquivalent(Type<?> t, Type<?> p)
static boolean	Helper.covariantReturnType(Type<?> t, Type<?> s)
static TypeBindings	TypeBindings.create(TypeList genericParameters, Type... boundTypes)
(package private) static MethodInfo	MethodInfo.declaredOn(MethodInfo method, Type<?> declaringType, Type<?> reflectedType)
static Type<?>	Helper.elementType(Type<?> t)
static Type<?>	Helper.erasure(Type<?> t)
private static Type<?>	Helper.erasure(Type<?> t, boolean recurse)
static Type<?>	Helper.erasureRecursive(Type<?> t)
private boolean	Type.filterApplyType(Type<?> type, Set<BindingFlags> bindingFlags, String name, boolean prefixLookup)
(package private) boolean	Type.filterMethodBase(MethodBase method, Set<BindingFlags> methodFlags, Set<BindingFlags> bindingFlags, CallingConvention callingConventions, Type<?>... argumentTypes)
MethodInfo	DelegatingMethodInfo.findBaseMethod(Type<?> relativeTo)
MethodInfo	MethodInfo.findBaseMethod(Type<?> relativeTo)
private static int	DefaultBinder.findMostSpecific(ParameterList p1, int[] varArgOrder1, Type varArgArrayType1, ParameterList p2, int[] varArgOrder2, Type varArgArrayType2, Type[] types, Object[] args)
private static int	DefaultBinder.findMostSpecificMethod(MethodBase m1, int[] varArgOrder1, Type varArgArrayType1, MethodBase m2, int[] varArgOrder2, Type varArgArrayType2, Type[] types, Object[] args)
private static int	DefaultBinder.findMostSpecificType(Type c1, Type c2, Type t)
<T> Type<T[]>	TypeCache.getArrayType(Type<T> elementType)
Type	TypeBindings.getBoundType(Type genericParameter)
ConstructorInfo	PrimitiveType.getConstructor(Set<BindingFlags> bindingFlags, CallingConvention callingConvention, Type<?>... parameterTypes)
(package private) MethodBase	RuntimeTypeCache.getConstructor(Type<? super T> declaringType, MethodInfo constructor)
final ConstructorInfo	Type.getConstructor(Type<?>... parameterTypes)
ConstructorInfo	Type.getConstructor(Set<BindingFlags> bindingFlags, CallingConvention callingConvention, Type<?>... parameterTypes)
final ConstructorInfo	Type.getConstructor(Set<BindingFlags> bindingFlags, Type<?>... parameterTypes)
<T> Type<T>	TypeCache.getGenericType(Type<T> type, TypeList typeArguments)
(package private) static int	Binder.getHierarchyDepth(Type t)
MethodInfo	PrimitiveType.getMethod(String name, Set<BindingFlags> bindingFlags, CallingConvention callingConvention, Type<?>... parameterTypes)
(package private) MethodBase	RuntimeTypeCache.getMethod(Type<? super T> declaringType, MethodInfo method)
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)
private <M extends MethodBase> M[]	Type.getMethodBaseCandidates(MemberType type, String name, Set<BindingFlags> bindingFlags, CallingConvention callingConvention, Type<?>[] parameterTypes, boolean allowPrefixLookup)
(package private) Type<?>	Type.getMostSpecificType(Type<?> t1, Type<?> t2)
static Type<?>	Helper.glb(Type<?> t, Type<?> p)
boolean	TypeBindings.hasBoundParameter(Type genericParameter)
boolean	TypeBindings.hasConcreteParameter(Type genericParameter)
static int	Helper.hashCode(Type<?> t)
boolean	Type.implementsInterface(Type<?> interfaceType)
static RuntimeException	Error.incorrectNumberOfTypeArguments(Type type)
static boolean	Helper.inSamePackage(Type<?> t1, Type<?> t2)
static ImmutableList<Type<?>>	Helper.insert(ImmutableList<Type<?>> cl, Type<?> t)
static ImmutableList<Type<?>>	Helper.interfaces(Type<?> type)
static RuntimeException	Error.invalidAncestorType(Type<?> ancestorType, Type<?> declaringType)
static RuntimeException	Error.invalidSignatureNonGenericTypeTypeArguments(Type<?> type)
static boolean	Helper.isAssignable(Type<?> sourceType, Type<?> targetType)
boolean	BottomType.isAssignableFrom(Type<?> type)
boolean	Type.isAssignableFrom(Type<?> type)
static boolean	Helper.isCaptureOf(Type<?> p, Type<?> t)
static boolean	Helper.isConvertible(Type<?> sourceType, Type<?> targetType)
boolean	GenericParameter.isEquivalentTo(Type<?> member)
boolean	RuntimeType.isEquivalentTo(Type<?> other)
boolean	Type.isEquivalentTo(Type<?> other)
boolean	WildcardType.isEquivalentTo(Type<?> other)
static boolean	Helper.isInheritedIn(Type<?> site, MemberInfo member)
private static boolean	Helper.isOverridableIn(MethodInfo method, Type<?> origin)
static boolean	Helper.isReifiable(Type<?> t)
static boolean	Helper.isSameType(Type<?> t, Type<?> p)
static boolean	Helper.isSameWildcard(Type<?> t, Type<?> p)
static boolean	Helper.isSubtype(Type<?> t, Type<?> p)
static boolean	Helper.isSubtype(Type<?> t, Type<?> p, boolean capture)
static boolean	Helper.isSubtypeNoCapture(Type<?> t, Type<?> p)
boolean	Type.isSubTypeOf(Type<?> type)
static boolean	Helper.isSubtypeUnchecked(Type<?> t, Type<?> s)
static boolean	Helper.isSuperType(Type<?> type, Type<?> other)
TypeCache.Key	TypeCache.key(Type<?> type)
TypeCache.Key	TypeCache.key(Type<?> type, TypeList typeArguments)
static TypeList	Type.list(Type<?>... types)
static Type<?>	Helper.lowerBound(Type<?> t)
static <T> Type<T[]>	Type.makeArrayType(Type<T> elementType)
static Type<?>	Type.makeCompoundType(Type<?> baseType, TypeList interfaces)
private static <T> Type<T>	Type.makeCompoundTypeCore(Type<T> baseType, TypeList interfaces)
static <T> Type<? extends T>	Type.makeExtendsWildcard(Type<T> bound)
MethodInfo	DelegatingMethodInfo.makeGenericMethod(Type<?>... typeArguments)
MethodInfo	MethodInfo.makeGenericMethod(Type<?>... typeArguments)
final <U extends T> Type<U>	Type.makeGenericType(Type<?>... typeArguments)
static <T> Type<? super T>	Type.makeSuperWildcard(Type<T> bound)
static RuntimeException	Error.noElementType(Type type)
static RuntimeException	Error.notArrayType(Type type)
static RuntimeException	Error.notBoundedType(Type type)
static RuntimeException	Error.notEnumType(Type type)
static RuntimeException	Error.notGenericParameter(Type type)
static RuntimeException	Error.notGenericType(Type type)
static RuntimeException	Error.notGenericTypeDefinition(Type type)
static RuntimeException	Error.notWildcard(Type type)
static TypeList	TypeList.of(Type... types)
private static Type<?>	TypeParser.parseTypeArgument(String s, MutableInteger position, Type<?> genericType, int typeArgumentIndex)
private static void	TypeParser.parseTypeParameters(String s, MutableInteger position, Type<?> resolvedType, Type<?>[] typeArguments)
private void	RuntimeTypeCache.MemberInfoCache.populateRuntimeFields(RuntimeTypeCache.Filter filter, FieldList declaredFields, Type<?> declaringType, ArrayList<RuntimeFieldInfo> list)
static boolean	Helper.precedes(Type<?> origin, Type<?> other)
(package private) void	TypeCache.put(TypeCache.Key key, Type<?> type)
static int	Helper.rank(Type<?> t)
(package private) static MethodInfo	MethodInfo.reflectedOn(MethodInfo method, Type<?> reflectedType)
private Type<?>	GenericMethod.resolveBindings(Type<?> type)
abstract MethodBase	Binder.selectMethod(Set<BindingFlags> bindingFlags, MethodBase[] matches, Type[] parameterTypes)
MethodBase	DefaultBinder.selectMethod(Set<BindingFlags> bindingFlags, MethodBase[] matches, Type[] types)
(package private) void	ReflectedType.setBaseType(Type<?> baseType)
void	GenericParameter.setDeclaringType(Type<?> declaringType)
(package private) void	ReflectedType.setDeclaringType(Type<?> declaringType)
(package private) final void	GenericParameter.setLowerBound(Type<?> lowerBound)
(package private) final void	GenericParameter.setUpperBound(Type<?> upperBound)
static Type<?>	Helper.substitute(Type<?> type, ImmutableList<Type<?>> genericParameters, ImmutableList<Type<?>> typeArguments)
static Type<?>	Helper.substitute(Type<?> type, TypeBindings bindings)
static Type<?>	Helper.substitute(Type<?> type, TypeList genericParameters, TypeList typeArguments)
protected static Type<?>	Type.substitute(Type<?> type, TypeBindings typeBindings)
static Type<?>	Helper.superType(Type<?> t)
static RuntimeException	Error.typeCannotBeInstantiated(Type<?> t)
static RuntimeException	Error.typeInstantiationFailed(Type<?> t, Throwable cause)
static RuntimeException	Error.typeParameterNotDefined(Type typeParameter)
static Type<?>	Helper.upperBound(Type<?> t)
ConstructorList	TypeBinder.visit(Type<?> declaringType, ConstructorList constructors, TypeBindings bindings)
FieldList	TypeBinder.visit(Type<?> declaringType, FieldList fields, TypeBindings bindings)
MethodList	TypeBinder.visit(Type<?> declaringType, MethodList methods, TypeBindings bindings)
Type<?>	TypeEraser.visit(Type<?> type)
final Boolean	TypeRelation.visit(TypeList types, Type<?> p)
R	TypeVisitor.visit(Type<?> type)
final R	TypeVisitor.visit(Type<?> type, P parameter)
final R	UnaryTypeVisitor.visit(Type<?> t)
R	DefaultTypeVisitor.visitArrayType(Type<?> type, P parameter)
Void	Helper.Adapter.visitArrayType(Type<?> source, Type<?> target)
Type<?>	TypeBinder.visitArrayType(Type<?> type, TypeBindings bindings)
Type<?>	TypeEraser.visitArrayType(Type<?> type, TypeBindings bindings)
R	TypeVisitor.visitArrayType(Type<?> type, P parameter)
R	DefaultTypeVisitor.visitCapturedType(Type<?> type, P parameter)
R	SimpleVisitor.visitCapturedType(Type<?> t, P s)
R	TypeVisitor.visitCapturedType(Type<?> type, P parameter)
R	DefaultTypeVisitor.visitClassType(Type<?> type, P parameter)
Void	Helper.Adapter.visitClassType(Type<?> source, Type<?> target)
Type<?>	TypeBinder.visitClassType(Type<?> type, TypeBindings bindings)
Type<?>	TypeEraser.visitClassType(Type<?> type, TypeBindings bindings)
R	TypeVisitor.visitClassType(Type<?> type, P parameter)
ConstructorInfo	TypeBinder.visitConstructor(Type<?> declaringType, ConstructorInfo constructor, TypeBindings bindings)
FieldInfo	TypeBinder.visitField(Type<?> declaringType, FieldInfo field, TypeBindings bindings)
FieldInfo	TypeEraser.visitField(Type<?> declaringType, FieldInfo field, TypeBindings bindings)
MemberInfo	TypeBinder.visitMember(Type<?> declaringType, MemberInfo member, TypeBindings bindings)
MethodInfo	TypeBinder.visitMethod(Type<?> declaringType, MethodInfo method, TypeBindings bindings)
MethodInfo	TypeEraser.visitMethod(Type<?> declaringType, MethodInfo method, TypeBindings bindings)
R	DefaultTypeVisitor.visitPrimitiveType(Type<?> type, P parameter)
R	TypeVisitor.visitPrimitiveType(Type<?> type, P parameter)
Void	Helper.Adapter.visitType(Type<?> source, Type<?> target)
Type<?>	TypeMapper.visitType(Type<?> type, T parameter)
R	TypeVisitor.visitType(Type<?> type, P parameter)
R	DefaultTypeVisitor.visitTypeParameter(Type<?> type, P parameter)
Void	Helper.Adapter.visitTypeParameter(Type<?> source, Type<?> target)
Type<?>	TypeBinder.visitTypeParameter(Type<?> type, TypeBindings bindings)
Type<?>	TypeEraser.visitTypeParameter(Type<?> type, TypeBindings bindings)
R	TypeVisitor.visitTypeParameter(Type<?> type, P parameter)
protected Type<?>	TypeBinder.visitTypeParameterCore(Type<?> type, TypeBindings bindings)
R	DefaultTypeVisitor.visitWildcardType(Type<?> type, P parameter)
Void	Helper.Adapter.visitWildcardType(Type<?> source, Type<?> target)
Type<?>	TypeBinder.visitWildcardType(Type<?> type, TypeBindings bindings)
Type<?>	TypeEraser.visitWildcardType(Type<?> type, TypeBindings bindings)
R	TypeVisitor.visitWildcardType(Type<?> type, P parameter)
TypeBindings	TypeBindings.withAdditionalBinding(Type genericParameter, Type typeArgument)
TypeBindings	TypeBindings.withAdditionalParameter(Type genericParameter)

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

Modifier and Type	Method	Description
static void	Helper.adapt(Type<?> source, Type<?> target, ListBuffer<Type<?>> from, ListBuffer<Type<?>> to)
private static void	Helper.adaptSelf(Type<?> t, ListBuffer<Type<?>> from, ListBuffer<Type<?>> to)
private static ImmutableList<Type<?>>	Helper.closureMin(ImmutableList<Type<?>> cl)
(package private) static boolean	Helper.containsType(ImmutableList<Type<?>> ts, ImmutableList<Type<?>> ss)
(package private) static boolean	Helper.containsTypeEquivalent(ImmutableList<Type<?>> ts, ImmutableList<Type<?>> tp)
static ImmutableList<Type<?>>	Helper.insert(ImmutableList<Type<?>> cl, Type<?> t)
static TypeList	Type.list(List<? extends Type<?>> types)
static TypeList	TypeList.of(List<? extends Type<?>> types)
static Type<?>	Helper.substitute(Type<?> type, ImmutableList<Type<?>> genericParameters, ImmutableList<Type<?>> typeArguments)
static ImmutableList<Type<?>>	Helper.union(ImmutableList<Type<?>> cl1, ImmutableList<Type<?>> cl2)

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

Modifier	Constructor	Description
(package private)	ArrayType(Type<?> elementType)
(package private)	CacheEntry(TypeBindings bindings, Type<?> type)
(package private)	CapturedType(Type<?> declaringType, Type<?> upperBound, Type<?> lowerBound, Type<?> wildcard)
(package private)	CompoundType(TypeList interfaces, Type<T> baseType)
(package private)	DelegatingMethodInfo(MethodInfo method, Type<?> reflectedType)
(package private)	DelegatingMethodInfo(MethodInfo method, Type<?> declaringType, Type<?> reflectedType)
(package private)	ErasedField(FieldInfo baseField, Type<?> declaringType, Type<?> fieldType)
(package private)	ErasedMethod(MethodInfo baseMethod, Type<?> declaringType, ParameterList parameters, Type<?> returnType, TypeList thrownTypes, TypeBindings typeBindings)
(package private)	ErasedType(Type<?> baseType)
(package private)	GenericParameter(String name, MethodInfo declaringMethod, Type<?> upperBound, int position)
protected	GenericParameter(String name, MethodInfo declaringMethod, Type<?> upperBound, Type<?> lowerBound, int position)
(package private)	GenericParameter(String name, Type<?> declaringType, Type<?> upperBound, int position)
protected	GenericParameter(String name, Type<?> declaringType, Type<?> upperBound, Type<?> lowerBound, int position)
(package private)	GenericType(Type<?> genericTypeDefinition, Type<?>... typeArguments)
(package private)	GenericType(Type<?> genericTypeDefinition, TypeBindings typeBindings)
(package private)	GenericType(Type<?> genericTypeDefinition, TypeList typeArguments)
	Key(Type<?> simpleType)
	Key(Type<?> type, TypeList typeArguments)
	ParameterInfo(String name, int position, Type<?> parameterType)
	RawConstructor(Type context, Constructor<?> constructor)
	RawField(Type context, Field field)
protected	RawMember(Type context)
	RawMethod(Type context, Method method)
(package private)	ReflectedConstructor(Type<?> declaringType, Constructor<?> rawConstructor, ParameterList parameters, TypeList thrownTypes)
(package private)	ReflectedField(Type<?> declaringType, Type<?> reflectedType, Field rawField, Type<?> fieldType)
(package private)	ReflectedField(Type<?> declaringType, Field rawField, Type<?> fieldType)
(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)	RuntimeFieldInfo(Field rawField, Type<?> declaringType, RuntimeTypeCache<?> reflectedTypeCache, int modifiers, Set<BindingFlags> bindingFlags, Type<?> fieldType)
(package private)	RuntimeMethodInfo(MethodInfo baseMethod, Method rawMethod, Type<?> declaringType, RuntimeTypeCache<?> reflectedTypeCache, int modifiers, Set<BindingFlags> bindingFlags, ParameterList parameters, Type<?> returnType, TypeList thrownTypes, TypeBindings typeBindings)
(package private)	RuntimeType(Type<?> reflectedType, Type<T> basedOn, TypeBindings allBindings)
(package private)	RuntimeTypeCache(Type<T> runtimeType)
	SignatureType(Type<?> returnType, TypeList parameterTypes)
	TypeList(Type... elements)
	TypeList(Type[] elements, int offset, int length)
(package private)	TypePair(Type<?> t1, Type<?> t2)
(package private)	WildcardType(Type<T> extendsBound, Type<?> superBound)

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

Modifier	Constructor	Description
(package private)	Adapter(ListBuffer<Type<?>> from, ListBuffer<Type<?>> to)
	TypeList(List<? extends Type<?>> elements)

Uses of Type in com.strobel.reflection.emit

Subclasses of Type in com.strobel.reflection.emit

Modifier and Type	Class	Description
final class	GenericParameterBuilder<T>
final class	TypeBuilder<T>
(package private) final class	TypeBuilderInstantiation<T>

Subclasses with type arguments of type Type in com.strobel.reflection.emit

Modifier and Type	Class	Description
private static final class	Verifier.GenericParameterResolver

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

Modifier and Type	Field	Description
private final Type<A>	AnnotationBuilder._annotationType
private Type<?>	TypeBuilder._baseType
private Type<T>	TypeBuilderInstantiation._baseType
(package private) Type[]	__ExceptionInfo._catchClass
private Type<?>	TypeBuilder._extendsBound
private Type<T>	TypeBuilder._generatedType
private final Type	LocalBuilder._localType
private final Type<?>	ParameterBuilder._parameterType
private Type<?>	FieldBuilder._type
private Type<?>[]	CodeGenerator._unhandledExceptions
(package private) static final Type<MethodHandles.Lookup>	TypeBuilder.LazyTypes.LOOKUP
(package private) final Type<?>	ClassWriter.LocalInfo.type

Fields in com.strobel.reflection.emit with type parameters of type Type

Modifier and Type	Field	Description
private final Set<Type<?>>	Verifier.GenericParameterScopeVerifier._visitedTypes
(package private) final HashSet<Type<?>>	ConstantPool.referencedInnerTypes

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

Modifier and Type	Method	Description
Type<T>	TypeBuilder.createType()
Type<T>	TypeBuilder.createType(File outputFile)
Type<T>	TypeBuilder.createType(OutputStream outputStream)
private Type<T>	TypeBuilder.createTypeNoLock(OutputStream writeTo)
private static Type[]	__ExceptionInfo.enlargeArray(Type[] incoming)
private static Type<?>	TypeBuilder.erase(Type<?> t)
Type<A>	AnnotationBuilder.getAnnotationType()
Type<? super T>	GenericParameterBuilder.getBaseType()
Type<? super T>	TypeBuilder.getBaseType()
Type<? super T>	TypeBuilderInstantiation.getBaseType()
(package private) Type[]	__ExceptionInfo.getCatchClass()
Type<?>	TypeBuilderInstantiation.getDeclaringType()
Type<?>	GenericParameterBuilder.getExtendsBound()
Type<?>	TypeBuilder.getExtendsBound()
Type<?>	FieldBuilder.getFieldType()
Type<?>	TypeBuilder.getGenericTypeDefinition()
Type<?>	TypeBuilderInstantiation.getGenericTypeDefinition()
Type<?>	LocalBuilder.getLocalType()
Type<?>	GenericParameterBuilder.getNestedType(String fullName, Set<BindingFlags> bindingFlags)
Type<?>	TypeBuilder.getNestedType(String fullName, Set<BindingFlags> bindingFlags)
Type<?>	ParameterBuilder.getParameterType()
Type<?>	ConstructorBuilder.getReflectedType()
Type<?>	FieldBuilder.getReflectedType()
Type<?>	GenericParameterBuilder.getReflectedType()
Type<?>	MethodBuilder.getReflectedType()
Type<?>	TypeBuilder.getReflectedType()
Type<?>	TypeBuilderInstantiation.getReflectedType()
Type<?>	MethodBuilder.getReturnType()
Type<?>	GenericParameterBuilder.getSuperBound()
(package private) final Type<?>[]	CodeGenerator.getUnhandledCheckedExceptions()
(package private) static <T> Type<T>	TypeBuilderInstantiation.makeGenericType(TypeBuilder<T> type, TypeList typeArguments)
protected Type<?>	TypeBuilder.makeGenericTypeCore(TypeList typeArguments)
private Type<?>	TypeBuilderInstantiation.substitute(TypeList substitutes)

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

Modifier and Type	Method	Description
static RuntimeException	Error.annotationRequiresValue(Type<? extends Annotation> annotationType)
static RuntimeException	Error.attributeValueIncompatible(Type<?> attributeType, Type<?> valueType)
static RuntimeException	Error.baseTypeHasNoDefaultConstructor(Type<?> baseType)
void	CodeGenerator.beginCatchBlock(Type<?> caughtType)
static RuntimeException	Error.boxFailure(Type<?> type)
private static boolean	CodeGenerator.canEmitBytecodeConstant(Type<?> type)
static boolean	CodeGenerator.canEmitConstant(Object value, Type<?> type)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static RuntimeException	Error.cannotInstantiateUnboundGenericType(Type<?> type)
static IllegalStateException	Error.checkedExceptionUnhandled(Type<?> exceptionType)
private static <A extends Annotation> void	AnnotationBuilder.checkProperties(Type<A> annotationType, MethodList properties, ReadOnlyList<Object> values)
static <A extends Annotation> AnnotationBuilder<A>	AnnotationBuilder.create(Type<A> annotationType)
static <A extends Annotation> AnnotationBuilder<A>	AnnotationBuilder.create(Type<A> annotationType, MethodList properties, ReadOnlyList<Object> values)
static <A extends Annotation> AnnotationBuilder<A>	AnnotationBuilder.create(Type<A> annotationType, Object value)
LocalBuilder	CodeGenerator.declareLocal(Type<?> localType)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
LocalBuilder	CodeGenerator.declareLocal(String name, Type<?> localType)
FieldBuilder	TypeBuilder.defineConstant(String name, Type<?> type, int modifiers, Object constantValue)
FieldBuilder	TypeBuilder.defineField(String name, Type<?> type, int modifiers)
private FieldBuilder	TypeBuilder.defineFieldCore(String name, Type<?> type, int modifiers, Object constantValue)
MethodBuilder	TypeBuilder.defineMethod(String name, int modifiers, Type<?> returnType)
MethodBuilder	TypeBuilder.defineMethod(String name, int modifiers, Type<?> returnType, TypeList parameterTypes)
MethodBuilder	TypeBuilder.defineMethod(String name, int modifiers, Type<?> returnType, TypeList parameterTypes, TypeList thrownTypes)
private MethodBuilder	TypeBuilder.defineMethodCore(String name, int modifiers, Type<?> returnType, TypeList parameterTypes, TypeList thrownTypes)
void	CodeGenerator.dup(Type<?> type)
void	CodeGenerator.emit(OpCode opCode, Type<?> type)
final void	CodeGenerator.emitArray(Type<?> elementType, int count, CodeGenerator.EmitArrayElementCallback emit)
void	CodeGenerator.emitBox(Type<?> type)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
private void	CodeGenerator.emitBoxedToBoxedConversion(Type<?> sourceType, Type<?> targetType)
private void	CodeGenerator.emitBoxedToReferenceConversion(Type<?> sourceType)
private void	CodeGenerator.emitBoxedToUnboxedConversion(Type<?> sourceType, Type<?> targetType)
private void	CodeGenerator.emitBoxedToUnboxedNumericConversion(Type<?> sourceType, Type<?> targetType)
private void	CodeGenerator.emitBoxingConversion(Type<?> sourceType, Type<?> targetType)
private void	CodeGenerator.emitCastToType(Type<?> sourceType, Type<?> targetType)
void	CodeGenerator.emitConstant(Object value, Type<?> type)
void	CodeGenerator.emitConversion(Type<?> sourceType, Type<?> targetType)
void	CodeGenerator.emitDefaultValue(Type<?> type)
protected void	CodeGenerator.emitLoad(Type<?> type, int absoluteIndex)
void	CodeGenerator.emitLoadElement(Type<?> elementType)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void	CodeGenerator.emitNew(Type<?> type)	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void	CodeGenerator.emitNewArray(Type<?> arrayType)
void	CodeGenerator.emitNewArray(Type<?> arrayType, int dimensionsToInitialize)
private void	CodeGenerator.emitNumericConversion(Type<?> sourceType, Type<?> targetType)
void	CodeGenerator.emitReturn(Type<?> returnType)
protected void	CodeGenerator.emitStore(Type<?> type, int absoluteIndex)
void	CodeGenerator.emitStoreElement(Type<?> elementType)
void	CodeGenerator.emitType(Type<?> value)
void	CodeGenerator.emitUnbox(Type<?> type)
private void	CodeGenerator.emitUnboxedToBoxedConversion(Type<?> sourceType, Type<?> targetType)
private static Type[]	__ExceptionInfo.enlargeArray(Type[] incoming)
private static Type<?>	TypeBuilder.erase(Type<?> t)
private static MemberInfo	TypeBuilder.findPackageAccessDeclaration(Type<?> start, Function<Type<?>,Type<?>> next)
ConstructorInfo	GenericParameterBuilder.getConstructor(Set<BindingFlags> bindingFlags, CallingConvention callingConvention, Type<?>... parameterTypes)
ConstructorInfo	TypeBuilder.getConstructor(Set<BindingFlags> bindingFlags, CallingConvention callingConvention, Type<?>... parameterTypes)
private static OpCode	CodeGenerator.getLocalLoadOpCode(Type<?> type, int localIndex)
private static OpCode	CodeGenerator.getLocalStoreOpCode(Type<?> type, int localIndex)
MethodInfo	GenericParameterBuilder.getMethod(String name, Set<BindingFlags> bindingFlags, CallingConvention callingConvention, Type<?>... parameterTypes)
MethodInfo	TypeBuilder.getMethod(String name, Set<BindingFlags> bindingFlags, CallingConvention callingConvention, Type<?>... parameterTypes)
ConstantPool.TypeInfo	ConstantPool.getTypeInfo(Type<?> type)
(package private) short	TypeBuilder.getTypeToken(Type<?> type)
boolean	GenericParameterBuilder.implementsInterface(Type<?> interfaceType)
private void	TypeBuilder.initialize(String typeName, int modifiers, Type<?> baseType, TypeList interfaces, TypeBuilder<?> declaringType, MethodHandles.Lookup packageAccess)
static RuntimeException	Error.invalidCast(Type<?> sourceType, Type<?> targetType)
static RuntimeException	Error.invalidType(Type<?> type)
boolean	GenericParameterBuilder.isAssignableFrom(Type<?> type)
boolean	TypeBuilder.isAssignableFrom(Type<?> type)
boolean	GenericParameterBuilder.isEquivalentTo(Type<?> other)
boolean	TypeBuilder.isEquivalentTo(Type<?> other)
boolean	TypeBuilderInstantiation.isEquivalentTo(Type<?> other)
boolean	GenericParameterBuilder.isSubTypeOf(Type<?> type)
(package private) void	__ExceptionInfo.markCatchAddress(int catchAddress, Type catchException)
private void	__ExceptionInfo.markHelper(int catchOrFilterAddress, int catchEndAddress, Type catchClass, int type)
private boolean	ClassWriter.needsLocalVariableTableEntry(Type<?> localType)
static RuntimeException	Error.newArrayDimensionsOutOfRange(Type<?> arrayType, int dimensions)
static RuntimeException	Error.notGenericType(Type<?> type)
static UnsupportedOperationException	Error.notGenericTypeDefinition(Type<?> type)
void	CodeGenerator.pop(Type<?> type)
void	TypeBuilder.setBaseType(Type<?> baseType)
void	GenericParameterBuilder.setBaseTypeConstraint(Type<?> baseType)
void	FieldBuilder.setFieldType(Type<?> fieldType)
void	MethodBuilder.setReturnType(Type<?> type)
void	MethodBuilder.setSignature(Type<?> returnType, TypeList parameterTypes)
private static int	CodeGenerator.stackSize(Type<?> type)
private boolean	CodeGenerator.tryEmitConstant(Object value, Type<?> type)
static MethodHandles.Lookup	TypeBuilder.tryResolvePackageAccessForClass(Type<?> type)
static RuntimeException	Error.typeMustBeInterface(Type<?> type)
static RuntimeException	Error.typeNotAnAnnotation(Type<? extends Annotation> type)
(package private) static String	Verifier.typeVariableOutOfScopeError(Type<?> typeParameter, MemberInfo scope)
Boolean	Verifier.GenericParameterResolver.visitArrayType(Type<?> type, Type<?> s)
Void	Verifier.GenericParameterScopeVerifier.visitArrayType(Type<?> type, MemberInfo scope)
Boolean	Verifier.GenericParameterResolver.visitCapturedType(Type<?> t, Type<?> s)
Void	Verifier.GenericParameterScopeVerifier.visitCapturedType(Type<?> type, MemberInfo scope)
Boolean	Verifier.GenericParameterResolver.visitClassType(Type<?> type, Type<?> s)
Void	Verifier.GenericParameterScopeVerifier.visitClassType(Type<?> type, MemberInfo scope)
Boolean	Verifier.GenericParameterResolver.visitPrimitiveType(Type<?> type, Type<?> s)
Void	Verifier.GenericParameterScopeVerifier.visitPrimitiveType(Type<?> type, MemberInfo scope)
Boolean	Verifier.GenericParameterResolver.visitScope(MemberInfo scope, Type<?> s)
Boolean	Verifier.GenericParameterResolver.visitTypeParameter(Type<?> type, Type<?> s)
Void	Verifier.GenericParameterScopeVerifier.visitTypeParameter(Type<?> type, MemberInfo scope)
Boolean	Verifier.GenericParameterResolver.visitTypes(TypeList types, Type<?> s)
Boolean	Verifier.GenericParameterResolver.visitWildcardType(Type<?> type, Type<?> s)
Void	Verifier.GenericParameterScopeVerifier.visitWildcardType(Type<?> type, MemberInfo scope)
private void	ClassWriter.writeInnerTypeInfo(Type<?> type)

Method parameters in com.strobel.reflection.emit with type arguments of type Type

Modifier and Type	Method	Description
private static MemberInfo	TypeBuilder.findPackageAccessDeclaration(Type<?> start, Function<Type<?>,Type<?>> next)
private static MemberInfo	TypeBuilder.findPackageAccessDeclaration(Type<?> start, Function<Type<?>,Type<?>> next)

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

Modifier	Constructor	Description
private	AnnotationBuilder(Type<A> annotationType, MethodList attributes, ReadOnlyList<Object> values)
(package private)	FieldBuilder(TypeBuilder<?> typeBuilder, String name, Type<?> type, int modifiers, Object constantValue)
	LocalBuilder(int localIndex, String name, Type localType, MethodInfo methodBuilder)
(package private)	LocalInfo(String name, Type<?> type, int position, int start, int end)
(package private)	MethodBuilder(String name, int modifiers, Type<?> returnType, TypeList parameterTypes, TypeList thrownTypes, TypeBuilder<?> declaringType)
(package private)	ParameterBuilder(MethodBuilder declaringMethod, int position, String name, Type<?> parameterType)
(package private)	TypeBuilder(String name, int modifiers, Type<?> baseType, TypeBuilder<?> declaringType)
	TypeBuilder(String name, int modifiers, Type<?> baseType, TypeList interfaces)
	TypeBuilder(String name, int modifiers, Type<?> baseType, TypeList interfaces, MethodHandles.Lookup packageAccess)
(package private)	TypeBuilder(String name, int modifiers, Type<? super T> baseType, TypeList interfaces, TypeBuilder<?> declaringType)
(package private)	TypeBuilder(String name, int modifiers, Type<? super T> baseType, TypeList interfaces, TypeBuilder<?> declaringType, MethodHandles.Lookup packageAccess)

Uses of Type in com.strobel.util

Methods in com.strobel.util that return Type

Modifier and Type	Method	Description
static Type<?>	TypeUtils.getBoxedType(Type<?> type)
static Type<?>	TypeUtils.getBoxedTypeOrSelf(Type<?> type)
static Type<?>	TypeUtils.getUnderlyingPrimitive(Type<?> type)
static Type<?>	TypeUtils.getUnderlyingPrimitiveOrSelf(Type<?> type)

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

Modifier and Type	Method	Description
static boolean	TypeUtils.areEquivalent(Type<?> class1, Type<?> class2)
static boolean	TypeUtils.areReferenceAssignable(Type<?> destination, Type<?> source)
static int	TypeUtils.bitWidth(Type<?> type)
static Type<?>	TypeUtils.getBoxedType(Type<?> type)
static Type<?>	TypeUtils.getBoxedTypeOrSelf(Type<?> type)
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)
static Type<?>	TypeUtils.getUnderlyingPrimitive(Type<?> type)
static Type<?>	TypeUtils.getUnderlyingPrimitiveOrSelf(Type<?> type)
static boolean	TypeUtils.hasBuiltInEqualityOperator(Type<?> left, Type<?> right)
static boolean	TypeUtils.hasIdentityPrimitiveOrBoxingConversion(Type<?> source, Type<?> destination)
static boolean	TypeUtils.hasReferenceConversion(Type<?> source, Type<?> destination)
static boolean	TypeUtils.hasReferenceEquality(Type<?> left, Type<?> right)
static boolean	TypeUtils.isArithmetic(Type<?> type)
static boolean	TypeUtils.isAutoUnboxed(Type<?> type)
static boolean	TypeUtils.isBoolean(Type<?> type)
static boolean	TypeUtils.isDoubleWord(Type<?> type)
static boolean	TypeUtils.isImplicitNumericConversion(Type<?> sourceType, Type<?> targetType)
static boolean	TypeUtils.isIntegral(Type<?> type)
static boolean	TypeUtils.isIntegralOrBoolean(Type<?> type)
static boolean	TypeUtils.isNumeric(Type<?> type)
static boolean	TypeUtils.isSameOrSubType(Type<?> type, Type<?> subType)
static boolean	TypeUtils.isSingleWord(Type<?> type)
static boolean	TypeUtils.isSubWordOrInt32(Type<?> type)
static boolean	TypeUtils.isValidInvocationTargetType(MethodInfo method, Type<?> targetType)