private void Add(string key, IGenericInstance value)
{
GenericInstanceHolder holder;
if (this._context.TryGetValue(key, out holder))
{
MemberReference reference = value as MemberReference;
if (reference == null)
{
throw new NotSupportedException();
}
MemberReference genericInstance = (MemberReference) holder.GenericInstance;
if (genericInstance.FullName != reference.FullName)
{
throw new ArgumentException("Duplicate key!", "key");
}
holder.Count++;
}
else
{
GenericInstanceHolder holder2 = new GenericInstanceHolder {
Count = 1,
GenericInstance = value
};
this._context.Add(key, holder2);
}
}
private static TypeReference ResolveIfNeeded(IGenericInstance genericInstanceMethod, IGenericInstance declaringGenericInstanceType, TypeReference parameterType)
{
ByReferenceType byReferenceType = parameterType as ByReferenceType;
if (byReferenceType != null)
{
return ResolveIfNeeded(genericInstanceMethod, declaringGenericInstanceType, byReferenceType);
}
ArrayType arrayType = parameterType as ArrayType;
if (arrayType != null)
{
return ResolveIfNeeded(genericInstanceMethod, declaringGenericInstanceType, arrayType);
}
GenericInstanceType type3 = parameterType as GenericInstanceType;
if (type3 != null)
{
return ResolveIfNeeded(genericInstanceMethod, declaringGenericInstanceType, type3);
}
GenericParameter genericParameterElement = parameterType as GenericParameter;
if (genericParameterElement != null)
{
return ResolveIfNeeded(genericInstanceMethod, declaringGenericInstanceType, genericParameterElement);
}
RequiredModifierType typeReference = parameterType as RequiredModifierType;
if ((typeReference != null) && Extensions.ContainsGenericParameters(typeReference))
{
return ResolveIfNeeded(genericInstanceMethod, declaringGenericInstanceType, typeReference.ElementType);
}
if (Extensions.ContainsGenericParameters(parameterType))
{
throw new Exception("Unexpected generic parameter.");
}
return parameterType;
}
private static void GenericInstanceFriendlyFullName(this IGenericInstance self, ILanguage language, StringBuilder builder, bool useGenericName, string leftBracket, string rightBracket)
{
dummyVar0 = builder.Append(leftBracket);
V_0 = self.get_GenericArguments();
V_1 = 0;
while (V_1 < V_0.get_Count())
{
V_2 = V_0.get_Item(V_1);
if (self.get_PostionToArgument().ContainsKey(V_1))
{
V_2 = self.get_PostionToArgument().get_Item(V_1);
}
if (V_1 > 0)
{
dummyVar1 = builder.Append(",");
}
V_3 = V_2.GetFriendlyFullName(language);
if (useGenericName)
{
V_4 = V_2.Resolve();
if (V_4 != null)
{
V_3 = V_4.GetGenericFullName(language);
}
}
dummyVar2 = builder.Append(V_3);
V_1 = V_1 + 1;
}
dummyVar3 = builder.Append(rightBracket);
return;
}
/* AGPL */
private static void GenericInstanceFriendlyFullName(this IGenericInstance self, ILanguage language, StringBuilder builder, bool useGenericName, string leftBracket, string rightBracket, bool includeNamespace = true)
/* End AGPL */
{
builder.Append(leftBracket);
var arguments = self.GenericArguments;
for (int i = 0; i < arguments.Count; i++)
{
TypeReference currentArgument = arguments[i];
if (self.PostionToArgument.ContainsKey(i))
{
currentArgument = self.PostionToArgument[i];
}
if (i > 0)
{
builder.Append(",");
}
/* AGPL */
var fullName = currentArgument.GetFriendlyFullName(language, includeNamespace);
/* End AGPL */
if (useGenericName)
{
var typeDefinition = currentArgument.Resolve();
if (typeDefinition != null)
{
fullName = typeDefinition.GetGenericFullName(language);
}
}
builder.Append(fullName);
}
builder.Append(rightBracket);
}
public static bool HasAnonymousArgument(this IGenericInstance self)
{
//for (int i = 0; i < self.GenericArguments.Count; i++)
//{
// TypeReference argument = self.GenericArguments[i];
// if (self.PostionToArgument.ContainsKey(i))
// {
// argument = self.PostionToArgument[i];
// }
// if (argument.ContainsAnonymousType())
// {
// return true;
// }
//}
foreach (TypeReference typeRef in self.GenericArguments)
{
if (typeRef.ContainsAnonymousType())
{
return(true);
}
}
foreach (TypeReference item in self.PostionToArgument.Values)
{
if (item.ContainsAnonymousType())
{
return(true);
}
}
return(false);
}
public static string GetTypeText(TypeReference tr)
{
StringBuilder sb = new StringBuilder();
if (tr.HasGenericParameters || tr is IGenericInstance)
{
int p = tr.Name.LastIndexOf("`");
if (p > 0)
{
sb.Append(tr.Name.Substring(0, p));
}
else
{
sb.Append(tr.Name);
}
if (tr.HasGenericParameters)
{
GetGenericParametersText(sb, tr.GenericParameters);
}
else
{
IGenericInstance gi = (IGenericInstance)tr;
if (gi.HasGenericArguments)
{
GetGenericArgumentsText(sb, gi.GenericArguments);
}
}
}
else
{
sb.Append(tr.Name);
}
return(sb.ToString());
}
private void Add(string key, IGenericInstance value)
{
GenericInstanceHolder genericInstanceHolder;
if (!this._context.TryGetValue(key, out genericInstanceHolder))
{
this._context.Add(key, new GenericInstanceHolder
{
Count = 1,
GenericInstance = value
});
return;
}
MemberReference memberReference = value as MemberReference;
if (memberReference == null)
{
throw new NotSupportedException();
}
MemberReference memberReference2 = (MemberReference)genericInstanceHolder.GenericInstance;
if (memberReference2.FullName != memberReference.FullName)
{
throw new ArgumentException("Duplicate key!", "key");
}
genericInstanceHolder.Count++;
}
/// <summary>
/// Updates references in a generic instance.
/// </summary>
/// <param name="genInst">The generic instance to process.</param>
/// <param name="memberMap">A dictionary mapping old to new references.</param>
private static void UpdateGenericInstance(this IGenericInstance genInst, Dictionary <IMemberDefinition, IMemberDefinition> memberMap)
{
if (genInst != null)
{
for (int i = 0; i < genInst.GenericArguments.Count; i++)
{
var arg = genInst.GenericArguments[i];
if (arg is IGenericInstance)
{
UpdateGenericInstance(arg as IGenericInstance, memberMap);
}
else
{
var argDef = arg.Resolve();
if (argDef != null)
{
IMemberDefinition newArg;
if (memberMap.TryGetValue(argDef, out newArg))
{
genInst.GenericArguments[i] = (TypeReference)newArg;
}
}
}
}
}
}
private void DispatchGenericArguments(IGenericInstance genericInstance, string referencingEntityName)
{
foreach (var argument in genericInstance.GenericArguments)
{
Visit(argument, referencingEntityName);
}
}
private void Add(string key, IGenericInstance value)
{
GenericInstanceHolder oldValue;
if (_context.TryGetValue(key, out oldValue))
{
var memberReference = value as MemberReference;
if (memberReference == null)
{
throw new NotSupportedException();
}
var storedValue = (MemberReference)oldValue.GenericInstance;
if (storedValue.FullName != memberReference.FullName)
{
throw new ArgumentException("Duplicate key!", "key");
}
oldValue.Count++;
return;
}
_context.Add(key, new GenericInstanceHolder {
Count = 1, GenericInstance = value
});
}
private void Add(string key, IGenericInstance value)
{
GenericInstanceHolder holder;
if (this._context.TryGetValue(key, out holder))
{
MemberReference reference = value as MemberReference;
if (reference == null)
{
throw new NotSupportedException();
}
MemberReference genericInstance = (MemberReference)holder.GenericInstance;
if (genericInstance.FullName != reference.FullName)
{
throw new ArgumentException("Duplicate key!", "key");
}
holder.Count++;
}
else
{
GenericInstanceHolder holder2 = new GenericInstanceHolder {
Count = 1,
GenericInstance = value
};
this._context.Add(key, holder2);
}
}
private void Remove(string key, IGenericInstance value)
{
GenericInstanceHolder oldValue;
if (_context.TryGetValue(key, out oldValue))
{
var memberReference = value as MemberReference;
if (memberReference == null)
{
throw new NotSupportedException();
}
var storedValue = (MemberReference)oldValue.GenericInstance;
if (storedValue.FullName != memberReference.FullName)
{
throw new ArgumentException("Invalid value!", "value");
}
oldValue.Count--;
if (oldValue.Count == 0)
{
_context.Remove(key);
}
return;
}
throw new ArgumentException("Invalid key!", "key");
}
List <MethodReference> getMethods(TypeDefinition declaringType, BabelMethodreference babelMethodRef)
{
var methods = new List <MethodReference>();
var git = babelMethodRef.DeclaringType as GenericInstanceType;
IGenericInstance gim = babelMethodRef.IsGenericMethod ? babelMethodRef : null;
foreach (var method in declaringType.Methods)
{
if (compareMethod(MethodReferenceInstance.make(method, git, gim), babelMethodRef))
{
if (!babelMethodRef.IsGenericMethod)
{
methods.Add(memberReferenceConverter.convert(method));
}
else
{
var gim2 = new GenericInstanceMethod(memberReferenceConverter.convert(method));
foreach (var arg in babelMethodRef.GenericArguments)
{
gim2.GenericArguments.Add(arg);
}
methods.Add(gim2);
}
}
}
return(methods);
}
private void Remove(string key, IGenericInstance value)
{
GenericInstanceHolder genericInstanceHolder;
if (!this._context.TryGetValue(key, out genericInstanceHolder))
{
throw new ArgumentException("Invalid key!", "key");
}
MemberReference memberReference = value as MemberReference;
if (memberReference == null)
{
throw new NotSupportedException();
}
MemberReference memberReference2 = (MemberReference)genericInstanceHolder.GenericInstance;
if (memberReference2.FullName != memberReference.FullName)
{
throw new ArgumentException("Invalid value!", "value");
}
genericInstanceHolder.Count--;
if (genericInstanceHolder.Count == 0)
{
this._context.Remove(key);
}
}
void MarkGenericArguments(IGenericInstance instance)
{
foreach (TypeReference argument in instance.GenericArguments)
{
MarkType(argument);
}
MarkGenericArgumentConstructors(instance);
}
/// <summary>
/// Mark all eachable items in argument as such.
/// </summary>
private static void Walk(ReachableContext context, IGenericInstance instance)
{
if (instance.HasGenericArguments)
{
foreach (TypeReference typeRef in instance.GenericArguments)
{
typeRef.MarkReachable(context);
}
}
}
private void AssertGenericArgumentsAreIdentical(IGenericInstance expected, IGenericInstance actual)
{
Assert.Equal(expected.HasGenericArguments, actual.HasGenericArguments);
for (var i = 0; i < expected.GenericArguments.Count; i += 1)
{
var aa = expected.GenericArguments[i];
var ba = actual.GenericArguments[i];
Assert.Equal(aa.Name, ba.Name);
}
}
private void AssertGenericArgumentsAreIdentical(IGenericInstance expected, IGenericInstance actual)
{
Assert.Equal(expected.HasGenericArguments, actual.HasGenericArguments);
for (var i = 0; i < expected.GenericArguments.Count; i += 1)
{
var aa = expected.GenericArguments[i];
var ba = actual.GenericArguments[i];
Assert.Equal(aa.Name, ba.Name);
}
}
private bool IsGenericInstanceArgumentsReferenceBroker(IGenericInstance genericInstance)
{
if (genericInstance != null)
{
return(genericInstance.GenericArguments.Any(a => a.BelongsToAssembly(BrokerKeyToken) ||
IsGenericInstanceArgumentsReferenceBroker(a as IGenericInstance)));
}
return(false);
}
public static bool ContainsGenericParameter (IGenericInstance self)
{
var arguments = self.GenericArguments;
for (int i = 0; i < arguments.Count; i++)
if (arguments [i].ContainsGenericParameter)
return true;
return false;
}
static TypeReference ResolveGenericParameter(TypeReference type, IGenericInstance parent)
{
if (!type.ContainsGenericParameter)
{
return(type);
}
if (type.IsArray)
{
Debug.Assert(false);
return(null);
}
if (type.IsByReference)
{
return(new PointerType(ResolveGenericParameter(type.GetElementType(), parent)));
}
if (type.IsPointer)
{
return(new PointerType(ResolveGenericParameter(type.GetElementType(), parent)));
}
if (type.IsGenericParameter)
{
return(parent.GenericArguments[(type as GenericParameter).Position]);
}
if (type is GenericInstanceType inst)
{
GenericInstanceType nt = new GenericInstanceType(inst.ElementType);
for (var i = 0; i < inst.GenericArguments.Count; i++)
{
if (inst.GenericArguments[i].IsGenericParameter)
{
var param = inst.GenericArguments[i] as GenericParameter;
nt.GenericArguments.Add(parent.GenericArguments[param.Position]);
}
else
{
nt.GenericArguments.Add(inst.GenericArguments[i]);
}
}
return(nt);
}
if (!type.HasGenericParameters)
{
return(type);
}
Debug.Assert(false);
return(null);
}
public void WriteGenericInstanceSignature(IGenericInstance instance)
{
Collection <TypeReference> genericArguments = instance.GenericArguments;
int count = genericArguments.Count;
base.WriteCompressedUInt32((uint)count);
for (int i = 0; i < count; i++)
{
this.WriteTypeSignature(genericArguments[i]);
}
}
private void AddUsedTypesFromGenericArgs(IGenericInstance git, List <UsedClass> usedT)
{
if (git == null)
{
return;
}
foreach (TypeReference tref in git.GenericArguments)
{
AddTypeToList(tref, ClassUse.Parameter, usedT);
}
}
public static void GenericInstanceFullName (IGenericInstance self, StringBuilder builder)
{
builder.Append ("<");
var arguments = self.GenericArguments;
for (int i = 0; i < arguments.Count; i++) {
if (i > 0)
builder.Append (",");
builder.Append (arguments [i].FullName);
}
builder.Append (">");
}
static void AddFromGenericInstance(HashSet <TypeDefinition> set, IGenericInstance instance)
{
if (!instance.HasGenericArguments)
{
return;
}
foreach (var genericArgument in instance.GenericArguments)
{
AddIfResolved(set, genericArgument);
}
}
static bool FindGenericType (IGenericInstance git, string nameSpace, string name)
{
foreach (object o in git.GenericArguments) {
if (IsGenericParameter (o, nameSpace, name))
return true;
GenericInstanceType inner = (o as GenericInstanceType);
if ((inner != null) && (FindGenericType (inner, nameSpace, name)))
return true;
}
return false;
}
public static bool ContainsGenericParameter(this IGenericInstance self)
{
Collection <TypeReference> genericArguments = self.GenericArguments;
for (int i = 0; i < genericArguments.Count; i++)
{
if (genericArguments[i].ContainsGenericParameter)
{
return(true);
}
}
return(false);
}
void ProcessImportMany(MethodDefinition method, Instruction instruction,
IGenericInstance methodReference)
{
InjectExportValueProvider();
InjectCompositionBatchHelper();
var searchPatternInstruction = SearchPatternInstruction(instruction.Previous);
instruction.Operand = InjectRetriever(methodReference.GenericArguments[0],
((searchPatternInstruction.Operand as string) ??
string.Empty).Split(new[] {'|'}, StringSplitOptions.RemoveEmptyEntries));
method.Body.GetILProcessor().Remove(searchPatternInstruction);
}
public static bool IsEqual(TypeReference tr1, TypeReference tr2)
{
if (tr1 == null && tr2 == null)
{
return(true);
}
if ((tr1 == null && tr2 != null) || (tr1 != null && tr2 == null))
{
return(false);
}
string trName1 = InsUtils.GetOldMemberName(tr1);
string trName2 = InsUtils.GetOldMemberName(tr2);
if (trName1 != trName2 || tr1.Namespace != tr2.Namespace)
{
return(false);
}
if (tr1 is IGenericInstance)
{
IGenericInstance gi1 = tr1 as IGenericInstance;
IGenericInstance gi2 = tr2 as IGenericInstance;
if (gi2 == null)
{
return(false);
}
if (gi1.GenericArguments.Count != gi2.GenericArguments.Count)
{
return(false);
}
for (int i = 0; i < gi1.GenericArguments.Count; i++)
{
if (!IsEqual(gi1.GenericArguments[i], gi2.GenericArguments[i]))
{
return(false);
}
}
}
if (tr1.DeclaringType == null && tr2.DeclaringType == null)
{
return(true);
}
if ((tr1.DeclaringType == null && tr2.DeclaringType != null) ||
(tr1.DeclaringType != null && tr2.DeclaringType == null))
{
return(false);
}
return(IsEqual(tr1.DeclaringType, tr2.DeclaringType));
}
public static bool ContainsGenericParameter(this IGenericInstance self)
{
var arguments = self.GenericArguments;
for (int i = 0; i < arguments.Count; i++)
{
if (arguments [i].ContainsGenericParameter)
{
return(true);
}
}
return(false);
}
static TypeReference ResolveIfNeeded(IGenericInstance genericInstanceMethod, IGenericInstance declaringGenericInstanceType, TypeReference parameterType)
{
if (parameterType is ByReferenceType byRefType)
{
return(ResolveIfNeeded(genericInstanceMethod, declaringGenericInstanceType, byRefType));
}
if (parameterType is ArrayType arrayType)
{
return(ResolveIfNeeded(genericInstanceMethod, declaringGenericInstanceType, arrayType));
}
if (parameterType is GenericInstanceType genericInstanceType)
{
return(ResolveIfNeeded(genericInstanceMethod, declaringGenericInstanceType, genericInstanceType));
}
if (parameterType is GenericParameter genericParameter)
{
return(ResolveIfNeeded(genericInstanceMethod, declaringGenericInstanceType, genericParameter));
}
if (parameterType is PointerType pointerType)
{
return(ResolveIfNeeded(genericInstanceMethod, declaringGenericInstanceType, pointerType));
}
if (parameterType is RequiredModifierType requiredModifierType && requiredModifierType.ContainsGenericParameters())
{
return(ResolveIfNeeded(genericInstanceMethod, declaringGenericInstanceType, requiredModifierType));
}
if (parameterType is OptionalModifierType optionalModifierType && optionalModifierType.ContainsGenericParameters())
{
return(ResolveIfNeeded(genericInstanceMethod, declaringGenericInstanceType, optionalModifierType.ElementType));
}
if (parameterType is PinnedType pinnedType)
{
return(ResolveIfNeeded(genericInstanceMethod, declaringGenericInstanceType, pinnedType.ElementType));
}
if (parameterType.ContainsGenericParameters())
{
throw new Exception("Unexpected generic parameter.");
}
return(parameterType);
}
private static GenericInstanceType ResolveIfNeeded(IGenericInstance genericInstanceMethod, IGenericInstance genericInstanceType, GenericInstanceType genericInstanceType1)
{
if (!ContainsGenericParameters(genericInstanceType1))
{
return(genericInstanceType1);
}
GenericInstanceType newGenericInstance = new GenericInstanceType(genericInstanceType1.ElementType);
foreach (TypeReference genericArgument in genericInstanceType1.GenericArguments)
{
if (!genericArgument.IsGenericParameter)
{
newGenericInstance.GenericArguments.Add(ResolveIfNeeded(genericInstanceMethod, genericInstanceType, genericArgument));
continue;
}
GenericParameter genParam = (GenericParameter)genericArgument;
switch (genParam.Type)
{
case GenericParameterType.Type:
{
if (genericInstanceType == null)
{
throw new NotSupportedException();
}
newGenericInstance.GenericArguments.Add(genericInstanceType.GenericArguments[genParam.Position]);
}
break;
case GenericParameterType.Method:
{
if (genericInstanceMethod == null)
{
newGenericInstance.GenericArguments.Add(genParam);
}
else
{
newGenericInstance.GenericArguments.Add(genericInstanceMethod.GenericArguments[genParam.Position]);
}
}
break;
}
}
return(newGenericInstance);
}
public static void GenericInstanceFullName(this IGenericInstance self, StringBuilder builder)
{
builder.Append("<");
var arguments = self.GenericArguments;
for (int i = 0; i < arguments.Count; i++)
{
if (i > 0)
{
builder.Append(",");
}
builder.Append(arguments [i].FullName);
}
builder.Append(">");
}
static void GenericInstanceFullName(this IGenericInstance genericInstance, StringBuilder builder)
{
builder.Append("<");
var genericArguments = genericInstance.GenericArguments;
for (var i = 0; i < genericArguments.Count; i++)
{
if (i > 0)
{
builder.Append(",");
}
builder.Append(GetNormalizedName(genericArguments[i]));
}
builder.Append(">");
}
public static void GenericInstanceFullName(this IGenericInstance self, StringBuilder builder)
{
builder.Append("<");
Collection <TypeReference> genericArguments = self.GenericArguments;
for (int i = 0; i < genericArguments.Count; i++)
{
if (i > 0)
{
builder.Append(",");
}
builder.Append(genericArguments[i].FullName);
}
builder.Append(">");
}
public void ReadGenericInstanceSignature(IGenericParameterProvider provider, IGenericInstance instance)
{
uint num = base.ReadCompressedUInt32();
if (!provider.IsDefinition)
{
SignatureReader.CheckGenericContext(provider, (int)(num - 1));
}
Collection <TypeReference> genericArguments = instance.GenericArguments;
for (int i = 0; (long)i < (ulong)num; i++)
{
genericArguments.Add(this.ReadTypeSignature());
}
}
/*Telerik Authorship*/
public static void GenericInstanceFullName(this IGenericInstance self, StringBuilder builder, string leftBracket, string rightBracket, System.Func <TypeReference, string> getTypeGenericName)
{
builder.Append(leftBracket);
var arguments = self.GenericArguments;
for (int i = 0; i < arguments.Count; i++)
{
if (i > 0)
{
builder.Append(",");
}
builder.Append(getTypeGenericName(arguments[i]));
}
builder.Append(rightBracket);
}
private static GenericInstanceType ResolveIfNeeded(IGenericInstance genericInstanceMethod, IGenericInstance genericInstanceType, GenericInstanceType genericInstanceType1)
{
if (!Extensions.ContainsGenericParameters(genericInstanceType1))
{
return genericInstanceType1;
}
GenericInstanceType type2 = new GenericInstanceType(genericInstanceType1.ElementType);
foreach (TypeReference reference in genericInstanceType1.GenericArguments)
{
if (!reference.IsGenericParameter)
{
type2.GenericArguments.Add(ResolveIfNeeded(genericInstanceMethod, genericInstanceType, reference));
}
else
{
GenericParameter item = (GenericParameter) reference;
switch (item.Type)
{
case GenericParameterType.Type:
if (genericInstanceType == null)
{
throw new NotSupportedException();
}
type2.GenericArguments.Add(genericInstanceType.GenericArguments[item.Position]);
break;
case GenericParameterType.Method:
if (genericInstanceMethod == null)
{
type2.GenericArguments.Add(item);
}
else
{
type2.GenericArguments.Add(genericInstanceMethod.GenericArguments[item.Position]);
}
break;
}
}
}
return type2;
}
public TypeResolver(IGenericInstance typeDefinitionContext, IGenericInstance methodDefinitionContext)
{
this._context = new Dictionary<string, GenericInstanceHolder>();
this._typeDefinitionContext = typeDefinitionContext;
this._methodDefinitionContext = methodDefinitionContext;
}
public GenericArgumentCollection (IGenericInstance container)
{
m_container = container;
}
void RecordGenericArguments(IGenericInstance instance)
{
foreach (TypeReference argument in instance.GenericArguments)
RecordType (argument);
RecordGenericArgumentConstructors (instance);
}
private static TypeReference ResolveIfNeeded(IGenericInstance genericInstanceMethod, IGenericInstance declaringGenericInstanceType, TypeReference parameterType)
{
var byRefType = parameterType as ByReferenceType;
if (byRefType != null)
return ResolveIfNeeded (genericInstanceMethod, declaringGenericInstanceType, byRefType);
var arrayType = parameterType as ArrayType;
if (arrayType != null)
return ResolveIfNeeded (genericInstanceMethod, declaringGenericInstanceType, arrayType);
var genericInstanceType = parameterType as GenericInstanceType;
if (genericInstanceType != null)
return ResolveIfNeeded (genericInstanceMethod, declaringGenericInstanceType, genericInstanceType);
var genericParameter = parameterType as GenericParameter;
if (genericParameter != null)
return ResolveIfNeeded (genericInstanceMethod, declaringGenericInstanceType, genericParameter);
var requiredModifierType = parameterType as RequiredModifierType;
if (requiredModifierType != null && ContainsGenericParameters (requiredModifierType))
return ResolveIfNeeded (genericInstanceMethod, declaringGenericInstanceType, requiredModifierType.ElementType);
if (ContainsGenericParameters (parameterType))
throw new Exception ("Unexpected generic parameter.");
return parameterType;
}
public GenericArgumentCollection(IGenericInstance container)
{
m_container = container;
m_items = new ArrayList ();
}
private static ByReferenceType ResolveIfNeeded(IGenericInstance genericInstanceMethod, IGenericInstance genericInstanceType, ByReferenceType byReferenceType)
{
return new ByReferenceType(ResolveIfNeeded(genericInstanceMethod, genericInstanceType, byReferenceType.ElementType));
}
IGenericParameterProvider GetGenericProviderFromInstance (IGenericInstance instance)
{
var method = instance as GenericInstanceMethod;
if (method != null)
return ResolveMethodDefinition (method.ElementMethod);
var type = instance as GenericInstanceType;
if (type != null)
return ResolveTypeDefinition (type.ElementType);
return null;
}
void MarkGenericArguments (IGenericInstance instance)
{
foreach (TypeReference argument in instance.GenericArguments)
MarkType (argument);
MarkGenericArgumentConstructors (instance);
}
public GenericParametersMap(IGenericParameterProvider source, IGenericInstance target)
{
if (source == null) throw new ArgumentNullException("source");
_source = source;
if (target == null) return;
if (!target.HasGenericArguments) return;
if (source.GenericParameters.Count != target.GenericArguments.Count) throw new ArgumentException();
int position = 0;
foreach (TypeReference argument in target.GenericArguments) {
var parameter = source.GenericParameters[position];
_map.Add(parameter.Name, argument);
++position;
}
}
private void ResolveGenericParametersAsArguments(IGenericParameterProvider source, IGenericInstance target)
{
if (source.HasGenericParameters) {
foreach (GenericParameter parameter in source.GenericParameters) {
target.GenericArguments.Add(parameter);
}
}
}
private void WriteGenericInstanceTypeArguments(IGenericInstance genericInstance, bool renameInvalidMembers)
{
WriteToken(GenericLeftBracket);
for (int i = 0; i < genericInstance.GenericArguments.Count; i++)
{
if (i > 0)
{
WriteToken(",");
WriteSpace();
}
TypeReference genericArg = genericInstance.GenericArguments[i];
if (genericInstance.PostionToArgument.ContainsKey(i))
{
genericArg = genericInstance.PostionToArgument[i];
}
WriteTypeReferenceNavigationName(genericArg, renameInvalidMembers);
}
WriteToken(GenericRightBracket);
}
IGenericParameterProvider GetGenericProviderFromInstance (IGenericInstance instance)
{
var method = instance as GenericInstanceMethod;
if (method != null)
return method.ElementMethod;
var type = instance as GenericInstanceType;
if (type != null)
return type.ElementType;
return null;
}
private void Remove(string key, IGenericInstance value)
{
GenericInstanceHolder holder;
if (!this._context.TryGetValue(key, out holder))
{
throw new ArgumentException("Invalid key!", "key");
}
MemberReference reference = value as MemberReference;
if (reference == null)
{
throw new NotSupportedException();
}
MemberReference genericInstance = (MemberReference) holder.GenericInstance;
if (genericInstance.FullName != reference.FullName)
{
throw new ArgumentException("Invalid value!", "value");
}
holder.Count--;
if (holder.Count == 0)
{
this._context.Remove(key);
}
}
private void AddUsedTypesFromGenericArgs(IGenericInstance git, List<UsedClass> usedT)
{
if (git == null) return;
foreach (TypeReference tref in git.GenericArguments)
{
AddTypeToList(tref, ClassUse.Parameter, usedT);
}
}
/// <summary>
/// Mark all eachable items in argument as such.
/// </summary>
private static void Walk(ReachableContext context, IGenericInstance instance)
{
if (instance.HasGenericArguments)
{
foreach (TypeReference typeRef in instance.GenericArguments)
{
typeRef.MarkReachable(context);
}
}
}
public TypeResolver(GenericInstanceMethod methodDefinitionContext)
{
_methodDefinitionContext = methodDefinitionContext;
}
public TypeResolver(GenericInstanceType typeDefinitionContext)
{
this._typeDefinitionContext = typeDefinitionContext;
}
private static TypeReference ResolveIfNeeded(IGenericInstance genericInstanceMethod, IGenericInstance genericInstanceType, GenericParameter genericParameterElement)
{
return ((genericParameterElement.MetadataType != MetadataType.MVar) ? genericInstanceType.GenericArguments[genericParameterElement.Position] : ((genericInstanceMethod == null) ? genericParameterElement : genericInstanceMethod.GenericArguments[genericParameterElement.Position]));
}
void MarkGenericArgumentConstructors (IGenericInstance instance)
{
var arguments = instance.GenericArguments;
var generic_element = GetGenericProviderFromInstance (instance);
if (generic_element == null)
return;
var parameters = generic_element.GenericParameters;
if (arguments.Count != parameters.Count)
return;
for (int i = 0; i < arguments.Count; i++) {
var argument = arguments [i];
var parameter = parameters [i];
if (!parameter.HasDefaultConstructorConstraint)
continue;
var argument_definition = ResolveTypeDefinition (argument);
if (argument_definition == null)
continue;
MarkMethodsIf (argument_definition.Methods, ctor => !ctor.IsStatic && !ctor.HasParameters);
}
}
public TypeResolver(GenericInstanceType typeDefinitionContext, GenericInstanceMethod methodDefinitionContext)
{
this._typeDefinitionContext = typeDefinitionContext;
this._methodDefinitionContext = methodDefinitionContext;
}
private static ArrayType ResolveIfNeeded(IGenericInstance genericInstanceMethod, IGenericInstance genericInstanceType, ArrayType arrayType)
{
return new ArrayType(ResolveIfNeeded(genericInstanceMethod, genericInstanceType, arrayType.ElementType), arrayType.Rank);
}
private void DispatchGenericArguments(IGenericInstance genericInstance, string referencingEntityName)
{
foreach (var argument in genericInstance.GenericArguments)
Visit(argument, referencingEntityName);
}
