blob: a163319f28112acd4c19f807377e939655727977 (
plain)
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
// 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.Diagnostics;
using System.Text;
using Internal.NativeFormat;
namespace Internal.TypeSystem
{
public sealed partial class InstantiatedMethod : MethodDesc
{
private MethodDesc _methodDef;
private Instantiation _instantiation;
private MethodSignature _signature;
internal InstantiatedMethod(MethodDesc methodDef, Instantiation instantiation)
{
Debug.Assert(!(methodDef is InstantiatedMethod));
_methodDef = methodDef;
Debug.Assert(instantiation.Length > 0);
_instantiation = instantiation;
}
// This constructor is a performance optimization - it allows supplying the hash code if it has already
// been computed prior to the allocation of this type. The supplied hash code still has to match the
// hash code this type would compute on it's own (and we assert to enforce that).
internal InstantiatedMethod(MethodDesc methodDef, Instantiation instantiation, int hashcode)
: this(methodDef, instantiation)
{
SetHashCode(hashcode);
}
protected override int ComputeHashCode()
{
return TypeHashingAlgorithms.ComputeMethodHashCode(OwningType.GetHashCode(), Instantiation.ComputeGenericInstanceHashCode(TypeHashingAlgorithms.ComputeNameHashCode(Name)));
}
public override TypeSystemContext Context
{
get
{
return _methodDef.Context;
}
}
public override TypeDesc OwningType
{
get
{
return _methodDef.OwningType;
}
}
private TypeDesc Instantiate(TypeDesc type)
{
return type.InstantiateSignature(new Instantiation(), _instantiation);
}
public override MethodSignature Signature
{
get
{
if (_signature == null)
{
MethodSignature template = _methodDef.Signature;
MethodSignatureBuilder builder = new MethodSignatureBuilder(template);
builder.ReturnType = Instantiate(template.ReturnType);
for (int i = 0; i < template.Length; i++)
builder[i] = Instantiate(template[i]);
_signature = builder.ToSignature();
}
return _signature;
}
}
public override Instantiation Instantiation
{
get
{
return _instantiation;
}
}
public override bool IsVirtual
{
get
{
return _methodDef.IsVirtual;
}
}
public override bool IsNewSlot
{
get
{
return _methodDef.IsNewSlot;
}
}
public override bool IsAbstract
{
get
{
return _methodDef.IsAbstract;
}
}
public override bool IsFinal
{
get
{
return _methodDef.IsFinal;
}
}
public override bool HasCustomAttribute(string attributeNamespace, string attributeName)
{
return _methodDef.HasCustomAttribute(attributeNamespace, attributeName);
}
public override MethodDesc GetMethodDefinition()
{
return _methodDef;
}
public override MethodDesc GetTypicalMethodDefinition()
{
return _methodDef.GetTypicalMethodDefinition();
}
public override string Name
{
get
{
return _methodDef.Name;
}
}
public override string ToString()
{
var sb = new StringBuilder(_methodDef.ToString());
sb.Append('<');
sb.Append(_instantiation.ToString());
sb.Append('>');
return sb.ToString();
}
}
}
|
