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);
}
