示例#1
0
 public MemberRefOptions(MemberRef mr)
 {
     this.Class = mr.Class;
     this.Name = mr.Name;
     this.Signature = mr.Signature;
     this.CustomAttributes.AddRange(mr.CustomAttributes);
 }
示例#2
0
		public MemberRef CopyTo(MemberRef mr) {
			mr.Class = Class;
			mr.Name = Name ?? UTF8String.Empty;
			mr.Signature = Signature;
			mr.CustomAttributes.Clear();
			mr.CustomAttributes.AddRange(CustomAttributes);
			return mr;
		}
		MemberRef CreateInitializeArrayMethod() {
			if (initializeArrayMethod == null) {
				var runtimeHelpersType = DotNetUtils.FindOrCreateTypeRef(module, module.CorLibTypes.AssemblyRef, "System.Runtime.CompilerServices", "RuntimeHelpers", false);
				var systemArrayType = DotNetUtils.FindOrCreateTypeRef(module, module.CorLibTypes.AssemblyRef, "System", "Array", false);
				var runtimeFieldHandleType = DotNetUtils.FindOrCreateTypeRef(module, module.CorLibTypes.AssemblyRef, "System", "RuntimeFieldHandle", true);
				var methodSig = MethodSig.CreateStatic(module.CorLibTypes.Void, systemArrayType, runtimeFieldHandleType);
				initializeArrayMethod = module.UpdateRowId(new MemberRefUser(module, "InitializeArray", methodSig, runtimeHelpersType.TypeDefOrRef));
			}
			return initializeArrayMethod;
		}
示例#4
0
 /// <inheritdoc/>
 public IMemberForwarded Resolve(MemberRef memberRef)
 {
     if (memberRef == null)
         return null;
     var parent = memberRef.Class;
     var method = parent as MethodDef;
     if (method != null)
         return method;
     var declaringType = GetDeclaringType(memberRef, parent);
     return declaringType == null ? null : declaringType.Resolve(memberRef);
 }
示例#5
0
		internal static bool ContainsGenericParameter(MemberRef mr) {
			if (mr == null)
				return false;

			if (ContainsGenericParameter(mr.Signature))
				return true;

			var cl = mr.Class;

			var tdr = cl as ITypeDefOrRef;
			if (tdr != null)
				return tdr.ContainsGenericParameter;

			var md = cl as MethodDef;
			if (md != null)
				return TypeHelper.ContainsGenericParameter(md.Signature);

			return false;
		}
示例#6
0
		public MemberRefInfo(MemberRef mr) {
			this.MemberRef = mr;
			this.OrigName = mr.Name;
		}
示例#7
0
        void AnalyzeMemberRef(ConfuserContext context, INameService service, MemberRef memberRef)
        {
            ITypeDefOrRef declType = memberRef.DeclaringType;
            var typeSpec = declType as TypeSpec;
            if (typeSpec == null)
                return;

            TypeSig sig = typeSpec.TypeSig;
            while (sig.Next != null)
                sig = sig.Next;

            Debug.Assert(sig is TypeDefOrRefSig || sig is GenericInstSig || sig is GenericSig);
            if (sig is GenericInstSig) {
                var inst = (GenericInstSig)sig;
                Debug.Assert(!(inst.GenericType.TypeDefOrRef is TypeSpec));
                TypeDef openType = inst.GenericType.TypeDefOrRef.ResolveTypeDefThrow();
                if (!context.Modules.Contains((ModuleDefMD)openType.Module) ||
                    memberRef.IsArrayAccessors())
                    return;

                IDnlibDef member;
                if (memberRef.IsFieldRef) member = memberRef.ResolveFieldThrow();
                else if (memberRef.IsMethodRef) member = memberRef.ResolveMethodThrow();
                else throw new UnreachableException();

                service.AddReference(member, new MemberRefReference(memberRef, member));
            }
        }
示例#8
0
 public MMethodDef findMethod(MemberRef mr)
 {
     return methods.find(mr);
 }
		bool? CanAccess(MethodDef md, MemberRef mr) {
			if (mr == null || md == null)
				return null;
			return CanAccess(md);
		}
		bool? CanAccess(TypeDef td, MemberRef mr) {
			return CanAccess(td, null, mr);
		}
示例#11
0
		void Hash(MemberRef mr) {
			if (mr == null)
				return;

			Hash(mr.Class);
			if (IsFromNonObfuscatedAssembly(mr.Class))
				Hash(mr.Name);
			Hash(mr.Signature);
		}
示例#12
0
		/// <inheritdoc/>
		public IMemberForwarded Resolve(MemberRef memberRef) {
			if (memberRef == null)
				return null;
			if (ProjectWinMDRefs)
				memberRef = WinMDHelpers.ToCLR(memberRef.Module, memberRef) ?? memberRef;
			var parent = memberRef.Class;
			var method = parent as MethodDef;
			if (method != null)
				return method;
			var declaringType = GetDeclaringType(memberRef, parent);
			return declaringType == null ? null : declaringType.Resolve(memberRef);
		}
示例#13
0
		public MemberRefInfo(MemberRef mr) {
			MemberRef = mr;
			OrigName = mr.Name;
		}
示例#14
0
 void Add(MemberRef mr)
 {
     if (mr == null || memberRefs.ContainsKey(mr))
         return;
     if (mr.Module != validModule)
         return;
     memberRefs[mr] = true;
     Push(mr.Class);
     Add(mr.Signature);
     Add(mr.CustomAttributes);
 }
示例#15
0
		TypeDef GetDeclaringType(MemberRef memberRef, IMemberRefParent parent) {
			if (memberRef == null || parent == null)
				return null;

			var declaringTypeDef = parent as TypeDef;
			if (declaringTypeDef != null)
				return declaringTypeDef;

			var declaringTypeRef = parent as TypeRef;
			if (declaringTypeRef != null)
				return Resolve(declaringTypeRef);

			// A module ref is used to reference the global type of a module in the same
			// assembly as the current module.
			var moduleRef = parent as ModuleRef;
			if (moduleRef != null) {
				var module = memberRef.Module;
				if (module == null)
					return null;
				TypeDef globalType = null;
				if (new SigComparer(0).Equals(module, moduleRef))
					globalType = module.GlobalType;
				var modAsm = module.Assembly;
				if (globalType == null && modAsm != null) {
					var moduleDef = modAsm.FindModule(moduleRef.Name);
					if (moduleDef != null)
						globalType = moduleDef.GlobalType;
				}
				return globalType;
			}

			var method = parent as MethodDef;
			if (method != null)
				return method.DeclaringType;

			var ts = parent as TypeSpec;
			if (ts != null) {
				var git = ts.TypeSig as GenericInstSig;
				if (git != null) {
					var td = git.GenericType.TypeDef;
					if (td != null)
						return td;
					var tr = git.GenericType.TypeRef;
					if (tr != null)
						return Resolve(tr);
				}
				return null;
			}

			return null;
		}
		/// <summary>
		/// Checks whether it can access a <see cref="MemberRef"/>
		/// </summary>
		/// <param name="mr">The member reference</param>
		/// <returns><c>true</c> if it has access to it, <c>false</c> if not, and <c>null</c>
		/// if we can't determine it (eg. we couldn't resolve a type or input was <c>null</c>)</returns>
		public bool? CanAccess(MemberRef mr) {
			if (mr == null)
				return null;

			var parent = mr.Class;

			var td = parent as TypeDef;
			if (td != null)
				return CanAccess(td, mr);

			var tr = parent as TypeRef;
			if (tr != null)
				return CanAccess(tr.Resolve(), mr);

			var ts = parent as TypeSpec;
			if (ts != null)
				return CanAccess(ts.ResolveTypeDef(), ts.TryGetGenericInstSig(), mr);

			var md = parent as MethodDef;
			if (md != null)
				return CanAccess(md, mr);

			var mod = parent as ModuleRef;
			if (mod != null)
				return CanAccess(mod, mr);

			return null;
		}
示例#17
0
		public MMethodDef FindAnyMethod(MemberRef mr) {
			return methods.FindAny(mr);
		}
		bool? CanAccess(TypeDef td, GenericInstSig git, MemberRef mr) {
			if (mr == null || td == null)
				return null;

			if (mr.MethodSig != null) {
				var md = td.FindMethodCheckBaseType(mr.Name, mr.MethodSig);
				if (md == null) {
					// Assume that it's an array type if it's one of these methods
					if (mr.Name == "Get" || mr.Name == "Set" || mr.Name == "Address" || mr.Name == ".ctor")
						return true;
					return null;
				}
				return CanAccess(md, git);
			}

			if (mr.FieldSig != null)
				return CanAccess(td.FindFieldCheckBaseType(mr.Name, mr.FieldSig), git);

			return null;
		}
示例#19
0
		public MFieldDef FindAnyField(MemberRef fr) {
			return fields.FindAny(fr);
		}
		bool? CanAccess(ModuleRef mod, MemberRef mr) {
			if (mr == null || mod == null || mod.Module == null)
				return null;

			var userModule = userType.Module;
			if (userModule == null)
				return null;
			if (!IsSameAssembly(userModule.Assembly, mod.Module.Assembly))
				return false;
			if (userModule.Assembly == null)
				return false;
			var otherMod = userModule.Assembly.FindModule(mod.Name);
			if (otherMod == null)
				return false;
			return CanAccess(otherMod.GlobalType, mr);
		}
示例#21
0
 public MFieldDef findField(MemberRef fr)
 {
     return fields.find(fr);
 }