private static bool MatchProperty(PropertyDef mCandidate, MethodBaseSig mCandidateSig, PropertyDef mProperty) { if (mCandidate == null || mCandidateSig == null || mProperty == null) { return(false); } if (mCandidate.Name != mProperty.Name) { return(false); } var accMeth = mCandidate.GetMethod ?? mCandidate.SetMethod; if (accMeth != null && accMeth.HasOverrides) { return(false); } if (mProperty.PropertySig == null || mCandidateSig.GenParamCount != mProperty.PropertySig.GenParamCount) { return(false); } return(new SigComparer().Equals(mCandidateSig.Params, mProperty.PropertySig.Params)); }
public bool MethodSigEquals(MethodBaseSig sig, MethodBase method) { if (sig == null || method == null) { return(false); } if (sig.HasThis != !method.IsStatic) { return(false); } if (sig.Generic != method.IsGenericMethod) { return(false); } if (sig.Generic) { if (sig.GenParamCount != method.GetGenericArguments().Length) { return(false); } } if (method.IsMethodSpec()) { method = method.Module.ResolveMethod(method.MetadataToken) ?? method; } var mps = method.GetParameters(); if (sig.Params.Count != mps.Length) { return(false); } var minfo = method as MethodInfo; if (minfo != null) { if (!Equals(sig.RetType, minfo.ReturnType)) { return(false); } } else { if (sig.RetType.RemovePinnedAndModifiers().GetElementType() != ElementType.Void) { return(false); } } for (int i = 0; i < mps.Length; i++) { if (!Equals(sig.Params[i], mps[i].ParameterType)) { return(false); } } return(true); }
void Add(MethodBaseSig sig) { if (sig is null) { return; } Add(sig.RetType); Add(sig.Params); Add(sig.ParamsAfterSentinel); }
void add(MethodBaseSig sig) { if (sig == null) { return; } add(sig.RetType); add(sig.Params); add(sig.ParamsAfterSentinel); }
void Add(MethodBaseSig msig) { if (msig == null) { return; } Add(msig.ExtraData); Add(msig.RetType); Add(msig.Params); Add(msig.ParamsAfterSentinel); }
public static IList <TypeSig> GetParameters(this MethodBaseSig methodSig) { if (methodSig.ParamsAfterSentinel != null) { return(methodSig.Params .Concat(new TypeSig[] { new SentinelSig() }) .Concat(methodSig.ParamsAfterSentinel) .ToList()); } else { return(methodSig.Params); } }
/// <summary> /// Resolves the method signature with the specified generic arguments. /// </summary> /// <param name="methodSig">The method signature.</param> /// <param name="typeGenArgs">The type generic arguments.</param> /// <param name="methodGenArgs">The method generic arguments.</param> /// <returns>Resolved method signature.</returns> /// <exception cref="System.ArgumentException">No generic arguments to resolve.</exception> public static MethodBaseSig Resolve(MethodBaseSig methodSig, IList <TypeSig> typeGenArgs, IList <TypeSig> methodGenArgs) { if (methodSig == null) { return(null); } if ((typeGenArgs == null || typeGenArgs.Count == 0) && (methodGenArgs == null || methodGenArgs.Count == 0)) { return(methodSig); } var resolver = new GenericArgumentResolver(typeGenArgs, methodGenArgs); return(resolver.ResolveGenericArgs(methodSig)); }
MethodSig?ResolveGenericArgs(MethodBaseSig sig) { if (sig is null) { return(null); } if (!recursionCounter.Increment()) { return(null); } MethodSig result = ResolveGenericArgs(new MethodSig(sig.CallingConvention), sig); recursionCounter.Decrement(); return(result); }
MethodSig ResolveGenericArgs(MethodSig sig, MethodBaseSig old) { sig.RetType = ResolveGenericArgs(old.RetType); foreach (var p in old.Params) { sig.Params.Add(ResolveGenericArgs(p)); } sig.GenParamCount = old.GenParamCount; if (!(sig.ParamsAfterSentinel is null)) { foreach (var p in old.ParamsAfterSentinel) { sig.ParamsAfterSentinel.Add(ResolveGenericArgs(p)); } } return(sig); }
private void Write(MethodBaseSig sig) { if (sig == null) { helper.Error("sig is null"); return; } if (!recursionCounter.Increment()) { helper.Error("Infinite recursion"); return; } writer.Write((byte)sig.GetCallingConvention()); if (sig.Generic) { WriteCompressedUInt32(sig.GenParamCount); } var numParams = (uint)sig.Params.Count; if (sig.ParamsAfterSentinel != null) { numParams += (uint)sig.ParamsAfterSentinel.Count; } var count = WriteCompressedUInt32(numParams); Write(sig.RetType); for (uint i = 0; i < count && i < (uint)sig.Params.Count; i++) { Write(sig.Params[(int)i]); } if (sig.ParamsAfterSentinel != null && sig.ParamsAfterSentinel.Count > 0) { writer.Write((byte)ElementType.Sentinel); for (uint i = 0, j = (uint)sig.Params.Count; i < (uint)sig.ParamsAfterSentinel.Count && j < count; i++, j++) { Write(sig.ParamsAfterSentinel[(int)i]); } } recursionCounter.Decrement(); }
private static MethodSig Resolve(MethodBaseSig method, TypeSig typeContext) { var args = new GenericArguments(); if (typeContext.IsGenericInstanceType) { args.PushTypeArgs(((GenericInstSig)typeContext).GenericArguments); } var retSig = new MethodSig(method.CallingConvention); retSig.RetType = args.Resolve(method.RetType); foreach (var param in method.Params) { retSig.Params.Add(args.Resolve(param)); } return(retSig); }
bool ContainsGenericParameterInternal(MethodBaseSig mbs) { if (mbs == null) { return(false); } if (!recursionCounter.Increment()) { return(false); } bool res = ContainsGenericParameterInternal(mbs.RetType) || ContainsGenericParameter(mbs.Params) || ContainsGenericParameter(mbs.ParamsAfterSentinel); recursionCounter.Decrement(); return(res); }
public MethodBaseSig Duplicate(MethodBaseSig metBaseSig) { switch (metBaseSig) { case PropertySig propSig: return(new PropertySig( propSig.HasThis, Duplicate(propSig.RetType), Duplicate(propSig.Params).ToArray())); case MethodSig metSig: return(new MethodSig( metSig.CallingConvention, metSig.GenParamCount, Duplicate(metSig.RetType), Duplicate(metSig.Params))); default: throw new ArgumentOutOfRangeException("Duplicate " + metBaseSig.GetType().Name); } }
public MethodBaseSig Create(MethodSigCreatorOptions options, MethodBaseSig origSig) { var data = new MethodSigCreatorVM(options); if (origSig is MethodSig) { data.MethodSig = (MethodSig)origSig; } else if (origSig is PropertySig) { data.PropertySig = (PropertySig)origSig; } var win = new MethodSigCreatorDlg(); win.DataContext = data; win.Owner = ownerWindow ?? Application.Current.MainWindow; if (win.ShowDialog() != true) { return(null); } return(data.MethodBaseSig); }
/// <summary> /// Resolves the method signature with the specified generic arguments. /// </summary> /// <param name="methodSig">The method signature.</param> /// <param name="typeGenArgs">The type generic arguments.</param> /// <param name="methodGenArgs">The method generic arguments.</param> /// <returns>Resolved method signature.</returns> /// <exception cref="System.ArgumentException">No generic arguments to resolve.</exception> public static MethodSig Resolve(MethodBaseSig methodSig, IList <TypeSig> typeGenArgs, IList <TypeSig> methodGenArgs) { if (methodSig == null) { return(null); } var resolver = new GenericArgumentResolver(); resolver.genericArguments = new GenericArguments(); resolver.recursionCounter = new RecursionCounter(); if (typeGenArgs != null) { resolver.genericArguments.PushTypeArgs(typeGenArgs); } if (methodGenArgs != null) { resolver.genericArguments.PushMethodArgs(methodGenArgs); } return(resolver.ResolveGenericArgs(methodSig)); }
void WriteSignature(MethodBaseSig sig) { if (sig == null) { CallingConvention = 0; ReturnType = null; ParametersCreateTypeSigArray.TypeSigCollection.Clear(); GenericParameterCount.Value = 0; SentinelCreateTypeSigArray.TypeSigCollection.Clear(); } else { CallingConvention = sig.CallingConvention; ReturnType = sig.RetType; ParametersCreateTypeSigArray.TypeSigCollection.Clear(); ParametersCreateTypeSigArray.TypeSigCollection.AddRange(sig.Params); GenericParameterCount.Value = sig.GenParamCount; SentinelCreateTypeSigArray.TypeSigCollection.Clear(); if (sig.ParamsAfterSentinel != null) { SentinelCreateTypeSigArray.TypeSigCollection.AddRange(sig.ParamsAfterSentinel); } } }
public static string SignatureName(this MethodBaseSig self) { Debug.Assert(self.ParamsAfterSentinel == null); StringBuilder sb = new StringBuilder(); PrettyName(sb, self.RetType, false); sb.Append(' '); if (self.Generic) { sb.Append('<'); for (uint i = 0; i < self.GenParamCount; ++i) { if (i != 0) { sb.Append(','); } sb.AppendFormat("!!{0}", i); } sb.Append('>'); } sb.Append('('); for (int i = 0; i < self.Params.Count; ++i) { if (i != 0) { sb.Append(','); } PrettyName(sb, self.Params[i], false); } sb.Append(')'); return(sb.ToString()); }
private static bool MatchMethod(MethodDef mCandidate, MethodBaseSig mCandidateSig, MethodDef mMethod) { if (mCandidate == null || mCandidateSig == null || mMethod == null) { return(false); } if (mCandidate.Name != mMethod.Name) { return(false); } if (mCandidate.HasOverrides) { return(false); } if (mCandidate.IsSpecialName != mMethod.IsSpecialName) { return(false); } if (mCandidate.HasGenericParameters || mMethod.HasGenericParameters) { if (!mCandidate.HasGenericParameters || !mMethod.HasGenericParameters || mCandidate.GenericParameters.Count != mMethod.GenericParameters.Count) { return(false); } } if (mMethod.MethodSig == null || mCandidateSig.Params.Count != mMethod.MethodSig.Params.Count) { return(false); } if (mCandidate.Parameters.Count != mMethod.Parameters.Count) { return(false); } for (int i = 0; i < mCandidate.Parameters.Count; i++) { var p1 = mCandidate.Parameters[i]; var p2 = mMethod.Parameters[i]; if (p1.IsHiddenThisParameter != p2.IsHiddenThisParameter) { return(false); } if (p1.IsHiddenThisParameter) { continue; } var pd1 = p1.ParamDef ?? new ParamDefUser(); var pd2 = p2.ParamDef ?? new ParamDefUser(); if (pd1.IsIn != pd2.IsIn || pd1.IsOut != pd2.IsOut) { return(false); } } return(new SigComparer().Equals(mCandidateSig.Params, mMethod.MethodSig.Params)); }
/// <summary> /// Checks whether <paramref name="methodSig"/> contains a <see cref="GenericVar"/> or a /// <see cref="GenericMVar"/>. /// </summary> /// <param name="methodSig">Method or property signature</param> /// <returns><c>true</c> if <paramref name="methodSig"/> contains a <see cref="GenericVar"/> /// or a <see cref="GenericMVar"/>.</returns> public static bool ContainsGenericParameter(MethodBaseSig methodSig) => new TypeHelper().ContainsGenericParameterInternal(methodSig);
private static MethodSig Resolve(MethodBaseSig method, TypeSig typeContext) { var genericArgs = typeContext.IsGenericInstanceType ? ((GenericInstSig)typeContext).GenericArguments : null; return(GenericArgumentResolver.Resolve(method, genericArgs, null)); }
void Write(MethodBaseSig sig) { if (sig == null) { helper.Error("sig is null"); return; } if (!recursionCounter.Increment()) { helper.Error("Infinite recursion"); return; } writer.Write((byte)sig.GetCallingConvention()); if (sig.Generic) WriteCompressedUInt32(sig.GenParamCount); uint numParams = (uint)sig.Params.Count; if (sig.ParamsAfterSentinel != null) numParams += (uint)sig.ParamsAfterSentinel.Count; uint count = WriteCompressedUInt32(numParams); Write(sig.RetType); for (uint i = 0; i < count && i < (uint)sig.Params.Count; i++) Write(sig.Params[(int)i]); if (sig.ParamsAfterSentinel != null && sig.ParamsAfterSentinel.Count > 0) { writer.Write((byte)ElementType.Sentinel); for (uint i = 0, j = (uint)sig.Params.Count; i < (uint)sig.ParamsAfterSentinel.Count && j < count; i++, j++) Write(sig.ParamsAfterSentinel[(int)i]); } recursionCounter.Decrement(); }