blob: 263615253fa0c3e50f4a9eee8ecf8ca83d82dfad (
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
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using Debug = System.Diagnostics.Debug;
namespace Internal.TypeSystem
{
// Implements generic method canonicalization
partial class InstantiatedMethod
{
/// <summary>
/// Stores a cached version of the canonicalized form of this method since
/// calculating it is a recursive operation
/// </summary>
InstantiatedMethod _specificCanonCache;
InstantiatedMethod _universalCanonCache;
/// <summary>
/// Returns the result of canonicalizing this method over the given kind of Canon
/// </summary>
public override MethodDesc GetCanonMethodTarget(CanonicalFormKind kind)
{
InstantiatedMethod canonicalMethodResult = GetCachedCanonValue(kind);
if (canonicalMethodResult == null)
{
bool instantiationChanged;
Instantiation canonInstantiation = Context.ConvertInstantiationToCanonForm(Instantiation, kind, out instantiationChanged);
MethodDesc openMethodOnCanonicalizedType = _methodDef.GetCanonMethodTarget(kind);
if (instantiationChanged || (openMethodOnCanonicalizedType != _methodDef))
{
canonicalMethodResult = Context.GetInstantiatedMethod(openMethodOnCanonicalizedType, canonInstantiation);
}
else
{
canonicalMethodResult = this;
}
// If the method instantiation is universal, we use a __UniversalCanon for all instantiation arguments for simplicity.
// This is to not end up having method instantiations like Foo<__UniversalCanon>.Method<int> or Foo<__UniversalCanon>.Method<string>
// or Foo<__UniversalCanon>.Method<__Canon> or Foo<int>.Method<__UniversalCanon>
// It should just be Foo<__UniversalCanon>.Method<__UniversalCanon>
if ((kind == CanonicalFormKind.Specific) &&
canonicalMethodResult.IsCanonicalMethod(CanonicalFormKind.Universal))
{
canonicalMethodResult = (InstantiatedMethod)canonicalMethodResult.GetCanonMethodTarget(CanonicalFormKind.Universal);
}
SetCachedCanonValue(kind, canonicalMethodResult);
}
return canonicalMethodResult;
}
InstantiatedMethod GetCachedCanonValue(CanonicalFormKind kind)
{
switch (kind)
{
case CanonicalFormKind.Specific:
return _specificCanonCache;
case CanonicalFormKind.Universal:
return _universalCanonCache;
default:
Debug.Fail("Invalid CanonicalFormKind: " + kind);
return null;
}
}
void SetCachedCanonValue(CanonicalFormKind kind, InstantiatedMethod value)
{
switch (kind)
{
case CanonicalFormKind.Specific:
Debug.Assert(_specificCanonCache == null || _specificCanonCache == value);
_specificCanonCache = value;
break;
case CanonicalFormKind.Universal:
Debug.Assert(_universalCanonCache == null || _universalCanonCache == value);
_universalCanonCache = value;
break;
default:
Debug.Fail("Invalid CanonicalFormKind: " + kind);
break;
}
}
/// <summary>
/// True if either the containing type instantiation or any of this method's generic arguments
/// are canonical
/// </summary>
public override bool IsCanonicalMethod(CanonicalFormKind policy)
{
if (OwningType.HasInstantiation && OwningType.IsCanonicalSubtype(policy))
{
return true;
}
foreach (TypeDesc type in Instantiation)
{
if (type.IsCanonicalSubtype(policy))
{
return true;
}
}
return false;
}
}
}
|
