private GenericParameter GetGenericParameter(GenericParameterType type, uint var)
{
IGenericParameterProvider method;
IGenericContext genericContext = this.reader.context;
int num = (int)var;
if (genericContext == null)
{
return(this.GetUnboundGenericParameter(type, num));
}
if (type == GenericParameterType.Type)
{
method = genericContext.Type;
}
else
{
if (type != GenericParameterType.Method)
{
throw new NotSupportedException();
}
method = genericContext.Method;
}
if (!genericContext.IsDefinition)
{
SignatureReader.CheckGenericContext(method, num);
}
if (num >= method.GenericParameters.Count)
{
return(this.GetUnboundGenericParameter(type, num));
}
return(method.GenericParameters[num]);
}
public CodeType ToCodeType(Type type, bool parseGenerics = true)
{
if (CodeType.ByName(type.Name.ToLower()) != null)
{
return(CodeType.ByName(type.Name.ToLower()));
}
UserType ut = null;
if (type.IsArray)
{
ut = new ArrayType(ToCodeType(type.GetElementType()));
}
else if (type.IsGenericType && parseGenerics)
{
CodeType[] parameters = new CodeType[type.GetGenericArguments().Length];
for (int i = 0; i < parameters.Length; i++)
{
parameters[i] = new GenericParameterType(ToCodeType(type.GetGenericArguments()[i]), i);
}
ut = GenericType.NewGenericType(UserType.NewUserType(type), parameters);
}
else
{
ut = UserType.NewUserType(type);
}
if (ut != null)
{
ReferenceTracker.AddUsedReference(ut.GetAssembly());
}
return(ut);
}
private GenericParameter GetGenericParameter(GenericParameterType type, uint var)
{
IGenericContext context = this.reader.context;
if (context == null)
{
return(this.GetUnboundGenericParameter(type, (int)var));
}
IGenericParameterProvider genericParameterProvider;
switch (type)
{
case GenericParameterType.Type:
genericParameterProvider = context.Type;
break;
case GenericParameterType.Method:
genericParameterProvider = context.Method;
break;
default:
throw new NotSupportedException();
}
if (!context.IsDefinition)
{
SignatureReader.CheckGenericContext(genericParameterProvider, (int)var);
}
if (var >= (uint)genericParameterProvider.GenericParameters.Count)
{
return(this.GetUnboundGenericParameter(type, (int)var));
}
return(genericParameterProvider.GenericParameters[(int)var]);
}
static TypeInfo bindGenericParameters(Library typeSystem, GenericParameterBindings genericsScope, TypeInfo typeInfo)
{
if (genericsScope.hasBinding(typeInfo))
{
return(genericsScope.getBindingValue(typeInfo));
}
else if (typeInfo.IsArray)
{
return(bindGenericParameters(typeSystem, genericsScope, typeInfo.ElementType).ArrayType);
}
else if (typeInfo.TypeKind == TypeKind.UpperBoundedWildcard)
{
return(bindGenericParameters(typeSystem, genericsScope, typeInfo.WildcardBound).UpperBoundedWildcard);
}
else if (typeInfo.TypeKind == TypeKind.LowerBoundedWildcard)
{
return(bindGenericParameters(typeSystem, genericsScope, typeInfo.WildcardBound).LowerBoundedWildcard);
}
else if (!typeInfo.IsClosed && typeInfo.GenericArguments.any())
{
return(typeSystem.getGenericType(typeInfo, bindGenericParameters(typeSystem, genericsScope, typeInfo.GenericArguments), genericsScope));
}
else if (typeInfo.IsGenericParameter && typeInfo.GenericParameterBounds.any())
{
var param = new GenericParameterType(typeSystem, typeInfo.FullName, typeInfo);
genericsScope.declareBinding(typeInfo, param);
foreach (var t in typeInfo.GenericParameterBounds)
{
param.genericParameterBounds.add(bindGenericParameters(typeSystem, genericsScope, t));
}
return(param);
}
return(typeInfo);
}
public DummyGenericParameterProvider(bool methodTypeParameter)
{
type = methodTypeParameter ? GenericParameterType.Method :
GenericParameterType.Type;
parameters = new Mono.Collections.Generic.Collection <GenericParameter>(1);
parameters.Add(new GenericParameter(this));
}
private ClrGenericParameterStandin(
GenericParameterType kind,
int position)
{
this.Kind = kind;
this.Position = position;
}
private GenericParameter GetGenericParameter(GenericParameterType type, uint var)
{
IGenericParameterProvider method;
IGenericContext context = this.reader.context;
int index = (int)var;
if (context == null)
{
return(this.GetUnboundGenericParameter(type, index));
}
switch (type)
{
case GenericParameterType.Type:
method = context.Type;
break;
case GenericParameterType.Method:
method = context.Method;
break;
default:
throw new NotSupportedException();
}
if (!context.IsDefinition)
{
CheckGenericContext(method, index);
}
return((index < method.GenericParameters.Count) ? method.GenericParameters[index] : this.GetUnboundGenericParameter(type, index));
}
public void ResolveGenericParameterWithEmptyTypeShouldThrow(GenericParameterType parameterType)
{
var context = new GenericContext();
var parameter = new GenericParameterSignature(parameterType, 0);
Assert.Throws <ArgumentOutOfRangeException>(() => context.GetTypeArgument(parameter));
}
public void SzArrayType(GenericParameterType parameterType, int index)
{
// 0![]
var signature = new SzArrayTypeSignature(new GenericParameterSignature(parameterType, index));
Assert.Equal(new SzArrayTypeSignature(GetTypeArguments(parameterType)[index]),
signature.InstantiateGenericTypes(_context), Comparer);
}
public TypeInfo addGenericArgument(String name)
{
checkCreated();
var type = new GenericParameterType(this.DeclaringType.Library, name, null);
genericArguments.add(type);
return(type);
}
/// <summary>
/// Creates a generic parameter stand-in.
/// </summary>
/// <param name="kind">
/// The kind of generic parameter to create a stand-in for.
/// </param>
/// <param name="position">
/// The position of the generic parameter in the generic
/// parameter list.
/// </param>
/// <returns>A generic parameter stand-in.</returns>
internal static ClrGenericParameterStandin Create(
GenericParameterType kind,
int position)
{
return(instanceCache.Intern(
new ClrGenericParameterStandin(
kind,
position)));
}
private ClrGenericParameterStandin(
GenericParameterType kind,
int position,
bool isReferenceType)
{
this.Kind = kind;
this.Position = position;
this.IsReferenceType = isReferenceType;
}
public GenericParameterTypeRefResolver(GenericParameterType type, int index)
{
_type = type;
_index = index;
if (index < 0)
{
throw new WeavingException($"Invalid generic parameter index: {index}");
}
}
private static GenericParameter CreateGenericParameter(int position, GenericParameterType type, ModuleDefinition module)
{
return((GenericParameter)typeof(GenericParameter)
.GetConstructor(
BindingFlags.NonPublic | BindingFlags.Instance,
null,
new[] { typeof(int), typeof(GenericParameterType), typeof(ModuleDefinition) },
null)
.Invoke(new object[] { position, type, module }));
}
internal GenericParameter(int position, GenericParameterType type, ModuleDefinition module)
: base(string.Empty, string.Empty)
{
Mixin.CheckModule(module);
this.position = position;
this.type = type;
base.etype = ConvertGenericParameterType(type);
base.module = module;
base.token = new MetadataToken(TokenType.GenericParam);
}
private InvokeMethodInfo BuildInvokeMethod(BuildMethod method, List <TypeSignature> genericArguments)
{
var invokeMethodInfo = new InvokeMethodInfo();
int argumentCount = method.Parameters.Count + 1;
if (method.HasThis)
{
argumentCount++;
}
var arguments = new TypeSignature[argumentCount];
var parameterFlags = new int[argumentCount];
// Arguments
{
int index = 0;
if (method.HasThis)
{
arguments[index++] = new GenericParameterType(true, 0);
genericArguments.Add(TypeReference.GetPrimitiveType(PrimitiveTypeCode.Object, _module.Assembly));
}
var parameters = method.Parameters;
for (int i = 0; i < parameters.Count; i++)
{
var parameter = parameters[i];
arguments[index] = BuildType(parameter.Type, genericArguments);
parameterFlags[index] = GetParameterFlags(parameter);
index++;
}
// index : [mscorlib]System.Int32
arguments[index++] = TypeReference.GetPrimitiveType(PrimitiveTypeCode.Int32, _module.Assembly);
}
var returnType = BuildType(method.ReturnType.Type, genericArguments);
invokeMethodInfo.CallSite =
new CallSite(
false,
false,
MethodCallingConvention.Default,
returnType,
arguments,
-1,
genericArguments.Count);
invokeMethodInfo.ParameterFlags = parameterFlags;
invokeMethodInfo.GenericParameterCount = genericArguments.Count;
return(invokeMethodInfo);
}
DataType TryGetGenericTypeFromMethodGroup(GenericParameterType gt, DelegateType dt, MethodGroup mg, GenericParameterType[] gparams, DataType[] gargs)
{
dt.AssignBaseType();
var pl = dt.Parameters;
foreach (var c in mg.Candidates)
{
var m = c;
if (m.IsGenericDefinition)
{
DataType[] typeArgs;
if (TryGetGenericTypeArgumentsFromParameterList(c.GenericParameters, c.Parameters,
dt.GenericArguments, out typeArgs))
{
for (int i = 0; i < typeArgs.Length; i++)
{
typeArgs[i] = TryParameterize(typeArgs[i], gparams, gargs);
if (typeArgs[i] == null)
{
goto CONTINUE;
}
}
m = TypeBuilder.Parameterize(mg.Source, c, typeArgs);
}
else
{
goto CONTINUE;
}
}
for (int j = 0; j < Math.Min(pl.Length, m.Parameters.Length); j++)
{
var at = TryGetGenericTypeArgumentRecursive(gt, pl[j].Type, m.Parameters[j].Type);
if (at != null)
{
return(at);
}
}
if (!m.ReturnType.IsVoid)
{
var at = TryGetGenericTypeArgumentRecursive(gt, dt.ReturnType, m.ReturnType);
if (at != null)
{
return(at);
}
}
CONTINUE:
;
}
return(null);
}
public static GenericArgumentOwnerType CecilGenericOwnerToC2JGenericOwner(GenericParameterType cecilOwner)
{
switch (cecilOwner)
{
case GenericParameterType.Method: return(GenericArgumentOwnerType.Method);
case GenericParameterType.Type: return(GenericArgumentOwnerType.Type);
default: return(GenericArgumentOwnerType.Type);
}
}
public GenericParameter(string name, IGenericParameterProvider owner) : base(string.Empty, name)
{
if (owner == null)
{
throw new ArgumentNullException();
}
this.position = -1;
this.owner = owner;
this.type = owner.GenericParameterType;
base.etype = ConvertGenericParameterType(this.type);
base.token = new MetadataToken(TokenType.GenericParam);
}
private static ElementType ConvertGenericParameterType(GenericParameterType type)
{
switch (type)
{
case GenericParameterType.Type:
return(ElementType.Var);
case GenericParameterType.Method:
return(ElementType.MVar);
}
throw new ArgumentOutOfRangeException();
}
internal GenericParameter(int position, GenericParameterType type, ModuleDefinition module) : base(string.Empty, string.Empty)
{
if (module == null)
{
throw new ArgumentNullException();
}
this.position = position;
this.type = type;
base.etype = ConvertGenericParameterType(type);
base.module = module;
base.token = new MetadataToken(TokenType.GenericParam);
}
private DelegateTypeInfo BuildInfo(BuildMethod method, List <TypeSignature> genericArguments)
{
var typeInfo = new DelegateTypeInfo();
int argumentCount = method.Parameters.Count;
if (method.HasThis)
{
argumentCount++;
}
var arguments = new TypeSignature[argumentCount];
var parameterFlags = new int[argumentCount];
if (argumentCount > 0)
{
int index = 0;
if (method.HasThis)
{
arguments[index++] = new GenericParameterType(false, 0);
genericArguments.Add(TypeReference.GetPrimitiveType(PrimitiveTypeCode.Object, _module.Assembly));
}
var parameters = method.Parameters;
for (int i = 0; i < parameters.Count; i++)
{
var parameter = parameters[i];
arguments[index] = BuildType(parameter.Type, genericArguments);
parameterFlags[index] = GetParameterFlags(parameter);
index++;
}
}
var returnType = BuildType(method.ReturnType.Type, genericArguments);
typeInfo.InvokeCallSite =
new CallSite(
true,
false,
MethodCallingConvention.Default,
returnType,
arguments,
-1,
0);
typeInfo.InvokeParameterFlags = parameterFlags;
typeInfo.GenericParameterCount = genericArguments.Count;
return(typeInfo);
}
public GenericParameter(int position, GenericParameterType type, ModuleDefinition module)
: base(string.Empty, string.Empty)
{
if (module == null)
{
throw new ArgumentNullException();
}
this.position = position;
this.type = type;
this.etype = ConvertGenericParameterType(type);
this.module = module;
}
private IList <TypeSignature> GetTypeArguments(GenericParameterType type)
{
switch (type)
{
case GenericParameterType.Type:
return(_typeArgs);
case GenericParameterType.Method:
return(_methodArgs);
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
public void ArrayType(GenericParameterType parameterType, int index)
{
// 0![0..10]
var genericParameter = new GenericParameterSignature(parameterType, index);
var signature = new ArrayTypeSignature(genericParameter)
{
Dimensions = { new ArrayDimension(10, 0) }
};
Assert.Equal(new ArrayTypeSignature(GetTypeArguments(parameterType)[index])
{
Dimensions = { new ArrayDimension(10, 0) }
}, signature.InstantiateGenericTypes(_context), Comparer);
}
public TypeParameterKind GetTypeParameterKind(GenericParameterType type)
{
switch (type)
{
case GenericParameterType.Type:
return(TypeParameterKind.Type);
case GenericParameterType.Method:
return(TypeParameterKind.Method);
default:
{
throw new Exception($"Expected either a type parameter kind of type or method, but not {type.ToString()}");
}
}
}
DataType TryGetGenericTypeArgumentRecursive(GenericParameterType gt, DataType pt, DataType at)
{
if (pt.Equals(gt))
{
return(at);
}
if (at.IsArray)
{
if (pt.IsArray)
{
return(TryGetGenericTypeArgumentRecursive(gt, pt.ElementType, at.ElementType));
}
if (pt.MasterDefinition == Essentials.IEnumerable_T && pt.IsGenericParameterization)
{
return(TryGetGenericTypeArgumentRecursive(gt, pt.GenericArguments[0], at.ElementType));
}
}
if (pt.IsFlattenedParameterization && at.IsFlattenedParameterization && pt.FlattenedArguments.Length == at.FlattenedArguments.Length)
{
for (int i = 0; i < pt.FlattenedArguments.Length; i++)
{
var dt = TryGetGenericTypeArgumentRecursive(gt, pt.FlattenedArguments[i], at.FlattenedArguments[i]);
if (dt != null)
{
return(dt);
}
}
}
for (int i = 0; i < at.Interfaces.Length; i++)
{
var dt = TryGetGenericTypeArgumentRecursive(gt, pt, at.Interfaces[i]);
if (dt != null)
{
return(dt);
}
}
if (at.Base != null)
{
return(TryGetGenericTypeArgumentRecursive(gt, pt, at.Base));
}
return(null);
}
void SetConstraints(GenericTypeParameterBuilder builder, GenericParameterType definition)
{
var attrs = GenericParameterAttributes.None;
switch (definition.ConstraintType)
{
case GenericConstraintType.Class:
if (definition.Base != _essentials.Object)
{
builder.SetBaseTypeConstraint(_linker.GetType(definition.Base));
}
else
{
attrs |= GenericParameterAttributes.ReferenceTypeConstraint;
}
break;
case GenericConstraintType.Struct:
attrs |= GenericParameterAttributes.NotNullableValueTypeConstraint;
break;
}
if (definition.Constructors.Count > 0)
{
attrs |= GenericParameterAttributes.DefaultConstructorConstraint;
}
if (attrs != GenericParameterAttributes.None)
{
builder.SetGenericParameterAttributes(attrs);
}
if (definition.Interfaces.Length > 0)
{
var interfaceTypes = new Type[definition.Interfaces.Length];
for (int j = 0; j < definition.Interfaces.Length; j++)
{
interfaceTypes[j] = _linker.GetType(definition.Interfaces[j]);
}
builder.SetInterfaceConstraints(interfaceTypes);
}
}
private void LoadActions()
{
var mscorlib = AssemblyReference.GetMscorlib(_module.Assembly);
for (int i = 0; i < 9; i++)
{
var delegateType = new DelegateType();
var arguments = new TypeSignature[i];
for (int j = 0; j < i; j++)
{
arguments[j] = new GenericParameterType(false, j);
}
delegateType.InvokeCallSite =
new CallSite(
true,
false,
MethodCallingConvention.Default,
TypeReference.GetPrimitiveType(PrimitiveTypeCode.Void, _module.Assembly),
arguments,
-1,
0);
string name = "Action";
if (i > 0)
{
name += "`" + i.ToString();
}
delegateType.DeclaringType = new TypeReference(
name,
"System",
mscorlib,
false);
delegateType.GenericParameterCount = i;
delegateType.InvokeParameterFlags = new int[i];
_types.TryAdd(CreateTypeInfo(delegateType));
}
}
public GenericParameter Retarget(GenericParameter value)
{
IGenericParameterProvider provider;
GenericParameterType type = value.Type;
if (type != GenericParameterType.Type)
{
if (type != GenericParameterType.Method)
{
throw new Exception(string.Format("Unknown GenericParameterType value {0}.", value.Type));
}
}
else
{
provider = this.types.Peek();
goto Label_00DC;
}
provider = this.methods.Peek();
if (!provider.HasGenericParameters)
{
MethodReference reference = (MethodReference)provider;
if (reference.DeclaringType.IsArray)
{
ArrayType declaringType = (ArrayType)reference.DeclaringType;
if (declaringType.ElementType.IsGenericParameter)
{
GenericParameter elementType = (GenericParameter)declaringType.ElementType;
if (elementType.FullName.Equals(value.FullName))
{
return(elementType);
}
}
}
throw new Exception(string.Format("Unknown generic parameter {0}.", value));
}
Label_00DC:
if (provider.GenericParameters.Count == 0)
{
return(value);
}
return(provider.GenericParameters.Single <GenericParameter>(p => (p.Position == value.Position)));
}
protected override void initializeMethods() {
if (classInfo == null || classInfo.methods == null) {
return;
}
initializeBaseTypes();
foreach (var m in classInfo.methods) {
var method = new ClassFileMethod(this, m.name, m.descriptor);
method.modifiers = m.modifiers;
methods.add(method);
if (m.signature == null) {
method.returnType = getTypeInfo(m.returnType);
int i = 0;
foreach (var p in m.parameters) {
var pi = new ParameterInfo(i++, getTypeInfo(p.type));
method.parameters.add(pi);
if (p.annotations == null) {
pi.annotations = Collections.emptyList();
} else {
pi.annotations = buildAnnotationValues(p.annotations);
}
}
if (m.exceptions == null) {
method.exceptions = Collections.emptyList();
} else {
var ex = new ArrayList<TypeInfo>();
foreach (var s in m.exceptions) {
var t = typeSystem.getType(s);
if (hasGenericArguments(t)) {
t = t.RawType;
}
ex.add(t);
}
method.exceptions = ex;
}
method.genericArguments = Collections.emptyList();
} else {
genericsScope.enterScope();
var genArgs = new ArrayList<TypeInfo>();
foreach (var t in m.signature.FormalTypeParameters) {
var tp = new GenericParameterType(this.Library, t.Name, null);
genArgs.add(tp);
genericsScope.declareBinding(t.Name, tp);
}
method.genericArguments = genArgs;
int i = 0;
foreach (var t in m.signature.getFormalTypeParameters()) {
if (t.FormalTypeParameterBounds.any()) {
foreach (var ts in t.FormalTypeParameterBounds) {
((GenericParameterType)genArgs[i]).genericParameterBounds.add(getTypeInfo(ts));
}
}
i++;
}
method.returnType = getTypeInfo(m.signature.ReturnType);
i = 0;
foreach (var param in m.signature.Parameters) {
var annotations = m.parameters[i].annotations;
var pi = new ParameterInfo(i++, getTypeInfo(param));
method.parameters.add(pi);
if (annotations == null) {
pi.annotations = Collections.emptyList();
} else {
pi.annotations = buildAnnotationValues(annotations);
}
}
var excepts = new ArrayList<TypeInfo>();
foreach (var t in m.signature.Exceptions) {
excepts.add(getTypeInfo(t));
}
method.exceptions = excepts;
genericsScope.leaveScope();
}
if (m.defaultValue != null) {
method.defaultValue = buildAnnotationArrayElement(m.defaultValue);
}
if (m.annotations == null) {
method.annotations = Collections.emptyList();
} else {
method.annotations = buildAnnotationValues(m.annotations);
}
}
classInfo.methods = null;
if (classInfo.fields == null) {
classInfo = null;
genericsScope = null;
}
}
protected override void initializeBaseTypes() {
if (classInfo == null || classInfo.name == null) {
return;
}
classInfo.name = null;
ReflectionHelper.declareEnclosingGenericParameters(genericsScope, this);
if (classInfo.signature == null) {
genericArguments = Query.empty();
if (classInfo.superName != null) {
baseType = typeSystem.getType(classInfo.superName);
if (hasGenericArguments(baseType)) {
baseType = baseType.RawType;
}
if (classInfo.interfaces != null) {
var ints = new ArrayList<TypeInfo>(sizeof(classInfo.interfaces));
foreach (var s in classInfo.interfaces) {
var t = typeSystem.getType(s);
if (hasGenericArguments(t)) {
t = t.RawType;
}
ints.add(t);
}
interfaces = ints;
} else {
interfaces = Query.empty();
}
} else {
interfaces = Query.empty();
}
} else {
if (classInfo.signature.FormalTypeParameters.any()) {
var genArgs = new ArrayList<TypeInfo>();
foreach (var t in classInfo.signature.FormalTypeParameters) {
var tp = new GenericParameterType(this.Library, t.Name, null);
genArgs.add(tp);
genericsScope.declareBinding(t.Name, tp);
}
genericArguments = genArgs;
int i = 0;
foreach (var t in classInfo.signature.FormalTypeParameters) {
if (t.FormalTypeParameterBounds.any()) {
foreach (var ts in t.FormalTypeParameterBounds) {
((GenericParameterType)genArgs[i]).genericParameterBounds.add(getTypeInfo(ts));
}
}
i++;
}
} else {
genericArguments = Query.empty();
}
if (classInfo.signature.Superclass != null) {
baseType = getTypeInfo(classInfo.signature.Superclass);
}
int n = classInfo.signature.Superinterfaces.count();
if (n > 0) {
var ints = new ArrayList<TypeInfo>(n);
foreach (var t in classInfo.signature.Superinterfaces) {
ints.add(getTypeInfo(t));
}
interfaces = ints;
} else {
interfaces = Query.empty();
}
classInfo.signature = null;
}
if (classInfo.annotations == null) {
this.annotations = Collections.emptyList();
} else {
this.annotations = buildAnnotationValues(classInfo.annotations);
}
}
public TypeInfo addGenericArgument(String name) {
checkCreated();
var type = new GenericParameterType(this.Library, name, null);
genericArguments.add(type);
return type;
}
IType ConvertTypeAndNullable(BuiltIns.FormalParamDesc t)
{
IType result;
switch (t.Type)
{
case Constants.TYPE.Float: result = this.FloatType; break;
case Constants.TYPE.Integer: result = this.IntegerType; break;
case Constants.TYPE.Bool: result = this.BoolType; break;
case Constants.TYPE.Mixture: result = this.MixtureType; break;
case Constants.TYPE.Plex: result = this.PlexType; break;
case Constants.TYPE.Strand: result = this.StrandType; break;
case Constants.TYPE.Domain: result = this.DomainType; break;
case Constants.TYPE.Void: result = this.VoidType; break;
case Constants.TYPE.Object: result = this.ObjectType; break;
case Constants.TYPE.String: result = this.StringType; break;
case Constants.TYPE.Melt: result = this.MeltType; break;
case Constants.TYPE.SeqDesignObject: result = this.SeqDesignType; break;
case Constants.TYPE.GenericType0: result = new GenericParameterType(0); break;
case Constants.TYPE.List: result = new ListTypeSymbol(this); break;
case Constants.TYPE.ListOfString: result = new ListTypeSymbol(this, this.StringType); break;
default:
throw new InternalErrorException("missing type in TypeFromEnum");
}
//
return result;
}
public static GenericParameterSignature FromReader(MetadataHeader header, IBinaryStreamReader reader, GenericParameterType parameterType)
{
long position = reader.Position;
uint index;
if (!reader.TryReadCompressedUInt32(out index))
return null;
return new GenericParameterSignature(parameterType, (int) index)
{
StartOffset = position
};
}
public GenericParameterSignature(GenericParameterType parameterType, int index)
{
ParameterType = parameterType;
Index = index;
}
