mcs/tools/corcompare/Util.cs

   1 using System;
   2 using System.Collections.Generic;
   3 using System.Text;
   4 using Mono.Cecil;
   5
   6 namespace Mono.ApiTools {
   7
   8         class TypeHelper {
   9
  10                 public TypeHelper (bool ignoreResolutionErrors, bool ignoreInheritedInterfaces)
  11                 {
  12                         IgnoreResolutionErrors = ignoreResolutionErrors;
  13                         IgnoreInheritedInterfaces = ignoreInheritedInterfaces;
  14                 }
  15
  16                 public bool IgnoreResolutionErrors { get; }
  17
  18                 public bool IgnoreInheritedInterfaces { get; }
  19
  20                 public AssemblyResolver Resolver { get; } = new AssemblyResolver();
  21
  22                 internal bool TryResolve (CustomAttribute attribute)
  23                 {
  24                         if (attribute == null)
  25                                 throw new ArgumentNullException (nameof (attribute));
  26
  27                         try {
  28                                 var has = attribute.HasProperties;
  29                                 return true;
  30                         } catch (AssemblyResolutionException) when (IgnoreResolutionErrors) {
  31                                 return false;
  32                         }
  33                 }
  34
  35                 internal bool IsPublic (TypeReference typeref)
  36                 {
  37                         if (typeref == null)
  38                                 throw new ArgumentNullException ("typeref");
  39
  40                         try {
  41                                 var td = typeref.Resolve ();
  42                                 if (td == null)
  43                                         return false;
  44
  45                                 return td.IsPublic || (td.IsNestedPublic && IsPublic (td.DeclaringType));
  46                         } catch (AssemblyResolutionException) when (IgnoreResolutionErrors) {
  47                                 return true;
  48                         }
  49                 }
  50
  51                 internal bool IsDelegate (TypeReference typeref)
  52                 {
  53                         return IsDerivedFrom (typeref, "System.MulticastDelegate");
  54                 }
  55
  56                 internal bool IsDerivedFrom (TypeReference type, string derivedFrom)
  57                 {
  58                         bool first = true;
  59                         foreach (var def in WalkHierarchy (type)) {
  60                                 if (first) {
  61                                         first = false;
  62                                         continue;
  63                                 }
  64
  65                                 if (def.FullName == derivedFrom)
  66                                         return true;
  67                         }
  68
  69                         return false;
  70                 }
  71
  72                 internal IEnumerable<TypeDefinition> WalkHierarchy (TypeReference type)
  73                 {
  74                         for (var def = type.Resolve (); def != null; def = GetBaseType (def))
  75                                 yield return def;
  76                 }
  77
  78                 internal IEnumerable<TypeReference> GetInterfaces (TypeReference type)
  79                 {
  80                         var ifaces = new Dictionary<string, TypeReference> ();
  81
  82                         foreach (var def in WalkHierarchy (type)) {
  83                                 foreach (var iface in def.Interfaces)
  84                                         ifaces [iface.InterfaceType.FullName] = iface.InterfaceType;
  85                                 if (IgnoreInheritedInterfaces)
  86                                         break;
  87                         }
  88
  89                         return ifaces.Values;
  90                 }
  91
  92                 internal TypeDefinition GetBaseType (TypeDefinition child)
  93                 {
  94                         if (child.BaseType == null)
  95                                 return null;
  96
  97                         try {
  98                                 return child.BaseType.Resolve ();
  99                         } catch (AssemblyResolutionException) when (IgnoreResolutionErrors) {
 100                                 return null;
 101                         }
 102                 }
 103
 104                 internal MethodDefinition GetMethod (MethodReference method)
 105                 {
 106                         if (method == null)
 107                                 throw new ArgumentNullException (nameof (method));
 108
 109                         try {
 110                                 return method.Resolve ();
 111                         } catch (AssemblyResolutionException) when (IgnoreResolutionErrors) {
 112                                 return null;
 113                         }
 114                 }
 115
 116                 internal bool IsPublic (CustomAttribute att)
 117                 {
 118                         return IsPublic (att.AttributeType);
 119                 }
 120
 121                 internal string GetFullName (CustomAttribute att)
 122                 {
 123                         return att.AttributeType.FullName;
 124                 }
 125
 126                 internal TypeDefinition GetTypeDefinition (CustomAttribute att)
 127                 {
 128                         return att.AttributeType.Resolve ();
 129                 }
 130
 131                 bool IsOverride (MethodDefinition method)
 132                 {
 133                         return method.IsVirtual && !method.IsNewSlot;
 134                 }
 135
 136                 public MethodDefinition GetBaseMethodInTypeHierarchy (MethodDefinition method)
 137                 {
 138                         if (!IsOverride (method))
 139                                 return method;
 140
 141                         var @base = GetBaseType (method.DeclaringType);
 142                         while (@base != null) {
 143                                 MethodDefinition base_method = TryMatchMethod (@base.Resolve (), method);
 144                                 if (base_method != null)
 145                                         return GetBaseMethodInTypeHierarchy (base_method) ?? base_method;
 146
 147                                 @base = GetBaseType (@base);
 148                         }
 149
 150                         return method;
 151                 }
 152
 153                 MethodDefinition TryMatchMethod (TypeDefinition type, MethodDefinition method)
 154                 {
 155                         if (!type.HasMethods)
 156                                 return null;
 157
 158                         foreach (MethodDefinition candidate in type.Methods)
 159                                 if (MethodMatch (candidate, method))
 160                                         return candidate;
 161
 162                         return null;
 163                 }
 164
 165                 bool MethodMatch (MethodDefinition candidate, MethodDefinition method)
 166                 {
 167                         if (!candidate.IsVirtual)
 168                                 return false;
 169
 170                         if (candidate.Name != method.Name)
 171                                 return false;
 172
 173                         if (!TypeMatch (candidate.ReturnType, method.ReturnType))
 174                                 return false;
 175
 176                         if (candidate.Parameters.Count != method.Parameters.Count)
 177                                 return false;
 178
 179                         for (int i = 0; i < candidate.Parameters.Count; i++)
 180                                 if (!TypeMatch (candidate.Parameters [i].ParameterType, method.Parameters [i].ParameterType))
 181                                         return false;
 182
 183                         return true;
 184                 }
 185
 186                 public bool TypeMatch (IModifierType a, IModifierType b)
 187                 {
 188                         if (!TypeMatch (a.ModifierType, b.ModifierType))
 189                                 return false;
 190
 191                         return TypeMatch (a.ElementType, b.ElementType);
 192                 }
 193
 194                 public bool TypeMatch (TypeSpecification a, TypeSpecification b)
 195                 {
 196                         if (a is GenericInstanceType)
 197                                 return TypeMatch ((GenericInstanceType) a, (GenericInstanceType) b);
 198
 199                         if (a is IModifierType)
 200                                 return TypeMatch ((IModifierType) a, (IModifierType) b);
 201
 202                         return TypeMatch (a.ElementType, b.ElementType);
 203                 }
 204
 205                 public bool TypeMatch (GenericInstanceType a, GenericInstanceType b)
 206                 {
 207                         if (!TypeMatch (a.ElementType, b.ElementType))
 208                                 return false;
 209
 210                         if (a.GenericArguments.Count != b.GenericArguments.Count)
 211                                 return false;
 212
 213                         if (a.GenericArguments.Count == 0)
 214                                 return true;
 215
 216                         for (int i = 0; i < a.GenericArguments.Count; i++)
 217                                 if (!TypeMatch (a.GenericArguments [i], b.GenericArguments [i]))
 218                                         return false;
 219
 220                         return true;
 221                 }
 222
 223                 public bool TypeMatch (TypeReference a, TypeReference b)
 224                 {
 225                         if (a is GenericParameter)
 226                                 return true;
 227
 228                         if (a is TypeSpecification || b is TypeSpecification) {
 229                                 if (a.GetType () != b.GetType ())
 230                                         return false;
 231
 232                                 return TypeMatch ((TypeSpecification) a, (TypeSpecification) b);
 233                         }
 234
 235                         return a.FullName == b.FullName;
 236                 }
 237         }
 238 }