private TypeReference Fix(TypeReference type, IGenericParameterProvider context) { if (type == null || type.IsDefinition) return type; if (type.IsGenericParameter) { var genPar = (GenericParameter)type; if (!fixedGenericParameters.Contains(genPar)) { fixedGenericParameters.Add(genPar); FixReferences(genPar.Constraints, context); FixReferences(genPar.CustomAttributes, context); } return type; } if (type is TypeSpecification) return Fix((TypeSpecification)type, context); var t2 = repack.GetMergedTypeFromTypeRef(type); if (t2 != null) return t2; if (type.IsNested) type.DeclaringType = Fix(type.DeclaringType, context); if (type.DeclaringType is TypeDefinition) return ((TypeDefinition)type.DeclaringType).NestedTypes.FirstOrDefault(x => x.FullName == type.FullName); return type; }
public void Push (IGenericParameterProvider provider) { if (stack == null) stack = new Collection<IGenericParameterProvider> (1) { provider }; else stack.Add (provider); }
internal void CheckProvider (IGenericParameterProvider provider, int count) { if (!AllowCreation) return; for (int i = provider.GenericParameters.Count; i < count; i++) provider.GenericParameters.Add (new GenericParameter (provider)); }
public static void CopyGenericParameters(IGenericParameterProvider source, IGenericParameterProvider target, ReferenceResolver resolver) { if (!source.HasGenericParameters) return; foreach (var parameter in source.GenericParameters) target.InjectGenericParameter(parameter, resolver); }
public static void ImportGenericParameters(IGenericParameterProvider imported, Type original) { var parameters = original.GetGenericTypeDefinition().GetGenericArguments(); var imported_parameters = imported.GenericParameters; for (int i = 0; i < parameters.Length; i++) imported_parameters.Add(new GenericParameter(parameters[i].Name, imported)); }
public static void ImportGenericParameters(IGenericParameterProvider imported, IGenericParameterProvider original) { var parameters = original.GenericParameters; var imported_parameters = imported.GenericParameters; for (int i = 0; i < parameters.Count; i++) imported_parameters.Add(new GenericParameter(parameters[i].Name, imported)); }
public TypeReference GetGenericParameter(GenericParameter genericParamter, IGenericParameterProvider[] paramProviders) { #if GENERIC IGenericParameterProvider context = GetContext(genericParamter, paramProviders); return context.GenericParameters[genericParamter.Position]; #else return type; #endif }
public static Collection<GenericParameter> GetGenericParameters( IGenericParameterProvider self, ref Collection<GenericParameter> collection, ModuleDefinition module) { return Mixin.HasImage(module) ? module.Read(ref collection, self, (provider, reader) => reader.ReadGenericParameters(provider)) : collection = new GenericParameterCollection(self); }
static void Process (IGenericParameterProvider provider) { if (!provider.HasGenericParameters) return; foreach (var parameter in provider.GenericParameters) Process (parameter); }
public GenericParameter(string name, IGenericParameterProvider owner) : base(string.Empty, name) { if (owner == null) throw new ArgumentNullException (); this.owner = owner; this.etype = owner.GenericParameterType == GenericParameterType.Type ? ElementType.Var : ElementType.MVar; }
public GenericContext(IGenericParameterProvider provider) { if (provider is TypeReference) m_type = provider as TypeReference; else if (provider is MethodReference) { MethodReference meth = provider as MethodReference; m_method = meth; m_type = meth.DeclaringType; } }
public static bool ContainsGenericParameter(IGenericParameterProvider provider, TypeReference parameter) { foreach (var param in provider.GenericParameters) { if (param.MetadataToken == parameter.MetadataToken) { return true; } } return false; }
private void AssertGenericParametersAreIdentical(IGenericParameterProvider expected, IGenericParameterProvider actual) { Assert.Equal(expected.HasGenericParameters, actual.HasGenericParameters); for (var i = 0; i < expected.GenericParameters.Count; i += 1) { var ap = expected.GenericParameters[i]; var bp = actual.GenericParameters[i]; Assert.Equal(ap.Name, bp.Name); Assert.Equal(ap.Position, bp.Position); } }
static TypeReference GenericTypeFor (IGenericParameterProvider context) { var type = context as TypeReference; if (type != null) return type.GetElementType (); var method = context as MethodReference; if (method != null) return method.DeclaringType.GetElementType (); throw new InvalidOperationException (); }
public void Process(IGenericParameterProvider provider) { if (!provider.HasGenericParameters) { return; } foreach (var parameter in provider.GenericParameters .Where(x => x.HasCustomAttributes)) { Process(parameter); } }
private FieldReference Fix(FieldReference field, IGenericParameterProvider context) { field.DeclaringType = Fix(field.DeclaringType, context); if (field.DeclaringType.IsDefinition && !field.IsDefinition) { FieldDefinition def = ((TypeDefinition)field.DeclaringType).Fields.First(x => x.Name == field.Name); if (def == null) throw new NullReferenceException("Field \"" + field + "\" not found in type \"" + field.DeclaringType + "\"."); return def; } field.FieldType = Fix(field.FieldType, context); return field; }
internal MethodReference Fix(MethodReference method, IGenericParameterProvider context) { TypeReference declaringType = Fix(method.DeclaringType, context); if (method.IsGenericInstance) { return Fix((GenericInstanceMethod)method, context); } // if declaring type is in our new merged module, return the definition if (declaringType.IsDefinition && !method.IsDefinition) { MethodDefinition def = new ReflectionHelper(repack).FindMethodDefinitionInType((TypeDefinition)declaringType, method); if (def != null) return def; } method.DeclaringType = declaringType; method.ReturnType = Fix(method.ReturnType, method); FixReferences(method.Parameters, method); FixReferences(method.GenericParameters, method); if (!method.IsDefinition && !method.DeclaringType.IsGenericInstance && !method.DeclaringType.IsArray && (method.ReturnType.IsDefinition || method.Parameters.Any(x => x.ParameterType.IsDefinition))) { var culprit = method.ReturnType.IsDefinition ? method.ReturnType : method.Parameters.First(x => x.ParameterType.IsDefinition).ParameterType; // warn about invalid merge assembly set, as this method is not gonna work fine (peverify would warn as well) repack.WARN("Method reference is used with definition return type / parameter. Indicates a likely invalid set of assemblies, consider one of the following"); repack.WARN(" - Remove the assembly defining " + culprit + " from the merge"); repack.WARN(" - Add assembly defining " + method + " to the merge"); // one case where it'll work correctly however (but doesn't seem common): // A references B // C references A // C is merged into B } return method; }
/// <summary> /// Returns the base-most MethodDefinition (for implicitly or explicitly overridden methods) in this assembly. /// (Meaning overridden methods in referenced assemblies do not count, therefore it returns a Definition, not a Reference.) /// </summary> public void FixOverridenMethodDef(MethodDefinition meth, IGenericParameterProvider context) { foreach (var ov in meth.Overrides) { MethodReference fixedOv = Fix(ov, context); if (fixedOv.IsDefinition) { if (fixedOv.Module == meth.Module) { // it's a Definition, and in our module MethodDefinition fixedOvDef = (MethodDefinition)fixedOv; if (fixedOvDef.IsVirtual) Fix((MethodDefinition) fixedOv, meth); } } } // no explicit overrides found, check implicit overrides MethodDefinition @base = MethodMatcher.MapVirtualMethod(meth); if (@base != null && @base.IsVirtual) Fix(@base, meth); }
private TypeReference Fix(TypeReference type, IGenericParameterProvider context) { if (type == null || type.IsDefinition) return type; if (type.IsGenericParameter) { var genPar = (GenericParameter)type; if (!fixedGenericParameters.Contains(genPar)) { fixedGenericParameters.Add(genPar); FixReferences(genPar.Constraints, context); FixReferences(genPar.CustomAttributes, context); } return type; } if (type is TypeSpecification) { return Fix((TypeSpecification)type, context); } if (type.IsNested) { type.DeclaringType = Fix(type.DeclaringType, context); // might need to do more if (type.DeclaringType is TypeDefinition) { return ((TypeDefinition)type.DeclaringType).NestedTypes.First(x => x.FullName == type.FullName); } } else { type = duplicateHandler.Rename(type); return FixImpl(type); } return type; }
public GenericResolutionWindow(IGenericParameterProvider generic, TypeDefinition context) { //Component initialization InitializeComponent(); originalGeneric = generic; //Sets icon and text var node = new ILEditTreeNode(generic, true); ImgIcon.Source = (ImageSource)node.Icon; LblName.Text = node.Text.ToString(); //Sets destination type LblDestinationType.Text = new ILEditTreeNode(context, true).Text.ToString(); //Populates the list LstParameters.ItemsSource = generic.GenericParameters .Select(p => { var row = new GenericParameterRowItem() { Name = p.Name, MemberFilter = Injection.MemberFilters.Types, DestinationModule = context.Module, EnclosingType = context }; row.HasSelectedParameter = false; row.Selected += Row_Selected; return row; }).ToArray(); }
public void RemoveGenericParameterRange(IGenericParameterProvider owner) { GenericParameters.Remove(owner.MetadataToken); }
internal GenericParameterCollection(IGenericParameterProvider owner, int capacity) : base(capacity) { this.owner = owner; }
/// <summary> /// Clones a collection of SecurityDeclarations /// </summary> public void CopySecurityDeclarations(Collection <SecurityDeclaration> input, Collection <SecurityDeclaration> output, IGenericParameterProvider context) { foreach (SecurityDeclaration sec in input) { SecurityDeclaration newSec = null; if (PermissionsetHelper.IsXmlPermissionSet(sec)) { newSec = PermissionsetHelper.Xml2PermissionSet(sec, _repackContext.TargetAssemblyMainModule); } if (newSec == null) { newSec = new SecurityDeclaration(sec.Action); foreach (SecurityAttribute sa in sec.SecurityAttributes) { SecurityAttribute newSa = new SecurityAttribute(Import(sa.AttributeType, context)); if (sa.HasFields) { foreach (CustomAttributeNamedArgument cana in sa.Fields) { newSa.Fields.Add(Copy(cana, context)); } } if (sa.HasProperties) { foreach (CustomAttributeNamedArgument cana in sa.Properties) { newSa.Properties.Add(Copy(cana, context)); } } newSec.SecurityAttributes.Add(newSa); } } output.Add(newSec); } }
public ImportGenericContext(IGenericParameterProvider provider) { stack = null; Push(provider); }
public void CopyCustomAttributes(Collection <CustomAttribute> input, Collection <CustomAttribute> output, bool allowMultiple, IGenericParameterProvider context) { var reflectionHelper = _repackContext.ReflectionHelper; foreach (CustomAttribute ca in input) { var caType = ca.AttributeType; var similarAttributes = output.Where(attr => reflectionHelper.AreSame(attr.AttributeType, caType)).ToList(); if (similarAttributes.Count != 0) { if (!allowMultiple) { continue; } if (!CustomAttributeTypeAllowsMultiple(caType)) { continue; } if (similarAttributes.Any(x => reflectionHelper.AreSame(x.ConstructorArguments, ca.ConstructorArguments) && reflectionHelper.AreSame(x.Fields, ca.Fields) && reflectionHelper.AreSame(x.Properties, ca.Properties) )) { continue; } } output.Add(Copy(ca, context)); } }
public ImportContext(IImporter importer, IGenericParameterProvider provider) { m_importer = importer; m_genContext = new GenericContext(provider); }
public FieldReference Import(FieldReference field, IGenericParameterProvider context) { return(ImportReference(field, context)); }
public virtual MethodReference ImportReference(MethodReference method, IGenericParameterProvider context) { Mixin.CheckMethod(method); return(ImportMethod(method, ImportGenericContext.For(context))); }
public static bool GetHasGenericParameters( this IGenericParameterProvider self, ModuleDefinition module) { return(module.HasImage() && module.Read(self, (provider, reader) => reader.HasGenericParameters(provider))); }
public virtual FieldReference ImportReference(FieldReference field, IGenericParameterProvider context) { Mixin.CheckField(field); return(ImportField(field, ImportGenericContext.For(context))); }
public virtual TypeReference ImportReference(TypeReference type, IGenericParameterProvider context) { Mixin.CheckType(type); return(ImportType(type, ImportGenericContext.For(context))); }
public CustomAttributeNamedArgument Copy(CustomAttributeNamedArgument namedArg, IGenericParameterProvider context) { return(new CustomAttributeNamedArgument(namedArg.Name, Copy(namedArg.Argument, context))); }
private GenericParameter FixPlatformVersion(GenericParameter gp, IGenericParameterProvider gpp) { GenericParameter ngp = new GenericParameter(gp.Name, gpp); ngp.Attributes = gp.Attributes; foreach (TypeReference tr in gp.Constraints) ngp.Constraints.Add(FixPlatformVersion(tr)); foreach (CustomAttribute ca in gp.CustomAttributes) ngp.CustomAttributes.Add(FixPlatformVersion(ca)); if (gp.DeclaringType != null ) ngp.DeclaringType = FixPlatformVersion(gp.DeclaringType); foreach (GenericParameter gp1 in gp.GenericParameters) ngp.GenericParameters.Add(FixPlatformVersion(gp1, ngp)); return ngp; }
public GenericParameter(IGenericParameterProvider owner) : this(string.Empty, owner) { }
public CustomAttributeArgument Copy(CustomAttributeArgument arg, IGenericParameterProvider context) { return(new CustomAttributeArgument(Import(arg.Type, context), ImportCustomAttributeValue(arg.Value, context))); }
bool AddMethodArgType(IGenericParameterProvider gpp, Parameter methodParam, ITypeDefOrRef type) { return(AddMethodArgType(gpp, methodParam, type.ToTypeSig())); }
public MethodReference Import(MethodReference method, IGenericParameterProvider context) { return(ImportReference(method, context)); }
protected virtual bool IsValidType(IGenericParameterProvider gpp, TypeSig type) { if (type == null) { return(false); } if (type.ElementType == ElementType.Void) { return(false); } while (type != null) { switch (type.ElementType) { case ElementType.GenericInst: foreach (var ga in ((GenericInstSig)type).GenericArguments) { if (!IsValidType(gpp, ga)) { return(false); } } break; case ElementType.SZArray: case ElementType.Array: case ElementType.Ptr: case ElementType.Class: case ElementType.ValueType: case ElementType.Void: case ElementType.Boolean: case ElementType.Char: case ElementType.I1: case ElementType.U1: case ElementType.I2: case ElementType.U2: case ElementType.I4: case ElementType.U4: case ElementType.I8: case ElementType.U8: case ElementType.R4: case ElementType.R8: case ElementType.TypedByRef: case ElementType.I: case ElementType.U: case ElementType.String: case ElementType.Object: break; case ElementType.Var: case ElementType.MVar: // TODO: Return false for now. We don't know whether the Var is a Var in // this type or from some other type. return(false); case ElementType.ByRef: case ElementType.FnPtr: case ElementType.CModOpt: case ElementType.CModReqd: case ElementType.Pinned: case ElementType.Sentinel: case ElementType.ValueArray: case ElementType.R: case ElementType.End: case ElementType.Internal: case ElementType.Module: default: return(false); } if (type.Next == null) { break; } type = type.Next; } return(type != null); }
public TypeReference Import(Type type, IGenericParameterProvider context) { return(ImportReference(type, context)); }
//--- Constructors --- public ParameterBuilder(IGenericParameterProvider genericParameterProvider, Func<Type, ReflectedTypeInfo> getType) { _genericParameterProvider = genericParameterProvider; _getType = getType; }
public void CopyCustomAttributes(Collection <CustomAttribute> input, Collection <CustomAttribute> output, IGenericParameterProvider context) { CopyCustomAttributes(input, output, true, context); }
public static void OutputGenericParameters (XmlDocument document, XmlNode nclass, IGenericParameterProvider provider) { if (provider.GenericParameters.Count == 0) return; var gparameters = provider.GenericParameters; XmlElement ngeneric = document.CreateElement (string.Format ("generic-parameters")); nclass.AppendChild (ngeneric); foreach (GenericParameter gp in gparameters) { XmlElement nparam = document.CreateElement (string.Format ("generic-parameter")); nparam.SetAttribute ("name", gp.Name); nparam.SetAttribute ("attributes", ((int) gp.Attributes).ToString ()); AttributeData.OutputAttributes (document, nparam, gp.CustomAttributes); ngeneric.AppendChild (nparam); var constraints = gp.Constraints; if (constraints.Count == 0) continue; XmlElement nconstraint = document.CreateElement ("generic-parameter-constraints"); foreach (TypeReference constraint in constraints) { XmlElement ncons = document.CreateElement ("generic-parameter-constraint"); ncons.SetAttribute ("name", Utils.CleanupTypeName (constraint)); nconstraint.AppendChild (ncons); } nparam.AppendChild (nconstraint); } }
public void CopyGenericParameters(Collection <GenericParameter> input, Collection <GenericParameter> output, IGenericParameterProvider nt) { foreach (GenericParameter gp in input) { GenericParameter ngp = new GenericParameter(gp.Name, nt); ngp.Attributes = gp.Attributes; output.Add(ngp); } // delay copy to ensure all generics parameters are already present Copy(input, output, (gp, ngp) => CopyTypeReferences(gp.Constraints, ngp.Constraints, nt)); Copy(input, output, (gp, ngp) => CopyCustomAttributes(gp.CustomAttributes, ngp.CustomAttributes, nt)); }
/// <summary> /// Format the generic parameters of given provider. /// </summary> private static string GetGenericParameters(IGenericParameterProvider provider) { if (!provider.HasGenericParameters) return string.Empty; return "<" + string.Join(", ", provider.GenericParameters.Select(x => x.Name)) + ">"; }
public FieldReference Import(FieldReference reference, IGenericParameterProvider context) { _repackContext.PlatformFixer.FixPlatformVersion(reference); return(_repackContext.TargetAssemblyMainModule.ImportReference(reference, context)); }
internal GenericParameter(int pos, IGenericParameterProvider owner) : base(string.Empty, string.Empty) { m_position = pos; m_owner = owner; }
internal GenericParameterCollection(IGenericParameterProvider owner) { this.owner = owner; }
public bool TryGetGenericParameterRanges(IGenericParameterProvider owner, out Range [] ranges) { return(GenericParameters.TryGetValue(owner.MetadataToken, out ranges)); }
public ImportGenericContext(IGenericParameterProvider provider) { stack = null; Push (provider); }
private GenericParameter CreateGenericParameter(Il2CppGenericParameter param, IGenericParameterProvider iGenericParameterProvider) { if (!genericParameterDic.TryGetValue(param, out var genericParameter)) { var genericName = metadata.GetStringFromIndex(param.nameIndex); genericParameter = new GenericParameter(genericName, iGenericParameterProvider); genericParameter.Attributes = (GenericParameterAttributes)param.flags; genericParameterDic.Add(param, genericParameter); for (int i = 0; i < param.constraintsCount; ++i) { var il2CppType = il2Cpp.types[metadata.constraintIndices[param.constraintsStart + i]]; genericParameter.Constraints.Add(new GenericParameterConstraint(GetTypeReference((MemberReference)iGenericParameterProvider, il2CppType))); } } return(genericParameter); }
static void ImportGenericParameters (IGenericParameterProvider provider, Type [] arguments) { var provider_parameters = provider.GenericParameters; for (int i = 0; i < arguments.Length; i++) provider_parameters.Add (new GenericParameter (arguments [i].Name, provider)); }
public void CopyTypeReferences(Collection <TypeReference> input, Collection <TypeReference> output, IGenericParameterProvider context) { foreach (TypeReference ta in input) { output.Add(Import(ta, context)); } }
private void WriteGenericParametersToDefinition(IGenericParameterProvider genericDefinition, Action<GenericParameter> writeParamConstraints, bool renameInvalidCharacters) { int i = 0; if (genericDefinition is TypeDefinition) { TypeDefinition nestedType = genericDefinition as TypeDefinition; TypeDefinition parentType = nestedType.DeclaringType; if (parentType != null && parentType.HasGenericParameters) { i = parentType.GenericParameters.Count; } } if (i < genericDefinition.GenericParameters.Count) { WriteToken(GenericLeftBracket); for (; i < genericDefinition.GenericParameters.Count; i++) { GenericParameter currentParameter = genericDefinition.GenericParameters[i]; if (currentParameter.IsCovariant) { WriteKeyword(KeyWordWriter.Covariant); WriteSpace(); } if (currentParameter.IsContravariant) { WriteKeyword(KeyWordWriter.Contravariant); WriteSpace(); } WriteReference(renameInvalidCharacters ? GenericHelper.ReplaceInvalidCharactersName(Language, currentParameter.Name) : currentParameter.Name, null); if (currentParameter.HasConstraints || currentParameter.HasDefaultConstructorConstraint || currentParameter.HasReferenceTypeConstraint || currentParameter.HasNotNullableValueTypeConstraint) { if (writeParamConstraints != null) { writeParamConstraints(currentParameter); } //WriteGenericParameterConstraints(currentParameter); } if (i != genericDefinition.GenericParameters.Count - 1) { WriteToken(","); WriteSpace(); } } WriteToken(GenericRightBracket); } }
public void CopyTypeReferences(GenericParameter genericParameter, GenericParameter nonGenericParameter, IGenericParameterProvider provider) { ICollection <TypeReference> genericParametersCollection = genericParameter.Constraints .Select(item => item.ConstraintType) .ToList(); ICollection <TypeReference> nonGenericParametersCollection = nonGenericParameter.Constraints .Select(item => item.ConstraintType) .ToList(); CopyTypeReferences( new Collection <TypeReference>(genericParametersCollection), new Collection <TypeReference>(nonGenericParametersCollection), provider); }
internal static IGenericInstanceForm GetForm(IGenericParameterProvider provider, IGenericParameterProvider context) { if (provider == null) { return(null); } if (!provider.HasGenericParameters) { return(null); } if (provider is MethodReference) { return(new GenericInstanceMethodForm(provider, context)); } if (provider is TypeReference) { return(new GenericInstanceTypeForm(provider, context)); } return(null); }
static ImportGenericContext GenericContextFor(IGenericParameterProvider context) { return(context != null ? new ImportGenericContext(context) : default(ImportGenericContext)); }
public GenericParameter(string name, IGenericParameterProvider owner) : base(string.Empty, string.Empty) { m_name = name; m_owner = owner; }
private TypeReference ProcessTypeReference(TypeReference type, IGenericParameterProvider owner) { if (type == null) { return(null); } // ref types if (type is ByReferenceType) { var elementType = ProcessTypeReference(type.GetElementType(), owner); if (elementType != type.GetElementType()) { type = new ByReferenceType(elementType); } return(type); } // Generic MVar/Var if (type is GenericParameter) { var genericParameter = (GenericParameter)type; if ((genericParameter.MetadataType == MetadataType.MVar || genericParameter.MetadataType == MetadataType.Var) && genericParameter.Owner is MethodReference) { if (genericParameter.Owner != null && owner != null) { return(owner.GenericParameters.Concat(genericParameter.Owner.GenericParameters).First(x => x.Name == type.Name)); } } return(type); } // Is it an async-related type? var asyncBridgeType = asyncBridgeAssembly.MainModule.GetTypeResolved(type.Namespace, type.Name); if (asyncBridgeType == null) { return(type); } // First work on inner TypeReference if there is a GenericInstanceType around it. var genericInstanceType = type as GenericInstanceType; if (genericInstanceType != null) { type = genericInstanceType.ElementType; } var newType = assembly.MainModule.ImportReference(new TypeReference(type.Namespace, type.Name, asyncBridgeAssembly.MainModule, asyncBridgeAssembly.Name, type.IsValueType)); for (int i = 0; i < type.GenericParameters.Count; ++i) { newType.GenericParameters.Add(new GenericParameter(type.GenericParameters[i].Name, newType)); foreach (var constraint in type.GenericParameters[i].Constraints) { newType.GenericParameters[i].Constraints.Add(new GenericParameterConstraint(ProcessTypeReference(constraint.ConstraintType, newType))); } } if (genericInstanceType != null) { var newGenericType = new GenericInstanceType(newType); foreach (var genericArgument in genericInstanceType.GenericArguments) { newGenericType.GenericArguments.Add(ProcessTypeReference(genericArgument, newGenericType)); } newType = newGenericType; } return(newType); }
void MarkGenericParameterProvider (IGenericParameterProvider provider) { if (!provider.HasGenericParameters) return; foreach (GenericParameter parameter in provider.GenericParameters) MarkGenericParameter (parameter); }
private static void ImportGenericParameters(IGenericParameterProvider imported, IGenericParameterProvider original) { Collection <GenericParameter> genericParameters = original.GenericParameters; Collection <GenericParameter> genericParameters1 = imported.GenericParameters; for (int i = 0; i < genericParameters.Count; i++) { genericParameters1.Add(new GenericParameter(genericParameters[i].Name, imported)); } }