Esempio n. 1
0
		/// <inheritdoc/>
		public IMemberForwarded Resolve(MemberRef memberRef) {
			if (memberRef == null)
				return null;
			var method = memberRef.Class as MethodDef;
			if (method != null)
				return method;
			var declaringType = GetDeclaringType(memberRef);
			return declaringType == null ? null : declaringType.Resolve(memberRef);
		}
Esempio n. 2
0
		TypeDef GetDeclaringType(MemberRef memberRef) {
			if (memberRef == null)
				return null;

			var parent = memberRef.Class;
			if (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;
				if (globalType == null && module.Assembly != null) {
					var moduleDef = module.Assembly.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;
		}
Esempio n. 3
0
		/// <summary>
		/// Resolves a field
		/// </summary>
		/// <param name="self">this</param>
		/// <param name="memberRef">A field reference</param>
		/// <returns>A <see cref="FieldDef"/> instance or <c>null</c> if it couldn't be resolved.</returns>
		/// <exception cref="MemberRefResolveException">If the field couldn't be resolved</exception>
		public static FieldDef ResolveFieldThrow(this IMemberRefResolver self, MemberRef memberRef) {
			var field = self.Resolve(memberRef) as FieldDef;
			if (field != null)
				return field;
			throw new MemberRefResolveException(string.Format("Could not resolve field: {0}", memberRef));
		}
Esempio n. 4
0
		/// <summary>
		/// Resolves a method
		/// </summary>
		/// <param name="self">this</param>
		/// <param name="memberRef">A method reference</param>
		/// <returns>A <see cref="MethodDef"/> instance or <c>null</c> if it couldn't be resolved.</returns>
		/// <exception cref="MemberRefResolveException">If the method couldn't be resolved</exception>
		public static MethodDef ResolveMethodThrow(this IMemberRefResolver self, MemberRef memberRef) {
			var method = self.Resolve(memberRef) as MethodDef;
			if (method != null)
				return method;
			throw new MemberRefResolveException(string.Format("Could not resolve method: {0} ({1})", memberRef, memberRef == null ? null : memberRef.GetDefinitionAssembly()));
		}
		/// <inheritdoc/>
		protected override uint AddMemberRef(MemberRef mr) {
			if (mr == null) {
				Error("MemberRef is null");
				return 0;
			}
			uint rid;
			if (memberRefInfos.TryGetRid(mr, out rid))
				return rid;
			var row = new RawMemberRefRow(AddMemberRefParent(mr.Class),
							stringsHeap.Add(mr.Name),
							GetSignature(mr.Signature));
			rid = tablesHeap.MemberRefTable.Add(row);
			memberRefInfos.Add(mr, rid);
			AddCustomAttributes(Table.MemberRef, rid, mr);
			return rid;
		}
Esempio n. 6
0
		/// <summary>
		/// Creates a new instruction with a method/field operand
		/// </summary>
		/// <param name="opCode">The opcode</param>
		/// <param name="mr">The method/field</param>
		/// <returns>A new <see cref="Instruction"/> instance</returns>
		public static Instruction Create(OpCode opCode, MemberRef mr) {
			if (opCode.OperandType != OperandType.InlineField && opCode.OperandType != OperandType.InlineMethod && opCode.OperandType != OperandType.InlineTok)
				throw new ArgumentException("Opcode does not have a field operand", "opCode");
			return new Instruction(opCode, mr);
		}
Esempio n. 7
0
        private static void AddImportReference(INameService service, ICollection <ModuleDefMD> modules, ModuleDef module, MethodDef method, MemberRef methodRef)
        {
            if (method.Module != module && modules.Contains((ModuleDefMD)module))
            {
                var declType = (TypeRef)methodRef.DeclaringType.ScopeType;
                service.AddReference(method.DeclaringType, new TypeRefReference(declType, method.DeclaringType));
                service.AddReference(method, new MemberRefReference(methodRef, method));

                var typeRefs = methodRef.MethodSig.Params.SelectMany(param => param.FindTypeRefs()).ToList();
                typeRefs.AddRange(methodRef.MethodSig.RetType.FindTypeRefs());
                typeRefs.AddRange(methodRef.DeclaringType.ToTypeSig().FindTypeRefs());
                foreach (var typeRef in typeRefs)
                {
                    SetupTypeReference(service, modules, module, typeRef);
                }
            }
        }
Esempio n. 8
0
		/// <inheritdoc/>
		public IMemberForwarded Resolve(MemberRef memberRef) {
			return null;
		}
Esempio n. 9
0
 public RuntimeImport(MemberRef importingMemberRef, TypeRef importingSiteTypeRef, TypeRef importingSiteTypeWithoutCollectionRef, ImportCardinality cardinality, IReadOnlyList <RuntimeExport> satisfyingExports, bool isNonSharedInstanceRequired, bool isExportFactory, IReadOnlyDictionary <string, object> metadata, IReadOnlyCollection <string> exportFactorySharingBoundaries)
     : this(importingSiteTypeRef, importingSiteTypeWithoutCollectionRef, cardinality, satisfyingExports, isNonSharedInstanceRequired, isExportFactory, metadata, exportFactorySharingBoundaries)
 {
     this.ImportingMemberRef = importingMemberRef;
 }
Esempio n. 10
0
        private static RuntimeExport CreateRuntimeExport(ExportDefinition exportDefinition, Type partType, MemberRef exportingMemberRef, Resolver resolver)
        {
            Requires.NotNull(exportDefinition, nameof(exportDefinition));

            var exportingMember = exportingMemberRef?.MemberInfo;

            return(new RuntimeExport(
                       exportDefinition.ContractName,
                       TypeRef.Get(partType, resolver),
                       exportingMemberRef,
                       TypeRef.Get(ReflectionHelpers.GetExportedValueType(partType, exportingMember), resolver),
                       exportDefinition.Metadata));
        }
Esempio n. 11
0
            protected override void Execute(ConfuserContext context, ProtectionParameters parameters)
            {
                foreach (ModuleDef module in parameters.Targets.OfType <ModuleDef>())
                {
                    foreach (TypeDef type in module.Types.ToArray())
                    {
                        foreach (MethodDef method in type.Methods.ToArray())
                        {
                            if (method.HasBody)
                            {
                                if (method.Body.HasInstructions)
                                {
                                    if (method.FullName.Contains("My."))
                                    {
                                        continue;
                                    }
                                    if (method.FullName.Contains(".My"))
                                    {
                                        continue;
                                    }
                                    if (method.FullName.Contains("Costura"))
                                    {
                                        continue;
                                    }
                                    if (method.IsConstructor)
                                    {
                                        continue;
                                    }
                                    if (method.DeclaringType.IsGlobalModuleType)
                                    {
                                        continue;
                                    }
                                    for (int i = 0; i < method.Body.Instructions.Count - 1; i++)
                                    {
                                        try
                                        {
                                            if (method.Body.Instructions[i].ToString().Contains("ISupportInitialize"))
                                            {
                                                continue;
                                            }
                                            if (method.Body.Instructions[i].OpCode == OpCodes.Call || method.Body.Instructions[i].OpCode == OpCodes.Callvirt /* || method.Body.Instructions[i].OpCode == OpCodes.Ldloc_S*/)
                                            {
                                                try
                                                {
                                                    MemberRef membertocalli = (MemberRef)method.Body.Instructions[i].Operand;


                                                    method.Body.Instructions[i].OpCode  = OpCodes.Calli;
                                                    method.Body.Instructions[i].Operand = membertocalli.MethodSig;
                                                    method.Body.Instructions.Insert(i, Instruction.Create(OpCodes.Ldftn, membertocalli));
                                                }
                                                catch (Exception ex)
                                                {
                                                    string str = ex.Message;
                                                }
                                            }
                                        }
                                        catch
                                        {
                                        }
                                    }
                                }
                                else
                                {
                                }
                            }
                        }
                        foreach (MethodDef md in module.GlobalType.Methods)
                        {
                            if (md.Name == ".ctor")
                            {
                                module.GlobalType.Remove(md);
                                break;
                            }
                        }
                    }
                }
            }
Esempio n. 12
0
        private void AddImportsFromMembers(PropertyInfo[] declaredProperties, FieldInfo[] declaredFields, TypeRef partTypeRef, IList <ImportDefinitionBinding> imports)
        {
            Requires.NotNull(declaredProperties, nameof(declaredProperties));
            Requires.NotNull(declaredFields, nameof(declaredFields));
            Requires.NotNull(partTypeRef, nameof(partTypeRef));
            Requires.NotNull(imports, nameof(imports));

            foreach (var member in declaredFields.Concat <MemberInfo>(declaredProperties))
            {
                if (!member.IsStatic())
                {
                    ImportDefinition importDefinition;
                    if (this.TryCreateImportDefinition(ReflectionHelpers.GetMemberType(member), member, out importDefinition))
                    {
                        imports.Add(new ImportDefinitionBinding(importDefinition, partTypeRef, MemberRef.Get(member, this.Resolver)));
                    }
                }
            }
        }
Esempio n. 13
0
 /// <summary>
 /// Resolves a method
 /// </summary>
 /// <param name="self">this</param>
 /// <param name="memberRef">A method reference</param>
 /// <returns>A <see cref="MethodDef"/> instance or <c>null</c> if it couldn't be resolved.</returns>
 public static MethodDef ResolveMethod(this IMemberRefResolver self, MemberRef memberRef) => self.Resolve(memberRef) as MethodDef;
Esempio n. 14
0
 /// <summary>
 /// Resolves a field
 /// </summary>
 /// <param name="self">this</param>
 /// <param name="memberRef">A field reference</param>
 /// <returns>A <see cref="FieldDef"/> instance or <c>null</c> if it couldn't be resolved.</returns>
 public static FieldDef ResolveField(this IMemberRefResolver self, MemberRef memberRef) => self.Resolve(memberRef) as FieldDef;
Esempio n. 15
0
		/// <summary>
		/// Resolves a method
		/// </summary>
		/// <param name="self">this</param>
		/// <param name="memberRef">A method reference</param>
		/// <returns>A <see cref="MethodDef"/> instance or <c>null</c> if it couldn't be resolved.</returns>
		/// <exception cref="MemberRefResolveException">If the method couldn't be resolved</exception>
		public static MethodDef ResolveMethodThrow(this IMemberRefResolver self, MemberRef memberRef) {
			var method = self.Resolve(memberRef) as MethodDef;
			if (method != null)
				return method;
			throw new MemberRefResolveException(string.Format("Could not resolve method: {0}", memberRef));
		}
Esempio n. 16
0
		/// <summary>
		/// Resolves a field
		/// </summary>
		/// <param name="self">this</param>
		/// <param name="memberRef">A field reference</param>
		/// <returns>A <see cref="FieldDef"/> instance or <c>null</c> if it couldn't be resolved.</returns>
		public static FieldDef ResolveField(this IMemberRefResolver self, MemberRef memberRef) {
			return self.Resolve(memberRef) as FieldDef;
		}
Esempio n. 17
0
 /// <summary>
 /// Creates a new instruction with a method/field operand
 /// </summary>
 /// <param name="mr">The method/field</param>
 /// <returns>A new <see cref="Instruction"/> instance</returns>
 public Instruction ToInstruction(MemberRef mr)
 {
     return(Instruction.Create(this, mr));
 }
        void AddImportReference(ConfuserContext context, INameService service, ModuleDef module, MethodDef method, MemberRef methodRef)
        {
            if (method.Module != module && context.Modules.Contains((ModuleDefMD)method.Module))
            {
                var declType = (TypeRef)methodRef.DeclaringType.ScopeType;
                service.AddReference(method.DeclaringType, new TypeRefReference(declType, method.DeclaringType));
                service.AddReference(method, new MemberRefReference(methodRef, method));

                var typeRefs = methodRef.MethodSig.Params.SelectMany(param => param.FindTypeRefs()).ToList();
                typeRefs.AddRange(methodRef.MethodSig.RetType.FindTypeRefs());
                foreach (var typeRef in typeRefs)
                {
                    var def = typeRef.ResolveTypeDefThrow();
                    if (def.Module != module && context.Modules.Contains((ModuleDefMD)def.Module))
                    {
                        service.AddReference(def, new TypeRefReference((TypeRef)typeRef, def));
                    }
                }
            }
        }
        private static void AnalyzeMemberRef(ICollection <ModuleDefMD> modules, INameService service, MemberRef memberRef)
        {
            ITypeDefOrRef declType = memberRef.DeclaringType;
            var           typeSpec = declType as TypeSpec;

            if (typeSpec == null || typeSpec.TypeSig.IsArray || typeSpec.TypeSig.IsSZArray)
            {
                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 (!modules.Contains((ModuleDefMD)openType.Module) ||
                    memberRef.IsArrayAccessors())
                {
                    return;
                }

                IMemberDef 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));
            }
        }
Esempio n. 20
0
 public abstract InvalidInfo ImplementableMemberRef(MessageContext ctxt, RootEnvironment rootEnv, MemberRef memberRef);
Esempio n. 21
0
 /// <summary>
 /// Resolves a field
 /// </summary>
 /// <param name="self">this</param>
 /// <param name="memberRef">A field reference</param>
 /// <returns>A <see cref="FieldDef"/> instance or <c>null</c> if it couldn't be resolved.</returns>
 public static FieldDef ResolveField(this IMemberRefResolver self, MemberRef memberRef)
 {
     return(self.Resolve(memberRef) as FieldDef);
 }
Esempio n. 22
0
 /// <summary>
 /// Resolves a method
 /// </summary>
 /// <param name="self">this</param>
 /// <param name="memberRef">A method reference</param>
 /// <returns>A <see cref="MethodDef"/> instance or <c>null</c> if it couldn't be resolved.</returns>
 public static MethodDef ResolveMethod(this IMemberRefResolver self, MemberRef memberRef)
 {
     return(self.Resolve(memberRef) as MethodDef);
 }
 public MemberRefReference(MemberRef memberRef, IDnlibDef memberDef)
 {
     this.memberRef = memberRef;
     this.memberDef = memberDef;
 }
Esempio n. 24
0
		/// <inheritdoc/>
		public override uint GetRid(MemberRef mr) {
			uint rid;
			memberRefInfos.TryGetRid(mr, out rid);
			return rid;
		}
Esempio n. 25
0
 public static TypeConstraint Type(MemberRef constrainedType)
 => new TypeConstraint(ConstraintType.Type, constrainedType, default);
Esempio n. 26
0
		/// <summary>
		/// Resolves a field
		/// </summary>
		/// <param name="self">this</param>
		/// <param name="memberRef">A field reference</param>
		/// <returns>A <see cref="FieldDef"/> instance or <c>null</c> if it couldn't be resolved.</returns>
		/// <exception cref="MemberRefResolveException">If the field couldn't be resolved</exception>
		public static FieldDef ResolveFieldThrow(this IMemberRefResolver self, MemberRef memberRef) {
			var field = self.Resolve(memberRef) as FieldDef;
			if (field != null)
				return field;
			throw new MemberRefResolveException(string.Format("Could not resolve field: {0} ({1})", memberRef, memberRef == null ? null : memberRef.GetDefinitionAssembly()));
		}
Esempio n. 27
0
 /// <summary>
 /// Creates a new instruction with a method/field operand
 /// </summary>
 /// <param name="mr">The method/field</param>
 /// <returns>A new <see cref="Instruction"/> instance</returns>
 public Instruction ToInstruction(MemberRef mr) => Instruction.Create(this, mr);
Esempio n. 28
0
		/// <summary>
		/// Resolves a method or a field
		/// </summary>
		/// <param name="self">this</param>
		/// <param name="memberRef">A method/field reference</param>
		/// <returns>A <see cref="MethodDef"/> or a <see cref="FieldDef"/> instance</returns>
		/// <exception cref="MemberRefResolveException">If the method/field couldn't be resolved</exception>
		public static IMemberForwarded ResolveThrow(this IMemberRefResolver self, MemberRef memberRef) {
			var memberDef = self.Resolve(memberRef);
			if (memberDef != null)
				return memberDef;
			throw new MemberRefResolveException(string.Format("Could not resolve method/field: {0} ({1})", memberRef, memberRef == null ? null : memberRef.GetDefinitionAssembly()));
		}
Esempio n. 29
0
 /// <inheritdoc/>
 public IMemberForwarded Resolve(MemberRef memberRef)
 {
     return(null);
 }
Esempio n. 30
0
		/// <summary>
		/// Resolves a method
		/// </summary>
		/// <param name="self">this</param>
		/// <param name="memberRef">A method reference</param>
		/// <returns>A <see cref="MethodDef"/> instance or <c>null</c> if it couldn't be resolved.</returns>
		public static MethodDef ResolveMethod(this IMemberRefResolver self, MemberRef memberRef) {
			return self.Resolve(memberRef) as MethodDef;
		}
Esempio n. 31
0
 public MemberRefInfo(MemberRef mr)
 {
     this.MemberRef = mr;
     this.OrigName  = mr.Name;
 }
Esempio n. 32
0
		/// <summary>
		/// Resolves a method or a field
		/// </summary>
		/// <param name="self">this</param>
		/// <param name="memberRef">A method/field reference</param>
		/// <returns>A <see cref="MethodDef"/> or a <see cref="FieldDef"/> instance</returns>
		/// <exception cref="MemberRefResolveException">If the method/field couldn't be resolved</exception>
		public static IMemberForwarded ResolveThrow(this IMemberRefResolver self, MemberRef memberRef) {
			var memberDef = self.Resolve(memberRef);
			if (memberDef != null)
				return memberDef;
			throw new MemberRefResolveException(string.Format("Could not resolve method/field: {0}", memberRef));
		}
Esempio n. 33
0
        protected override ComposablePartDefinition CreatePart(Type partType, bool typeExplicitlyRequested)
        {
            Requires.NotNull(partType, nameof(partType));

            var partTypeInfo = partType.GetTypeInfo();

            if (!typeExplicitlyRequested)
            {
                bool isPublic = partType.IsNested ? partTypeInfo.IsNestedPublic : partTypeInfo.IsPublic;
                if (!this.IsNonPublicSupported && !isPublic)
                {
                    // Skip non-public types.
                    return(null);
                }
            }

            var declaredProperties  = partTypeInfo.GetProperties(BindingFlags.Instance | this.PublicVsNonPublicFlags);
            var exportingProperties = from member in declaredProperties
                                      from export in member.GetAttributes <ExportAttribute>()
                                      select new KeyValuePair <MemberInfo, ExportAttribute>(member, export);
            var exportedTypes = from export in partTypeInfo.GetAttributes <ExportAttribute>()
                                select new KeyValuePair <MemberInfo, ExportAttribute>(partTypeInfo, export);
            var exportsByMember = (from export in exportingProperties.Concat(exportedTypes)
                                   group export.Value by export.Key into exportsByType
                                   select exportsByType).Select(g => new KeyValuePair <MemberInfo, ExportAttribute[]>(g.Key, g.ToArray())).ToArray();

            if (exportsByMember.Length == 0)
            {
                return(null);
            }

            // Check for PartNotDiscoverable only after we've established it's an interesting part.
            // This optimizes for the fact that most types have no exports, in which case it's not a discoverable
            // part anyway. Checking for the PartNotDiscoverableAttribute first, which is rarely defined,
            // doesn't usually pay for itself in terms of short-circuiting. But it does add an extra
            // attribute to look for that we don't need to find for all the types that have no export attributes either.
            if (!typeExplicitlyRequested && partTypeInfo.IsAttributeDefined <PartNotDiscoverableAttribute>())
            {
                return(null);
            }

            TypeRef partTypeRef = TypeRef.Get(partType, this.Resolver);
            Type    partTypeAsGenericTypeDefinition = partTypeInfo.IsGenericType ? partType.GetGenericTypeDefinition() : null;

            string sharingBoundary = null;
            var    sharedAttribute = partTypeInfo.GetFirstAttribute <SharedAttribute>();

            if (sharedAttribute != null)
            {
                sharingBoundary = sharedAttribute.SharingBoundary ?? string.Empty;
            }

            CreationPolicy partCreationPolicy = sharingBoundary != null ? CreationPolicy.Shared : CreationPolicy.NonShared;
            var            allExportsMetadata = ImmutableDictionary.CreateRange(PartCreationPolicyConstraint.GetExportMetadata(partCreationPolicy));

            var exportsOnType    = ImmutableList.CreateBuilder <ExportDefinition>();
            var exportsOnMembers = ImmutableDictionary.CreateBuilder <MemberRef, IReadOnlyCollection <ExportDefinition> >();
            var imports          = ImmutableList.CreateBuilder <ImportDefinitionBinding>();

            foreach (var export in exportsByMember)
            {
                var member = export.Key;
                var memberExportMetadata = allExportsMetadata.AddRange(this.GetExportMetadata(member));

                if (member is TypeInfo)
                {
                    foreach (var exportAttribute in export.Value)
                    {
                        Type             exportedType     = exportAttribute.ContractType ?? partTypeAsGenericTypeDefinition ?? partType;
                        ExportDefinition exportDefinition = CreateExportDefinition(memberExportMetadata, exportAttribute, exportedType);
                        exportsOnType.Add(exportDefinition);
                    }
                }
                else // property
                {
                    var property = (PropertyInfo)member;
                    Verify.Operation(!partTypeInfo.IsGenericTypeDefinition, Strings.ExportsOnMembersNotAllowedWhenDeclaringTypeGeneric);
                    var exportDefinitions = ImmutableList.CreateBuilder <ExportDefinition>();
                    foreach (var exportAttribute in export.Value)
                    {
                        Type             exportedType     = exportAttribute.ContractType ?? property.PropertyType;
                        ExportDefinition exportDefinition = CreateExportDefinition(memberExportMetadata, exportAttribute, exportedType);
                        exportDefinitions.Add(exportDefinition);
                    }

                    exportsOnMembers.Add(MemberRef.Get(member, this.Resolver), exportDefinitions.ToImmutable());
                }
            }

            foreach (var member in declaredProperties)
            {
                var importAttribute     = member.GetFirstAttribute <ImportAttribute>();
                var importManyAttribute = member.GetFirstAttribute <ImportManyAttribute>();
                Requires.Argument(!(importAttribute != null && importManyAttribute != null), "partType", Strings.MemberContainsBothImportAndImportMany, member.Name);

                var importConstraints = GetImportConstraints(member);
                ImportDefinition importDefinition;
                if (this.TryCreateImportDefinition(ReflectionHelpers.GetMemberType(member), member, importConstraints, out importDefinition))
                {
                    var importDefinitionBinding = new ImportDefinitionBinding(
                        importDefinition,
                        TypeRef.Get(partType, this.Resolver),
                        MemberRef.Get(member, this.Resolver),
                        TypeRef.Get(member.PropertyType, this.Resolver),
                        TypeRef.Get(GetImportingSiteTypeWithoutCollection(importDefinition, member.PropertyType), this.Resolver));
                    imports.Add(importDefinitionBinding);
                }
            }

            MethodInfo onImportsSatisfied = null;

            foreach (var method in partTypeInfo.GetMethods(this.PublicVsNonPublicFlags | BindingFlags.Instance))
            {
                if (method.IsAttributeDefined <OnImportsSatisfiedAttribute>())
                {
                    Verify.Operation(method.GetParameters().Length == 0, Strings.OnImportsSatisfiedTakeNoParameters);
                    Verify.Operation(onImportsSatisfied == null, Strings.OnlyOneOnImportsSatisfiedMethodIsSupported);
                    onImportsSatisfied = method;
                }
            }

            var importingConstructorParameters = ImmutableList.CreateBuilder <ImportDefinitionBinding>();
            var importingCtor = GetImportingConstructor <ImportingConstructorAttribute>(partType, publicOnly: !this.IsNonPublicSupported);

            Verify.Operation(importingCtor != null, Strings.NoImportingConstructorFound);
            foreach (var parameter in importingCtor.GetParameters())
            {
                var import = this.CreateImport(parameter, GetImportConstraints(parameter));
                if (import.ImportDefinition.Cardinality == ImportCardinality.ZeroOrMore)
                {
                    Verify.Operation(PartDiscovery.IsImportManyCollectionTypeCreateable(import), Strings.CollectionMustBePublicAndPublicCtorWhenUsingImportingCtor);
                }

                importingConstructorParameters.Add(import);
            }

            var partMetadata = ImmutableDictionary.CreateBuilder <string, object>();

            foreach (var partMetadataAttribute in partTypeInfo.GetAttributes <PartMetadataAttribute>())
            {
                partMetadata[partMetadataAttribute.Name] = partMetadataAttribute.Value;
            }

            var assemblyNamesForMetadataAttributes = ImmutableHashSet.CreateBuilder <AssemblyName>(ByValueEquality.AssemblyName);

            foreach (var export in exportsByMember)
            {
                GetAssemblyNamesFromMetadataAttributes <MetadataAttributeAttribute>(export.Key, assemblyNamesForMetadataAttributes);
            }

            return(new ComposablePartDefinition(
                       TypeRef.Get(partType, this.Resolver),
                       partMetadata.ToImmutable(),
                       exportsOnType.ToImmutable(),
                       exportsOnMembers.ToImmutable(),
                       imports.ToImmutable(),
                       sharingBoundary,
                       MethodRef.Get(onImportsSatisfied, this.Resolver),
                       MethodRef.Get(importingCtor, this.Resolver),
                       importingConstructorParameters.ToImmutable(),
                       partCreationPolicy,
                       assemblyNamesForMetadataAttributes));
        }
Esempio n. 34
0
		/// <summary>
		/// Creates a new instruction with a method/field operand
		/// </summary>
		/// <param name="mr">The method/field</param>
		/// <returns>A new <see cref="Instruction"/> instance</returns>
		public Instruction ToInstruction(MemberRef mr) {
			return Instruction.Create(this, mr);
		}
Esempio n. 35
0
        protected override ComposablePartDefinition?CreatePart(Type partType, bool typeExplicitlyRequested)
        {
            Requires.NotNull(partType, nameof(partType));

            var partTypeInfo = partType.GetTypeInfo();

            // We want to ignore abstract classes, but we want to consider static classes.
            // Static classes claim to be both abstract and sealed. So to ignore just abstract
            // ones, we check that they are not sealed.
            if (partTypeInfo.IsAbstract && !partTypeInfo.IsSealed)
            {
                return(null);
            }

            BindingFlags everythingLocal = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
            BindingFlags instanceLocal   = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;

            // If the type is abstract only find local static exports
            var exportBindingFlags = everythingLocal;

            if (partTypeInfo.IsAbstract)
            {
                exportBindingFlags &= ~BindingFlags.Instance;
            }

            var declaredMethods    = partType.GetMethods(exportBindingFlags); // methods can only export, not import
            var declaredProperties = partType.GetProperties(everythingLocal);
            var declaredFields     = partType.GetFields(everythingLocal);

            var allLocalMembers  = declaredMethods.Concat <MemberInfo>(declaredProperties).Concat(declaredFields);
            var exportingMembers = from member in allLocalMembers
                                   from export in member.GetAttributes <ExportAttribute>()
                                   select new KeyValuePair <MemberInfo, ExportAttribute>(member, export);
            var exportedTypes = from export in partTypeInfo.GetAttributes <ExportAttribute>()
                                select new KeyValuePair <MemberInfo, ExportAttribute>(partTypeInfo, export);
            var inheritedExportedTypes = from baseTypeOrInterface in partType.GetInterfaces().Concat(partType.EnumTypeAndBaseTypes().Skip(1))
                                         where baseTypeOrInterface != typeof(object)
                                         from export in baseTypeOrInterface.GetTypeInfo().GetAttributes <InheritedExportAttribute>()
                                         select new KeyValuePair <MemberInfo, ExportAttribute>(baseTypeOrInterface.GetTypeInfo(), export);

            var exportsByMember = (from export in exportingMembers.Concat(exportedTypes).Concat(inheritedExportedTypes)
                                   group export.Value by export.Key into exportsByType
                                   select exportsByType).Select(g => new KeyValuePair <MemberInfo, ExportAttribute[]>(g.Key, g.ToArray())).ToArray();

            if (exportsByMember.Length == 0)
            {
                return(null);
            }

            // Check for PartNotDiscoverable only after we've established it's an interesting part.
            // This optimizes for the fact that most types have no exports, in which case it's not a discoverable
            // part anyway. Checking for the PartNotDiscoverableAttribute first, which is rarely defined,
            // doesn't usually pay for itself in terms of short-circuiting. But it does add an extra
            // attribute to look for that we don't need to find for all the types that have no export attributes either.
            if (!typeExplicitlyRequested && partTypeInfo.IsAttributeDefined <PartNotDiscoverableAttribute>())
            {
                return(null);
            }

            foreach (var exportingMember in exportsByMember)
            {
                this.ThrowOnInvalidExportingMember(exportingMember.Key);
            }

            TypeRef partTypeRef = TypeRef.Get(partType, this.Resolver);
            Type?   partTypeAsGenericTypeDefinition = partTypeInfo.IsGenericType ? partType.GetGenericTypeDefinition() : null;

            // Collect information for all imports.
            var imports = ImmutableList.CreateBuilder <ImportDefinitionBinding>();

            this.AddImportsFromMembers(declaredProperties, declaredFields, partTypeRef, imports);
            Type?baseType = partTypeInfo.BaseType;

            while (baseType != null && baseType != typeof(object))
            {
                this.AddImportsFromMembers(baseType.GetProperties(instanceLocal), baseType.GetFields(instanceLocal), partTypeRef, imports);
                baseType = baseType.GetTypeInfo().BaseType;
            }

            var partCreationPolicy          = CreationPolicy.Any;
            var partCreationPolicyAttribute = partTypeInfo.GetFirstAttribute <PartCreationPolicyAttribute>();

            if (partCreationPolicyAttribute != null)
            {
                partCreationPolicy = (CreationPolicy)partCreationPolicyAttribute.CreationPolicy;
            }

            var allExportsMetadata = ImmutableDictionary.CreateRange(PartCreationPolicyConstraint.GetExportMetadata(partCreationPolicy));
            var inheritedExportContractNamesFromNonInterfaces = ImmutableHashSet.CreateBuilder <string>();
            var exportDefinitions = ImmutableList.CreateBuilder <KeyValuePair <MemberInfo, ExportDefinition> >();

            foreach (var export in exportsByMember)
            {
                var memberExportMetadata = allExportsMetadata.AddRange(GetExportMetadata(export.Key));

                if (export.Key is MethodInfo method)
                {
                    var exportAttributes = export.Value;
                    if (exportAttributes.Any())
                    {
                        foreach (var exportAttribute in exportAttributes)
                        {
                            Type   exportedType   = exportAttribute.ContractType ?? ReflectionHelpers.GetContractTypeForDelegate(method);
                            string contractName   = string.IsNullOrEmpty(exportAttribute.ContractName) ? GetContractName(exportedType) : exportAttribute.ContractName !;
                            var    exportMetadata = memberExportMetadata
                                                    .Add(CompositionConstants.ExportTypeIdentityMetadataName, ContractNameServices.GetTypeIdentity(exportedType));
                            var exportDefinition = new ExportDefinition(contractName, exportMetadata);
                            exportDefinitions.Add(new KeyValuePair <MemberInfo, ExportDefinition>(export.Key, exportDefinition));
                        }
                    }
                }
                else
                {
                    MemberInfo exportingTypeOrPropertyOrField = export.Key;
                    Verify.Operation(export.Key is TypeInfo || !partTypeInfo.IsGenericTypeDefinition, Strings.ExportsOnMembersNotAllowedWhenDeclaringTypeGeneric);
                    Type exportSiteType = ReflectionHelpers.GetMemberType(exportingTypeOrPropertyOrField);
                    foreach (var exportAttribute in export.Value)
                    {
                        Type   exportedType = exportAttribute.ContractType ?? partTypeAsGenericTypeDefinition ?? exportSiteType;
                        string contractName = string.IsNullOrEmpty(exportAttribute.ContractName) ? GetContractName(exportedType) : exportAttribute.ContractName !;
                        if (export.Key is TypeInfo && exportAttribute is InheritedExportAttribute)
                        {
                            if (inheritedExportContractNamesFromNonInterfaces.Contains(contractName))
                            {
                                // We already have an export with this contract name on this type (from a more derived type)
                                // using InheritedExportAttribute.
                                continue;
                            }

                            if (!((TypeInfo)export.Key).IsInterface)
                            {
                                inheritedExportContractNamesFromNonInterfaces.Add(contractName);
                            }
                        }

                        var exportMetadata = memberExportMetadata
                                             .Add(CompositionConstants.ExportTypeIdentityMetadataName, ContractNameServices.GetTypeIdentity(exportedType));
                        var exportDefinition = new ExportDefinition(contractName, exportMetadata);
                        exportDefinitions.Add(new KeyValuePair <MemberInfo, ExportDefinition>(export.Key, exportDefinition));
                    }
                }
            }

            MethodInfo?onImportsSatisfied = null;

            if (typeof(IPartImportsSatisfiedNotification).IsAssignableFrom(partType))
            {
                onImportsSatisfied = OnImportsSatisfiedMethodInfo;
            }

            var importingConstructorParameters = ImmutableList.CreateBuilder <ImportDefinitionBinding>();
            var importingCtor = GetImportingConstructor <ImportingConstructorAttribute>(partType, publicOnly: false);

            if (importingCtor != null) // some parts have exports merely for metadata -- they can't be instantiated
            {
                foreach (var parameter in importingCtor.GetParameters())
                {
                    var import = this.CreateImport(parameter);
                    if (import.ImportDefinition.Cardinality == ImportCardinality.ZeroOrMore)
                    {
                        Verify.Operation(PartDiscovery.IsImportManyCollectionTypeCreateable(import), Strings.CollectionMustBePublicAndPublicCtorWhenUsingImportingCtor);
                    }

                    importingConstructorParameters.Add(import);
                }
            }

            var partMetadata = ImmutableDictionary.CreateBuilder <string, object?>();

            foreach (var partMetadataAttribute in partTypeInfo.GetAttributes <PartMetadataAttribute>())
            {
                partMetadata[partMetadataAttribute.Name] = partMetadataAttribute.Value;
            }

            var exportsOnType    = exportDefinitions.Where(kv => kv.Key is TypeInfo).Select(kv => kv.Value).ToArray();
            var exportsOnMembers = (from kv in exportDefinitions
                                    where !(kv.Key is TypeInfo)
                                    group kv.Value by kv.Key into byMember
                                    select byMember).ToDictionary(g => MemberRef.Get(g.Key, this.Resolver), g => (IReadOnlyCollection <ExportDefinition>)g.ToArray());

            var assemblyNamesForMetadataAttributes = ImmutableHashSet.CreateBuilder <AssemblyName>(ByValueEquality.AssemblyName);

            foreach (var export in exportsByMember)
            {
                GetAssemblyNamesFromMetadataAttributes <MetadataAttributeAttribute>(export.Key, assemblyNamesForMetadataAttributes);
            }

            return(new ComposablePartDefinition(
                       TypeRef.Get(partType, this.Resolver),
                       partMetadata.ToImmutable(),
                       exportsOnType,
                       exportsOnMembers,
                       imports.ToImmutable(),
                       partCreationPolicy != CreationPolicy.NonShared ? string.Empty : null,
                       onImportsSatisfied is object?ImmutableList.Create(MethodRef.Get(onImportsSatisfied, this.Resolver)) : ImmutableList <MethodRef> .Empty,
                           MethodRef.Get(importingCtor, this.Resolver),
                           importingCtor != null ? importingConstructorParameters.ToImmutable() : null, // some MEF parts are only for metadata
                           partCreationPolicy,
                           partCreationPolicy != CreationPolicy.NonShared,
                           assemblyNamesForMetadataAttributes));
        }
Esempio n. 36
0
 public InvalidMemberRef(MessageContext ctxt, MemberRef member, string message)
     : base(ctxt, Severity.Warning, "1024")
 {
     Member = member;
     Message = message;
 }
Esempio n. 37
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="field">Field ref</param>
 protected FieldReferenceNode(MemberRef field)
 {
     Debug.Assert(field.IsFieldRef);
     FieldRef = field ?? throw new ArgumentNullException(nameof(field));
 }