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 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); } }
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); }