public override IEnumerable <DependencyListEntry> GetStaticDependencies(NodeFactory factory) { DependencyList dependencies = new DependencyList(); CustomAttributeBasedDependencyAlgorithm.AddDependenciesDueToCustomAttributes(ref dependencies, factory, ((EcmaType)_type)); DefType containingType = _type.ContainingType; if (containingType != null) { dependencies.Add(factory.TypeMetadata((MetadataType)containingType), "Containing type of a reflectable type"); } else { dependencies.Add(factory.ModuleMetadata(_type.Module), "Containing module of a reflectable type"); } if (_type.IsDelegate) { // A delegate type metadata is rather useless without the Invoke method. // If someone reflects on a delegate, chances are they're going to look at the signature. dependencies.Add(factory.MethodMetadata(_type.GetMethod("Invoke", null)), "Delegate invoke method metadata"); } return(dependencies); }
public override IEnumerable <DependencyListEntry> GetStaticDependencies(NodeFactory factory) { DependencyList dependencies = new DependencyList(); CustomAttributeBasedDependencyAlgorithm.AddDependenciesDueToCustomAttributes(ref dependencies, factory, ((EcmaType)_type)); DefType containingType = _type.ContainingType; if (containingType != null) { dependencies.Add(factory.TypeMetadata((MetadataType)containingType), "Containing type of a reflectable type"); } else { dependencies.Add(factory.ModuleMetadata(_type.Module), "Containing module of a reflectable type"); } // TODO: https://github.com/dotnet/corert/issues/3224 // We don't currently track the exact list of fields used - assume all are used foreach (FieldDesc field in _type.GetFields()) { if (factory.MetadataManager.CanGenerateMetadata(field)) { dependencies.Add(factory.FieldMetadata(field), "Field of a reflectable type"); } } return(dependencies); }
public override IEnumerable <DependencyListEntry> GetStaticDependencies(NodeFactory factory) { DependencyList dependencies = new DependencyList(); CustomAttributeBasedDependencyAlgorithm.AddDependenciesDueToCustomAttributes(ref dependencies, factory, ((EcmaType)_type)); DefType containingType = _type.ContainingType; if (containingType != null) { dependencies.Add(factory.TypeMetadata((MetadataType)containingType), "Containing type of a reflectable type"); } else { dependencies.Add(factory.ModuleMetadata(_type.Module), "Containing module of a reflectable type"); } var mdManager = (UsageBasedMetadataManager)factory.MetadataManager; if (_type.IsDelegate) { // A delegate type metadata is rather useless without the Invoke method. // If someone reflects on a delegate, chances are they're going to look at the signature. var invokeMethod = _type.GetMethod("Invoke", null); if (!mdManager.IsReflectionBlocked(invokeMethod)) { dependencies.Add(factory.MethodMetadata(invokeMethod), "Delegate invoke method metadata"); } } if (_type.IsEnum) { // A lot of the enum reflection actually happens on top of the respective EEType (e.g. getting the underlying type), // so for enums also include their EEType. dependencies.Add(factory.MaximallyConstructableType(_type), "Reflectable enum"); } // If the user asked for complete metadata to be generated for all types that are getting metadata, ensure that. if ((mdManager._generationOptions & UsageBasedMetadataGenerationOptions.CompleteTypesOnly) != 0) { foreach (MethodDesc method in _type.GetMethods()) { if (!mdManager.IsReflectionBlocked(method)) { dependencies.Add(factory.MethodMetadata(method), "Complete metadata for type"); } } foreach (FieldDesc field in _type.GetFields()) { if (!mdManager.IsReflectionBlocked(field)) { dependencies.Add(factory.FieldMetadata(field), "Complete metadata for type"); } } } return(dependencies); }
public override IEnumerable <DependencyListEntry> GetStaticDependencies(NodeFactory factory) { DependencyList dependencies = new DependencyList(); dependencies.Add(factory.TypeMetadata((MetadataType)_field.OwningType), "Owning type metadata"); CustomAttributeBasedDependencyAlgorithm.AddDependenciesDueToCustomAttributes(ref dependencies, factory, ((EcmaField)_field)); return(dependencies); }
public override IEnumerable <DependencyListEntry> GetStaticDependencies(NodeFactory factory) { DependencyList dependencies = new DependencyList(); // Global module type always generates metadata because it's really convenient to // have something in an assembly that always generates metadata. dependencies.Add(factory.TypeMetadata(_module.GetGlobalModuleType()), "Global module type"); CustomAttributeBasedDependencyAlgorithm.AddDependenciesDueToCustomAttributes(ref dependencies, factory, (EcmaAssembly)_module); return(dependencies); }
public override IEnumerable <DependencyListEntry> GetStaticDependencies(NodeFactory factory) { DependencyList dependencies = new DependencyList(); CustomAttributeBasedDependencyAlgorithm.AddDependenciesDueToCustomAttributes(ref dependencies, factory, ((EcmaType)_type)); DefType containingType = _type.ContainingType; if (containingType != null) { dependencies.Add(factory.TypeMetadata((MetadataType)containingType), "Containing type of a reflectable type"); } else { dependencies.Add(factory.ModuleMetadata(_type.Module), "Containing module of a reflectable type"); } return(dependencies); }
public override IEnumerable <DependencyListEntry> GetStaticDependencies(NodeFactory factory) { DependencyList dependencies = new DependencyList(); dependencies.Add(factory.TypeMetadata((MetadataType)_method.OwningType), "Owning type metadata"); CustomAttributeBasedDependencyAlgorithm.AddDependenciesDueToCustomAttributes(ref dependencies, factory, ((EcmaMethod)_method)); MethodSignature sig = _method.Signature; const string reason = "Method signature metadata"; TypeMetadataNode.GetMetadataDependencies(ref dependencies, factory, sig.ReturnType, reason); foreach (TypeDesc paramType in sig) { TypeMetadataNode.GetMetadataDependencies(ref dependencies, factory, paramType, reason); } return(dependencies); }
public override IEnumerable <DependencyListEntry> GetStaticDependencies(NodeFactory factory) { DependencyList dependencies = new DependencyList(); CustomAttributeBasedDependencyAlgorithm.AddDependenciesDueToCustomAttributes(ref dependencies, factory, ((EcmaType)_type)); DefType containingType = _type.ContainingType; if (containingType != null) { dependencies.Add(factory.TypeMetadata((MetadataType)containingType), "Containing type of a reflectable type"); } else { dependencies.Add(factory.ModuleMetadata(_type.Module), "Containing module of a reflectable type"); } var mdManager = (UsageBasedMetadataManager)factory.MetadataManager; if (_type.IsDelegate) { // We've decided as a policy that delegate Invoke methods will be generated in full. // The libraries (e.g. System.Linq.Expressions) have trimming warning suppressions // in places where they assume IL-level trimming (where the method cannot be removed). // We ask for a full reflectable method with its method body instead of just the // metadata. var invokeMethod = _type.GetMethod("Invoke", null); if (!mdManager.IsReflectionBlocked(invokeMethod)) { dependencies.Add(factory.ReflectableMethod(invokeMethod), "Delegate invoke method"); } } if (_type.IsEnum) { // A lot of the enum reflection actually happens on top of the respective MethodTable (e.g. getting the underlying type), // so for enums also include their MethodTable. dependencies.Add(factory.MaximallyConstructableType(_type), "Reflectable enum"); // Enums are not useful without their literal fields. The literal fields are not referenced // from anywhere (source code reference to enums compiles to the underlying numerical constants in IL). foreach (FieldDesc enumField in _type.GetFields()) { if (enumField.IsLiteral) { dependencies.Add(factory.FieldMetadata(enumField), "Value of a reflectable enum"); } } } // If the user asked for complete metadata to be generated for all types that are getting metadata, ensure that. if ((mdManager._generationOptions & UsageBasedMetadataGenerationOptions.CompleteTypesOnly) != 0) { foreach (MethodDesc method in _type.GetMethods()) { if (!mdManager.IsReflectionBlocked(method)) { try { // Make sure we're not adding a method to the dependency graph that is going to // cause trouble down the line. This entire type would not actually load on CoreCLR anyway. LibraryRootProvider.CheckCanGenerateMethod(method); } catch (TypeSystemException) { continue; } dependencies.Add(factory.MethodMetadata(method), "Complete metadata for type"); } } foreach (FieldDesc field in _type.GetFields()) { if (!mdManager.IsReflectionBlocked(field)) { dependencies.Add(factory.FieldMetadata(field), "Complete metadata for type"); } } } return(dependencies); }