| 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 |
} |