1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System;
using System.Collections.Generic;
using ILCompiler.DependencyAnalysisFramework;
using Internal.TypeSystem;
using Debug = System.Diagnostics.Debug;
using EcmaType = Internal.TypeSystem.Ecma.EcmaType;
namespace ILCompiler.DependencyAnalysis
{
/// <summary>
/// Represents a type that has metadata generated in the current compilation.
/// </summary>
/// <remarks>
/// Only expected to be used during ILScanning when scanning for reflection.
/// </remarks>
internal class TypeMetadataNode : DependencyNodeCore<NodeFactory>
{
private readonly MetadataType _type;
public TypeMetadataNode(MetadataType type)
{
Debug.Assert(type.IsTypeDefinition);
_type = type;
}
public MetadataType Type => _type;
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");
}
// If the user asked for complete metadata to be generated for all types that are getting metadata, ensure that.
var mdManager = (UsageBasedMetadataManager)factory.MetadataManager;
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;
}
/// <summary>
/// Decomposes a constructed type into individual <see cref="TypeMetadataNode"/> units that will be needed to
/// express the constructed type in metadata.
/// </summary>
public static void GetMetadataDependencies(ref DependencyList dependencies, NodeFactory nodeFactory, TypeDesc type, string reason)
{
MetadataManager mdManager = nodeFactory.MetadataManager;
switch (type.Category)
{
case TypeFlags.Array:
case TypeFlags.SzArray:
case TypeFlags.ByRef:
case TypeFlags.Pointer:
GetMetadataDependencies(ref dependencies, nodeFactory, ((ParameterizedType)type).ParameterType, reason);
break;
case TypeFlags.FunctionPointer:
throw new NotImplementedException();
default:
Debug.Assert(type.IsDefType);
TypeDesc typeDefinition = type.GetTypeDefinition();
if (typeDefinition != type)
{
if (mdManager.CanGenerateMetadata((MetadataType)typeDefinition))
{
dependencies = dependencies ?? new DependencyList();
dependencies.Add(nodeFactory.TypeMetadata((MetadataType)typeDefinition), reason);
}
foreach (TypeDesc typeArg in type.Instantiation)
{
GetMetadataDependencies(ref dependencies, nodeFactory, typeArg, reason);
}
}
else
{
if (mdManager.CanGenerateMetadata((MetadataType)type))
{
dependencies = dependencies ?? new DependencyList();
dependencies.Add(nodeFactory.TypeMetadata((MetadataType)type), reason);
}
}
break;
}
}
protected override string GetName(NodeFactory factory)
{
return "Reflectable type: " + _type.ToString();
}
protected override void OnMarked(NodeFactory factory)
{
Debug.Assert(!factory.MetadataManager.IsReflectionBlocked(_type));
Debug.Assert(factory.MetadataManager.CanGenerateMetadata(_type));
}
public override bool InterestingForDynamicDependencyAnalysis => false;
public override bool HasDynamicDependencies => false;
public override bool HasConditionalStaticDependencies => false;
public override bool StaticDependenciesAreComputed => true;
public override IEnumerable<CombinedDependencyListEntry> GetConditionalStaticDependencies(NodeFactory factory) => null;
public override IEnumerable<CombinedDependencyListEntry> SearchDynamicDependencies(List<DependencyNodeCore<NodeFactory>> markedNodes, int firstNode, NodeFactory factory) => null;
}
}
|
