Debian Codegraph @

external/api-doc-tools/mdoc/Mono.Documentation/Updater/Frameworks/MDocMetadataResolver.cs

raw
1 using System;
2 using Mono.Cecil;
3
4 namespace Mono.Documentation.Updater.Frameworks
5 {
6 public class MDocMetadataResolver : MetadataResolver
7 {
8 public MDocMetadataResolver (CachedResolver r) : base (r) { }
9
10 ReaderParameters parameters = new ReaderParameters ();
11
12 public override TypeDefinition Resolve (TypeReference type)
13 {
14 type = type.GetElementType ();
15
16 var scope = type.Scope;
17
18 if (scope == null)
19 return null;
20
21 CachedResolver assembly_resolver = this.AssemblyResolver as CachedResolver;
22 parameters.AssemblyResolver = assembly_resolver;
23 parameters.MetadataResolver = this;
24
25 try {
26
27 switch (scope.MetadataScopeType)
28 {
29 case MetadataScopeType.AssemblyNameReference:
30 var assembly = assembly_resolver.ResolveCore ((AssemblyNameReference)scope, parameters, type);
31 if (assembly == null)
32 return null;
33
34 return GetType (assembly.MainModule, type);
35 case MetadataScopeType.ModuleDefinition:
36 return GetType ((ModuleDefinition)scope, type);
37 case MetadataScopeType.ModuleReference:
38 var modules = type.Module.Assembly.Modules;
39 var module_ref = (ModuleReference)scope;
40 for (int i = 0; i < modules.Count; i++)
41 {
42 var netmodule = modules[i];
43 if (netmodule.Name == module_ref.Name)
44 return GetType (netmodule, type);
45 }
46 break;
47 }
48 }
49 catch(AssemblyResolutionException are)
50 {
51 throw new MDocException ($"Failed to resolve type '{type.FullName}'", are);
52 }
53 catch
54 {
55 throw;
56 }
57
58 throw new NotSupportedException ($"metadata scope type {scope.MetadataScopeType.ToString("G")} is not supported");
59 }
60 static TypeDefinition GetType (ModuleDefinition module, TypeReference reference)
61 {
62 var type = GetTypeDefinition (module, reference);
63 if (type != null)
64 return type;
65
66 if (!module.HasExportedTypes)
67 return null;
68
69 var exported_types = module.ExportedTypes;
70
71 for (int i = 0; i < exported_types.Count; i++)
72 {
73 var exported_type = exported_types[i];
74 if (exported_type.Name != reference.Name)
75 continue;
76
77 if (exported_type.Namespace != reference.Namespace)
78 continue;
79
80 return exported_type.Resolve ();
81 }
82
83 return null;
84 }
85
86 static TypeDefinition GetTypeDefinition (ModuleDefinition module, TypeReference type)
87 {
88 if (!type.IsNested)
89 return module.GetType (type.Namespace, type.Name);
90
91 var declaring_type = type.DeclaringType.Resolve ();
92 if (declaring_type == null)
93 return null;
94
95 return GetNestedType (declaring_type, TypeFullName(type));
96 }
97
98 public static TypeDefinition GetNestedType (TypeDefinition self, string fullname)
99 {
100 if (!self.HasNestedTypes)
101 return null;
102
103 var nested_types = self.NestedTypes;
104
105 for (int i = 0; i < nested_types.Count; i++)
106 {
107 var nested_type = nested_types[i];
108
109 if (TypeFullName(nested_type) == fullname)
110 return nested_type;
111 }
112
113 return null;
114 }
115 public static string TypeFullName (TypeReference self)
116 {
117 return string.IsNullOrEmpty (self.Namespace)
118 ? self.Name
119 : self.Namespace + '.' + self.Name;
120 }
121 }
122 }