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
|
using System;
using System.Collections.Generic;
using System.Linq;
using Mono.Cecil;
using Mono.Cecil.Cil;
namespace Mono.Linker {
public static class MethodBodyScanner {
public static IEnumerable<InterfaceImplementation> GetReferencedInterfaces (AnnotationStore annotations, MethodBody body)
{
var possibleStackTypes = AllPossibleStackTypes (body.Method);
if (possibleStackTypes.Count == 0)
return null;
var interfaceTypes = possibleStackTypes.Where (t => t.IsInterface).ToArray ();
if (interfaceTypes.Length == 0)
return null;
var interfaceImplementations = new HashSet<InterfaceImplementation> ();
// If a type could be on the stack in the body and an interface it implements could be on the stack on the body
// then we need to mark that interface implementation. When this occurs it is not safe to remove the interface implementation from the type
// even if the type is never instantiated
foreach (var type in possibleStackTypes) {
// We only sweep interfaces on classes so that's why we only care about classes
if (!type.IsClass)
continue;
AddMatchingInterfaces (interfaceImplementations, type, interfaceTypes);
var bases = annotations.GetClassHierarchy (type);
foreach (var @base in bases) {
AddMatchingInterfaces (interfaceImplementations, @base, interfaceTypes);
}
}
return interfaceImplementations;
}
static HashSet<TypeDefinition> AllPossibleStackTypes (MethodDefinition method)
{
if (!method.HasBody)
throw new ArgumentException();
var body = method.Body;
var types = new HashSet<TypeDefinition> ();
foreach (VariableDefinition var in body.Variables)
AddIfResolved (types, var.VariableType);
foreach (ExceptionHandler eh in body.ExceptionHandlers) {
if (eh.HandlerType == ExceptionHandlerType.Catch) {
AddIfResolved (types, eh.CatchType);
}
}
foreach (Instruction instruction in body.Instructions) {
if (instruction.Operand is FieldReference fieldReference) {
AddIfResolved (types, fieldReference.Resolve ()?.FieldType);
} else if (instruction.Operand is MethodReference methodReference) {
if (methodReference is GenericInstanceMethod genericInstanceMethod)
AddFromGenericInstance (types, genericInstanceMethod);
if (methodReference.DeclaringType is GenericInstanceType genericInstanceType)
AddFromGenericInstance (types, genericInstanceType);
var resolvedMethod = methodReference.Resolve ();
if (resolvedMethod != null) {
if (resolvedMethod.HasParameters) {
foreach (var param in resolvedMethod.Parameters)
AddIfResolved (types, param.ParameterType);
}
AddFromGenericParameterProvider (types, resolvedMethod);
AddFromGenericParameterProvider (types, resolvedMethod.DeclaringType);
AddIfResolved (types, resolvedMethod.ReturnType);
}
}
}
return types;
}
static void AddMatchingInterfaces (HashSet<InterfaceImplementation> results, TypeDefinition type, TypeDefinition [] interfaceTypes)
{
foreach (var interfaceType in interfaceTypes) {
if (type.HasInterface (interfaceType, out InterfaceImplementation implementation))
results.Add (implementation);
}
}
static void AddFromGenericInstance (HashSet<TypeDefinition> set, IGenericInstance instance)
{
if (!instance.HasGenericArguments)
return;
foreach (var genericArgument in instance.GenericArguments)
AddIfResolved (set, genericArgument);
}
static void AddFromGenericParameterProvider (HashSet<TypeDefinition> set, IGenericParameterProvider provider)
{
if (!provider.HasGenericParameters)
return;
foreach (var genericParameter in provider.GenericParameters) {
foreach (var constraint in genericParameter.Constraints)
AddIfResolved (set, constraint);
}
}
static void AddIfResolved (HashSet<TypeDefinition> set, TypeReference item)
{
var resolved = item.Resolve ();
if (resolved == null)
return;
set.Add (resolved);
}
}
}
|
