/*
    Copyright (C) 2014-2019 de4dot@gmail.com

    This file is part of dnSpy

    dnSpy is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    dnSpy is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with dnSpy.  If not, see <http://www.gnu.org/licenses/>.
*/

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using dnlib.DotNet;

namespace dnSpy.AsmEditor.Compiler {
	sealed class ImportSigComparerOptions {
		public ModuleDef SourceModule { get; }
		public ModuleDef TargetModule { get; }
		public ImportSigComparerOptions(ModuleDef sourceModule, ModuleDef targetModule) {
			SourceModule = sourceModule;
			TargetModule = targetModule;
		}
	}

	sealed class ImportTypeEqualityComparer : IEqualityComparer<TypeDef>, IEqualityComparer<ITypeDefOrRef>, IEqualityComparer<IType>, IEqualityComparer<TypeSig> {
		/*readonly*/ ImportSigComparer comparer;
		public ImportTypeEqualityComparer(ImportSigComparer comparer) => this.comparer = comparer;
		public bool Equals([AllowNull] TypeDef x, [AllowNull] TypeDef y) => comparer.Equals(x, y);
		public int GetHashCode([DisallowNull] TypeDef obj) => comparer.GetHashCode(obj);
		public bool Equals([AllowNull] ITypeDefOrRef x, [AllowNull] ITypeDefOrRef y) => comparer.Equals(x, y);
		public int GetHashCode([DisallowNull] ITypeDefOrRef obj) => comparer.GetHashCode(obj);
		public bool Equals([AllowNull] IType x, [AllowNull] IType y) => comparer.Equals(x, y);
		public int GetHashCode([DisallowNull] IType obj) => comparer.GetHashCode(obj);
		public bool Equals([AllowNull] TypeSig x, [AllowNull] TypeSig y) => comparer.Equals(x, y);
		public int GetHashCode([DisallowNull] TypeSig obj) => comparer.GetHashCode(obj);
	}

	sealed class ImportPropertyEqualityComparer : IEqualityComparer<PropertyDef> {
		/*readonly*/ ImportSigComparer comparer;
		public ImportPropertyEqualityComparer(ImportSigComparer comparer) => this.comparer = comparer;
		public bool Equals([AllowNull] PropertyDef x, [AllowNull] PropertyDef y) => comparer.Equals(x, y);
		public int GetHashCode([DisallowNull] PropertyDef obj) => comparer.GetHashCode(obj);
	}

	sealed class ImportEventEqualityComparer : IEqualityComparer<EventDef> {
		/*readonly*/ ImportSigComparer comparer;
		public ImportEventEqualityComparer(ImportSigComparer comparer) => this.comparer = comparer;
		public bool Equals([AllowNull] EventDef x, [AllowNull] EventDef y) => comparer.Equals(x, y);
		public int GetHashCode([DisallowNull] EventDef obj) => comparer.GetHashCode(obj);
	}

	sealed class ImportMethodEqualityComparer : IEqualityComparer<MethodDef>, IEqualityComparer<MemberRef>, IEqualityComparer<IMethod> {
		/*readonly*/ ImportSigComparer comparer;
		public ImportMethodEqualityComparer(ImportSigComparer comparer) => this.comparer = comparer;
		public bool Equals([AllowNull] MethodDef x, [AllowNull] MethodDef y) => comparer.Equals(x, y);
		public int GetHashCode([DisallowNull] MethodDef obj) => comparer.GetHashCode(obj);
		public bool Equals([AllowNull] MemberRef x, [AllowNull] MemberRef y) => comparer.Equals(x, y);
		public int GetHashCode([DisallowNull] MemberRef obj) => comparer.GetHashCode(obj);
		public bool Equals([AllowNull] IMethod x, [AllowNull] IMethod y) => comparer.Equals(x, y);
		public int GetHashCode([DisallowNull] IMethod obj) => comparer.GetHashCode(obj);
	}

	sealed class ImportFieldEqualityComparer : IEqualityComparer<FieldDef>, IEqualityComparer<MemberRef>, IEqualityComparer<IField> {
		/*readonly*/ ImportSigComparer comparer;
		public ImportFieldEqualityComparer(ImportSigComparer comparer) => this.comparer = comparer;
		public bool Equals([AllowNull] FieldDef x, [AllowNull] FieldDef y) => comparer.Equals(x, y);
		public int GetHashCode([DisallowNull] FieldDef obj) => comparer.GetHashCode(obj);
		public bool Equals([AllowNull] MemberRef x, [AllowNull] MemberRef y) => comparer.Equals(x, y);
		public int GetHashCode([DisallowNull] MemberRef obj) => comparer.GetHashCode(obj);
		public bool Equals([AllowNull] IField x, [AllowNull] IField y) => comparer.Equals(x, y);
		public int GetHashCode([DisallowNull] IField obj) => comparer.GetHashCode(obj);
	}

	// Most code is from dnlib.DotNet.SigComparer
	struct ImportSigComparer {
		const int HASHCODE_MAGIC_GLOBAL_TYPE = 1654396648;
		const int HASHCODE_MAGIC_NESTED_TYPE = -1049070942;
		const int HASHCODE_MAGIC_ET_MODULE = -299744851;
		const int HASHCODE_MAGIC_ET_VALUEARRAY = -674970533;
		const int HASHCODE_MAGIC_ET_GENERICINST = -2050514639;
		const int HASHCODE_MAGIC_ET_VAR = 1288450097;
		const int HASHCODE_MAGIC_ET_MVAR = -990598495;
		const int HASHCODE_MAGIC_ET_ARRAY = -96331531;
		const int HASHCODE_MAGIC_ET_SZARRAY = 871833535;
		const int HASHCODE_MAGIC_ET_BYREF = -634749586;
		const int HASHCODE_MAGIC_ET_PTR = 1976400808;
		const int HASHCODE_MAGIC_ET_SENTINEL = 68439620;

		RecursionCounter recursionCounter;
		SigComparerOptions options;
		readonly ImportSigComparerOptions importOptions;
		readonly ModuleDef sourceModule;

		bool DontCompareTypeScope => (options & SigComparerOptions.DontCompareTypeScope) != 0;
		bool CompareMethodFieldDeclaringType => (options & SigComparerOptions.CompareMethodFieldDeclaringType) != 0;
		bool ComparePropertyDeclaringType => (options & SigComparerOptions.ComparePropertyDeclaringType) != 0;
		bool CompareEventDeclaringType => (options & SigComparerOptions.CompareEventDeclaringType) != 0;
		bool CompareSentinelParams => (options & SigComparerOptions.CompareSentinelParams) != 0;
		bool CompareAssemblyPublicKeyToken => (options & SigComparerOptions.CompareAssemblyPublicKeyToken) != 0;
		bool CompareAssemblyVersion => (options & SigComparerOptions.CompareAssemblyVersion) != 0;
		bool CompareAssemblyLocale => (options & SigComparerOptions.CompareAssemblyLocale) != 0;
		bool TypeRefCanReferenceGlobalType => (options & SigComparerOptions.TypeRefCanReferenceGlobalType) != 0;
		bool DontCompareReturnType => (options & SigComparerOptions.DontCompareReturnType) != 0;
		bool CaseInsensitiveTypeNamespaces => (options & SigComparerOptions.CaseInsensitiveTypeNamespaces) != 0;
		bool CaseInsensitiveTypeNames => (options & SigComparerOptions.CaseInsensitiveTypeNames) != 0;
		bool CaseInsensitiveMethodFieldNames => (options & SigComparerOptions.CaseInsensitiveMethodFieldNames) != 0;
		bool CaseInsensitivePropertyNames => (options & SigComparerOptions.CaseInsensitivePropertyNames) != 0;
		bool CaseInsensitiveEventNames => (options & SigComparerOptions.CaseInsensitiveEventNames) != 0;
		bool PrivateScopeFieldIsComparable => (options & SigComparerOptions.PrivateScopeFieldIsComparable) != 0;
		bool PrivateScopeMethodIsComparable => (options & SigComparerOptions.PrivateScopeMethodIsComparable) != 0;
		bool RawSignatureCompare => (options & SigComparerOptions.RawSignatureCompare) != 0;
		bool IgnoreModifiers => (options & SigComparerOptions.IgnoreModifiers) != 0;
		bool MscorlibIsNotSpecial => (options & SigComparerOptions.MscorlibIsNotSpecial) != 0;

		public ImportSigComparer(ImportSigComparerOptions importOptions, SigComparerOptions options, ModuleDef sourceModule) {
			recursionCounter = new RecursionCounter();
			this.options = options;
			this.importOptions = importOptions ?? throw new ArgumentNullException(nameof(importOptions));
			this.sourceModule = sourceModule;
		}

		int GetHashCode_FnPtr_SystemIntPtr() =>
			GetHashCode_TypeNamespace("System") +
			GetHashCode_TypeName("IntPtr");

		bool Equals_Names(bool caseInsensitive, UTF8String a, UTF8String b) {
			if (caseInsensitive)
				return UTF8String.ToSystemStringOrEmpty(a).Equals(UTF8String.ToSystemStringOrEmpty(b), StringComparison.OrdinalIgnoreCase);
			return UTF8String.Equals(a, b);
		}

		bool Equals_Names(bool caseInsensitive, string a, string b) {
			if (caseInsensitive)
				return (a ?? string.Empty).Equals(b ?? string.Empty, StringComparison.OrdinalIgnoreCase);
			return (a ?? string.Empty) == (b ?? string.Empty);
		}

		int GetHashCode_Name(bool caseInsensitive, string a) {
			if (caseInsensitive)
				return (a ?? string.Empty).ToUpperInvariant().GetHashCode();
			return (a ?? string.Empty).GetHashCode();
		}

		bool Equals_TypeNamespaces(UTF8String a, UTF8String b) => Equals_Names(CaseInsensitiveTypeNamespaces, a, b);

		bool Equals_TypeNamespaces(UTF8String a, string b) => Equals_Names(CaseInsensitiveTypeNamespaces, UTF8String.ToSystemStringOrEmpty(a), b);

		int GetHashCode_TypeNamespace(UTF8String a) => GetHashCode_Name(CaseInsensitiveTypeNamespaces, UTF8String.ToSystemStringOrEmpty(a));

		int GetHashCode_TypeNamespace(string a) => GetHashCode_Name(CaseInsensitiveTypeNamespaces, a);

		bool Equals_TypeNames(UTF8String a, UTF8String b) => Equals_Names(CaseInsensitiveTypeNames, a, b);

		bool Equals_TypeNames(UTF8String a, string b) => Equals_Names(CaseInsensitiveTypeNames, UTF8String.ToSystemStringOrEmpty(a), b);

		int GetHashCode_TypeName(UTF8String a) => GetHashCode_Name(CaseInsensitiveTypeNames, UTF8String.ToSystemStringOrEmpty(a));

		int GetHashCode_TypeName(string a) => GetHashCode_Name(CaseInsensitiveTypeNames, a);

		bool Equals_MethodFieldNames(UTF8String a, UTF8String b) => Equals_Names(CaseInsensitiveMethodFieldNames, a, b);

		bool Equals_MethodFieldNames(UTF8String a, string b) => Equals_Names(CaseInsensitiveMethodFieldNames, UTF8String.ToSystemStringOrEmpty(a), b);

		int GetHashCode_MethodFieldName(UTF8String a) => GetHashCode_Name(CaseInsensitiveMethodFieldNames, UTF8String.ToSystemStringOrEmpty(a));

		int GetHashCode_MethodFieldName(string a) => GetHashCode_Name(CaseInsensitiveMethodFieldNames, a);

		bool Equals_PropertyNames(UTF8String a, UTF8String b) => Equals_Names(CaseInsensitivePropertyNames, a, b);

		bool Equals_PropertyNames(UTF8String a, string b) => Equals_Names(CaseInsensitivePropertyNames, UTF8String.ToSystemStringOrEmpty(a), b);

		int GetHashCode_PropertyName(UTF8String a) => GetHashCode_Name(CaseInsensitivePropertyNames, UTF8String.ToSystemStringOrEmpty(a));

		int GetHashCode_PropertyName(string a) => GetHashCode_Name(CaseInsensitivePropertyNames, a);

		bool Equals_EventNames(UTF8String a, UTF8String b) => Equals_Names(CaseInsensitiveEventNames, a, b);

		bool Equals_EventNames(UTF8String a, string b) => Equals_Names(CaseInsensitiveEventNames, UTF8String.ToSystemStringOrEmpty(a), b);

		int GetHashCode_EventName(UTF8String a) => GetHashCode_Name(CaseInsensitiveEventNames, UTF8String.ToSystemStringOrEmpty(a));

		int GetHashCode_EventName(string a) => GetHashCode_Name(CaseInsensitiveEventNames, a);

		static GenericInstSig? GetGenericInstanceType(IMemberRefParent parent) {
			var ts = parent as TypeSpec;
			if (ts is null)
				return null;
			return ts.TypeSig.RemoveModifiers() as GenericInstSig;
		}

		bool Equals(IAssembly aAsm, IAssembly bAsm, TypeRef b) {
			if (Equals(aAsm, bAsm))
				return true;

			// Could be an exported type. Resolve it and check again.

			var td = b.Resolve(sourceModule);
			return td is not null && Equals(aAsm, td.Module.Assembly);
		}

		bool Equals(IAssembly aAsm, IAssembly bAsm, ExportedType b) {
			if (Equals(aAsm, bAsm))
				return true;

			var td = b.Resolve();
			return td is not null && Equals(aAsm, td.Module.Assembly);
		}

		bool Equals(IAssembly? aAsm, TypeRef a, IAssembly? bAsm, TypeRef b) {
			if (Equals(aAsm, bAsm))
				return true;

			// Could be exported types. Resolve them and check again.

			var tda = a.Resolve(sourceModule);
			var tdb = b.Resolve(sourceModule);
			return tda is not null && tdb is not null && Equals(tda.Module.Assembly, tdb.Module.Assembly);
		}

		bool Equals(IAssembly? aAsm, ExportedType a, IAssembly? bAsm, ExportedType b) {
			if (Equals(aAsm, bAsm))
				return true;

			var tda = a.Resolve();
			var tdb = b.Resolve();
			return tda is not null && tdb is not null && Equals(tda.Module.Assembly, tdb.Module.Assembly);
		}

		bool Equals(IAssembly? aAsm, TypeRef a, IAssembly? bAsm, ExportedType b) {
			if (Equals(aAsm, bAsm))
				return true;

			// Could be an exported type. Resolve it and check again.

			var tda = a.Resolve(sourceModule);
			var tdb = b.Resolve();
			return tda is not null && tdb is not null && Equals(tda.Module.Assembly, tdb.Module.Assembly);
		}

		bool Equals(TypeDef a, IModule bMod, TypeRef b) {
			if (Equals(a.Module, bMod) && Equals(a.DefinitionAssembly, b.DefinitionAssembly))
				return true;

			// Could be an exported type. Resolve it and check again.

			var td = b.Resolve(sourceModule);
			if (td is null)
				return false;
			return Equals(a.Module, td.Module) && Equals(a.DefinitionAssembly, td.DefinitionAssembly);
		}

		bool Equals(TypeDef a, FileDef bFile, ExportedType b) {
			if (Equals(a.Module, bFile) && Equals(a.DefinitionAssembly, b.DefinitionAssembly))
				return true;

			var td = b.Resolve();
			return td is not null && Equals(a.Module, td.Module) && Equals(a.DefinitionAssembly, td.DefinitionAssembly);
		}

		bool TypeDefScopeEquals(TypeDef? a, TypeDef? b) {
			if (a is null || b is null)
				return false;
			return Equals(a.Module, b.Module);
		}

		bool Equals(TypeRef a, IModule? ma, TypeRef b, IModule? mb) {
			if (Equals(ma, mb) && Equals(a.DefinitionAssembly, b.DefinitionAssembly))
				return true;

			// Could be exported types. Resolve them and check again.

			var tda = a.Resolve(sourceModule);
			var tdb = b.Resolve(sourceModule);
			return tda is not null && tdb is not null &&
				Equals(tda.Module, tdb.Module) && Equals(tda.DefinitionAssembly, tdb.DefinitionAssembly);
		}

		bool Equals(TypeRef a, IModule? ma, ExportedType b, FileDef? fb) {
			if (Equals(ma, fb) && Equals(a.DefinitionAssembly, b.DefinitionAssembly))
				return true;

			// Could be an exported type. Resolve it and check again.

			var tda = a.Resolve(sourceModule);
			var tdb = b.Resolve();
			return tda is not null && tdb is not null &&
				Equals(tda.Module, tdb.Module) && Equals(tda.DefinitionAssembly, tdb.DefinitionAssembly);
		}

		public bool Equals(IMemberRef? a, IMemberRef? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result;
			IType? ta, tb;
			IField? fa, fb;
			IMethod? ma, mb;
			PropertyDef? pa, pb;
			EventDef? ea, eb;

			if ((ta = a as IType) is not null && (tb = b as IType) is not null)
				result = Equals(ta, tb);
			else if ((fa = a as IField) is not null && (fb = b as IField) is not null && fa.IsField && fb.IsField)
				result = Equals(fa, fb);
			else if ((ma = a as IMethod) is not null && (mb = b as IMethod) is not null)
				result = Equals(ma, mb);
			else if ((pa = a as PropertyDef) is not null && (pb = b as PropertyDef) is not null)
				result = Equals(pa, pb);
			else if ((ea = a as EventDef) is not null && (eb = b as EventDef) is not null)
				result = Equals(ea, eb);
			else
				result = false;

			recursionCounter.Decrement();
			return result;
		}

		public int GetHashCode(IMemberRef? a) {
			if (a is null)
				return 0;
			if (!recursionCounter.Increment())
				return 0;

			int result;
			IType? ta;
			IField? fa;
			IMethod? ma;
			PropertyDef? pa;
			EventDef? ea;

			if ((ta = a as IType) is not null)
				result = GetHashCode(ta);
			else if ((fa = a as IField) is not null)
				result = GetHashCode(fa);
			else if ((ma = a as IMethod) is not null)
				result = GetHashCode(ma);
			else if ((pa = a as PropertyDef) is not null)
				result = GetHashCode(pa);
			else if ((ea = a as EventDef) is not null)
				result = GetHashCode(ea);
			else
				result = 0;		// Should never be reached

			recursionCounter.Decrement();
			return result;
		}

		public bool Equals(ITypeDefOrRef? a, ITypeDefOrRef? b) => Equals((IType?)a, (IType?)b);

		public int GetHashCode(ITypeDefOrRef? a) => GetHashCode((IType?)a);

		public bool Equals(IType? a, IType? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result;
			TypeDef? tda, tdb;
			TypeRef? tra, trb;
			TypeSpec? tsa, tsb;
			TypeSig? sa, sb;
			ExportedType? eta, etb;

			if ((tda = a as TypeDef) is not null & (tdb = b as TypeDef) is not null)
				result = Equals(tda, tdb);
			else if ((tra = a as TypeRef) is not null & (trb = b as TypeRef) is not null)
				result = Equals(tra, trb);
			else if ((tsa = a as TypeSpec) is not null & (tsb = b as TypeSpec) is not null)
				result = Equals(tsa, tsb);
			else if ((sa = a as TypeSig) is not null & (sb = b as TypeSig) is not null)
				result = Equals(sa, sb);
			else if ((eta = a as ExportedType) is not null & (etb = b as ExportedType) is not null)
				result = Equals(eta, etb);
			else if (tda is not null && trb is not null)
				result = Equals(tda, trb);		// TypeDef vs TypeRef
			else if (tra is not null && tdb is not null)
				result = Equals(tdb, tra);		// TypeDef vs TypeRef
			else if (tda is not null && tsb is not null)
				result = Equals(tda, tsb);		// TypeDef vs TypeSpec
			else if (tsa is not null && tdb is not null)
				result = Equals(tdb, tsa);		// TypeDef vs TypeSpec
			else if (tda is not null && sb is not null)
				result = Equals(tda, sb);		// TypeDef vs TypeSig
			else if (sa is not null && tdb is not null)
				result = Equals(tdb, sa);		// TypeDef vs TypeSig
			else if (tda is not null && etb is not null)
				result = Equals(tda, etb);		// TypeDef vs ExportedType
			else if (eta is not null && tdb is not null)
				result = Equals(tdb, eta);		// TypeDef vs ExportedType
			else if (tra is not null && tsb is not null)
				result = Equals(tra, tsb);		// TypeRef vs TypeSpec
			else if (tsa is not null && trb is not null)
				result = Equals(trb, tsa);		// TypeRef vs TypeSpec
			else if (tra is not null && sb is not null)
				result = Equals(tra, sb);		// TypeRef vs TypeSig
			else if (sa is not null && trb is not null)
				result = Equals(trb, sa);		// TypeRef vs TypeSig
			else if (tra is not null && etb is not null)
				result = Equals(tra, etb);		// TypeRef vs ExportedType
			else if (eta is not null && trb is not null)
				result = Equals(trb, eta);		// TypeRef vs ExportedType
			else if (tsa is not null && sb is not null)
				result = Equals(tsa, sb);		// TypeSpec vs TypeSig
			else if (sa is not null && tsb is not null)
				result = Equals(tsb, sa);		// TypeSpec vs TypeSig
			else if (tsa is not null && etb is not null)
				result = Equals(tsa, etb);		// TypeSpec vs ExportedType
			else if (eta is not null && tsb is not null)
				result = Equals(tsb, eta);		// TypeSpec vs ExportedType
			else if (sa is not null && etb is not null)
				result = Equals(sa, etb);		// TypeSig vs ExportedType
			else if (eta is not null && sb is not null)
				result = Equals(sb, eta);		// TypeSig vs ExportedType
			else
				result = false;	// Should never be reached

			recursionCounter.Decrement();
			return result;
		}

		public int GetHashCode(IType? a) {
			if (a is null)
				return 0;
			if (!recursionCounter.Increment())
				return 0;

			int hash;
			TypeDef? td;
			TypeRef? tr;
			TypeSpec? ts;
			TypeSig? sig;
			ExportedType? et;

			if ((td = a as TypeDef) is not null)
				hash = GetHashCode(td);
			else if ((tr = a as TypeRef) is not null)
				hash = GetHashCode(tr);
			else if ((ts = a as TypeSpec) is not null)
				hash = GetHashCode(ts);
			else if ((sig = a as TypeSig) is not null)
				hash = GetHashCode(sig);
			else if ((et = a as ExportedType) is not null)
				hash = GetHashCode(et);
			else
				hash = 0;	// Should never be reached

			recursionCounter.Decrement();
			return hash;
		}

		public bool Equals(TypeRef? a, TypeDef? b) => Equals(b, a);

		public bool Equals(TypeDef? a, TypeRef? b) {
			if ((object?)a == b)
				return true;	// both are null
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result;
			IModule? bMod;
			AssemblyRef? bAsm;
			TypeRef? dtb;

			var scope = b.ResolutionScope;

			if (!Equals_TypeNames(a.Name, b.Name) || !Equals_TypeNamespaces(a.Namespace, b.Namespace))
				result = false;
			else if ((dtb = scope as TypeRef) is not null)	// nested type
				result = Equals(a.DeclaringType, dtb);	// Compare enclosing types
			else if (a.DeclaringType is not null) {
				// a is nested, b isn't
				result = false;
			}
			else if (DontCompareTypeScope)
				result = true;
			else if ((bMod = scope as IModule) is not null)	// 'b' is defined in the same assembly as 'a'
				result = Equals(a, bMod, b);
			else if ((bAsm = scope as AssemblyRef) is not null) {
				var aMod = a.Module;
				result = aMod is not null && Equals(aMod.Assembly, bAsm, b);
			}
			else {
				result = false;
				//TODO: Handle the case where scope is null
			}

			if (result && !TypeRefCanReferenceGlobalType && a.IsGlobalModuleType)
				result = false;
			recursionCounter.Decrement();
			return result;
		}

		public bool Equals(ExportedType? a, TypeDef? b) => Equals(b, a);

		public bool Equals(TypeDef? a, ExportedType? b) {
			if ((object?)a == b)
				return true;	// both are null
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result;
			ExportedType? dtb;
			FileDef? bFile;
			AssemblyRef? bAsm;

			var scope = b.Implementation;

			if (!Equals_TypeNames(a.Name, b.TypeName) || !Equals_TypeNamespaces(a.Namespace, b.TypeNamespace))
				result = false;
			else if ((dtb = scope as ExportedType) is not null) {	// nested type
				result = Equals(a.DeclaringType, dtb);	// Compare enclosing types
			}
			else if (a.DeclaringType is not null) {
				result = false;	// a is nested, b isn't
			}
			else if (DontCompareTypeScope)
				result = true;
			else {
				if ((bFile = scope as FileDef) is not null)
					result = Equals(a, bFile, b);
				else if ((bAsm = scope as AssemblyRef) is not null) {
					var aMod = a.Module;
					result = aMod is not null && Equals(aMod.Assembly, bAsm, b);
				}
				else
					result = false;
			}

			if (result && !TypeRefCanReferenceGlobalType && a.IsGlobalModuleType)
				result = false;
			recursionCounter.Decrement();
			return result;
		}

		public bool Equals(TypeSpec? a, TypeDef? b) => Equals(b, a);

		public bool Equals(TypeDef? a, TypeSpec? b) {
			if ((object?)a == b)
				return true;	// both are null
			if (a is null || b is null)
				return false;
			return Equals(a, b.TypeSig);
		}

		public bool Equals(TypeSig? a, TypeDef? b) => Equals(b, a);

		public bool Equals(TypeDef? a, TypeSig? b) {
			if ((object?)a == b)
				return true;	// both are null
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;
			bool result;

			if (b is TypeDefOrRefSig b2)
				result = Equals(a, (IType)b2.TypeDefOrRef);
			else if (b is ModifierSig || b is PinnedSig)
				result = Equals(a, b.Next);
			else
				result = false;

			recursionCounter.Decrement();
			return result;
		}

		public bool Equals(TypeSpec? a, TypeRef? b) => Equals(b, a);

		public bool Equals(TypeRef? a, TypeSpec? b) {
			if ((object?)a == b)
				return true;	// both are null
			if (a is null || b is null)
				return false;
			return Equals(a, b.TypeSig);
		}

		public bool Equals(ExportedType? a, TypeRef? b) => Equals(b, a);

		public bool Equals(TypeRef? a, ExportedType? b) {
			if ((object?)a == b)
				return true;	// both are null
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result = Equals_TypeNames(a.Name, b.TypeName) &&
					Equals_TypeNamespaces(a.Namespace, b.TypeNamespace) &&
					EqualsScope(a, b);

			recursionCounter.Decrement();
			return result;
		}

		public bool Equals(TypeSig? a, TypeRef? b) => Equals(b, a);

		public bool Equals(TypeRef? a, TypeSig? b) {
			if ((object?)a == b)
				return true;	// both are null
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;
			bool result;

			if (b is TypeDefOrRefSig b2)
				result = Equals(a, (IType)b2.TypeDefOrRef);
			else if (b is ModifierSig || b is PinnedSig)
				result = Equals(a, b.Next);
			else
				result = false;

			recursionCounter.Decrement();
			return result;
		}

		public bool Equals(TypeSig? a, TypeSpec? b) => Equals(b, a);

		public bool Equals(TypeSpec? a, TypeSig? b) {
			if ((object?)a == b)
				return true;	// both are null
			if (a is null || b is null)
				return false;
			return Equals(a.TypeSig, b);
		}

		public bool Equals(ExportedType? a, TypeSpec? b) => Equals(b, a);

		public bool Equals(TypeSpec? a, ExportedType? b) {
			if ((object?)a == b)
				return true;	// both are null
			if (a is null || b is null)
				return false;
			return Equals(a.TypeSig, b);
		}

		public bool Equals(ExportedType? a, TypeSig? b) => Equals(b, a);

		public bool Equals(TypeSig? a, ExportedType? b) {
			if ((object?)a == b)
				return true;	// both are null
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;
			bool result;

			if (a is TypeDefOrRefSig a2)
				result = Equals(a2.TypeDefOrRef, b);
			else if (a is ModifierSig || a is PinnedSig)
				result = Equals(a.Next, b);
			else
				result = false;

			recursionCounter.Decrement();
			return result;
		}

		int GetHashCodeGlobalType() =>
			// We don't always know the name+namespace of the global type, eg. when it's
			// referenced by a ModuleRef. Use the same hash for all global types.
			HASHCODE_MAGIC_GLOBAL_TYPE;

		public bool Equals(TypeRef? a, TypeRef? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result = Equals_TypeNames(a.Name, b.Name) &&
					Equals_TypeNamespaces(a.Namespace, b.Namespace) &&
					EqualsResolutionScope(a, b);

			recursionCounter.Decrement();
			return result;
		}

		public int GetHashCode(TypeRef? a) {
			if (a is null)
				return TypeRefCanReferenceGlobalType ? GetHashCodeGlobalType() : 0;

			int hash;
			hash = GetHashCode_TypeName(a.Name);
			if (a.ResolutionScope is TypeRef)
				hash += HASHCODE_MAGIC_NESTED_TYPE;
			else
				hash += GetHashCode_TypeNamespace(a.Namespace);
			return hash;
		}

		public bool Equals(ExportedType? a, ExportedType? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result = Equals_TypeNames(a.TypeName, b.TypeName) &&
					Equals_TypeNamespaces(a.TypeNamespace, b.TypeNamespace) &&
					EqualsImplementation(a, b);

			recursionCounter.Decrement();
			return result;
		}

		public int GetHashCode(ExportedType? a) {
			if (a is null)
				return TypeRefCanReferenceGlobalType ? GetHashCodeGlobalType() : 0;
			int hash;
			hash = GetHashCode_TypeName(a.TypeName);
			if (a.Implementation is ExportedType)
				hash += HASHCODE_MAGIC_NESTED_TYPE;
			else
				hash += GetHashCode_TypeNamespace(a.TypeNamespace);
			return hash;
		}

		public bool Equals(TypeDef? a, TypeDef? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result;

			result = Equals_TypeNames(a.Name, b.Name) &&
					Equals_TypeNamespaces(a.Namespace, b.Namespace) &&
					Equals(a.DeclaringType, b.DeclaringType) &&
					(DontCompareTypeScope || TypeDefScopeEquals(a, b));

			recursionCounter.Decrement();
			return result;
		}

		public int GetHashCode(TypeDef? a) {
			if (a is null || a.IsGlobalModuleType)
				return GetHashCodeGlobalType();

			int hash;
			hash = GetHashCode_TypeName(a.Name);
			if (a.DeclaringType is not null)
				hash += HASHCODE_MAGIC_NESTED_TYPE;
			else
				hash += GetHashCode_TypeNamespace(a.Namespace);
			return hash;
		}

		public bool Equals(TypeSpec? a, TypeSpec? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result = Equals(a.TypeSig, b.TypeSig);

			recursionCounter.Decrement();
			return result;
		}

		public int GetHashCode(TypeSpec? a) {
			if (a is null)
				return 0;
			return GetHashCode(a.TypeSig);
		}

		bool EqualsResolutionScope(TypeRef? a, TypeRef? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			var ra = a.ResolutionScope;
			var rb = b.ResolutionScope;
			if (ra == rb)
				return true;
			if (ra is null || rb is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result;
			TypeRef? ea, eb;
			IModule? ma, mb;
			AssemblyRef? aa, ab;
			ModuleDef? modDef;

			// if one of them is a TypeRef, the other one must be too
			if ((ea = ra as TypeRef) is not null | (eb = rb as TypeRef) is not null)
				result = Equals(ea, eb);
			else if (DontCompareTypeScope)
				result = true;
			// only compare if both are modules
			else if ((ma = ra as IModule) is not null & (mb = rb as IModule) is not null)
				result = Equals(a, ma, b, mb);
			// only compare if both are assemblies
			else if ((aa = ra as AssemblyRef) is not null & (ab = rb as AssemblyRef) is not null)
				result = Equals(aa, a, ab, b);
			else if (aa is not null && rb is ModuleRef) {
				var bMod = b.Module;
				result = bMod is not null && Equals(bMod.Assembly, b, aa, a);
			}
			else if (ab is not null && ra is ModuleRef) {
				var aMod = a.Module;
				result = aMod is not null && Equals(aMod.Assembly, a, ab, b);
			}
			else if (aa is not null && (modDef = rb as ModuleDef) is not null)
				result = Equals(modDef.Assembly, aa, a);
			else if (ab is not null && (modDef = ra as ModuleDef) is not null)
				result = Equals(modDef.Assembly, ab, b);
			else
				result = false;

			recursionCounter.Decrement();
			return result;
		}

		bool EqualsImplementation(ExportedType? a, ExportedType? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			var ia = a.Implementation;
			var ib = b.Implementation;
			if (ia == ib)
				return true;
			if (ia is null || ib is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result;
			ExportedType? ea, eb;
			FileDef? fa, fb;
			AssemblyRef? aa, ab;

			// if one of them is an ExportedType, the other one must be too
			if ((ea = ia as ExportedType) is not null | (eb = ib as ExportedType) is not null)
				result = Equals(ea, eb);
			else if (DontCompareTypeScope)
				result = true;
			// only compare if both are files
			else if ((fa = ia as FileDef) is not null & (fb = ib as FileDef) is not null)
				result = Equals(fa, fb);
			// only compare if both are assemblies
			else if ((aa = ia as AssemblyRef) is not null & (ab = ib as AssemblyRef) is not null)
				result = Equals(aa, a, ab, b);
			else if (fa is not null && ab is not null)
				result = Equals(a.DefinitionAssembly, ab, b);
			else if (fb is not null && aa is not null)
				result = Equals(b.DefinitionAssembly, aa, a);
			else
				result = false;

			recursionCounter.Decrement();
			return result;
		}

		bool EqualsScope(TypeRef? a, ExportedType? b) {
			if ((object?)a == b)
				return true;	// both are null
			if (a is null || b is null)
				return false;
			var ra = a.ResolutionScope;
			var ib = b.Implementation;
			if (ra == ib)
				return true;
			if (ra is null || ib is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result;
			TypeRef? ea;
			ExportedType? eb;
			IModule? ma;
			FileDef? fb;
			AssemblyRef? aa, ab;

			// If one is a nested type, the other one must be too
			if ((ea = ra as TypeRef) is not null | (eb = ib as ExportedType) is not null)
				result = Equals(ea, eb);
			else if (DontCompareTypeScope)
				result = true;
			else if ((ma = ra as IModule) is not null & (fb = ib as FileDef) is not null)
				result = Equals(a, ma, b, fb);
			else if ((aa = ra as AssemblyRef) is not null & (ab = ib as AssemblyRef) is not null)
				result = Equals(aa, a, ab, b);
			else if (ma is not null && ab is not null)
				result = Equals(a.DefinitionAssembly, ab, b);
			else if (fb is not null && aa is not null)
				result = Equals(b.DefinitionAssembly, aa, a);
			else
				result = false;

			recursionCounter.Decrement();
			return result;
		}

		bool Equals(FileDef? a, FileDef? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;

			return UTF8String.CaseInsensitiveEquals(a.Name, b.Name);
		}

		bool Equals(IModule? a, FileDef? b) {
			if ((object?)a == b)
				return true;	// both are null
			if (a is null || b is null)
				return false;

			//TODO: You should compare against the module's file name, not the name in the metadata!
			return UTF8String.CaseInsensitiveEquals(a.Name, b.Name);
		}

		internal bool Equals(IModule? a, IModule? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!MscorlibIsNotSpecial && IsCorLib(a) && IsCorLib(b))
				return true;

			return UTF8String.CaseInsensitiveEquals(a.Name, b.Name) || (IsTargetOrSourceModule(a) && IsTargetOrSourceModule(b));
		}

		static bool IsCorLib(ModuleDef? a) => a is not null && a.IsManifestModule && a.Assembly.IsCorLib();

		static bool IsCorLib(IModule? a) {
			var mod = a as ModuleDef;
			return mod is not null && mod.IsManifestModule && mod.Assembly.IsCorLib();
		}

		static bool IsCorLib(IAssembly a) => a.IsCorLib();

		bool Equals(ModuleDef? a, ModuleDef? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!MscorlibIsNotSpecial && IsCorLib(a) && IsCorLib(b))
				return true;
			if (!recursionCounter.Increment())
				return false;

			bool result = Equals((IModule)a, (IModule)b) && Equals(a.Assembly, b.Assembly);

			recursionCounter.Decrement();
			return result;
		}

		bool Equals(IAssembly? a, IAssembly? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!MscorlibIsNotSpecial && IsCorLib(a) && IsCorLib(b))
				return true;
			if (!recursionCounter.Increment())
				return false;

			bool result = UTF8String.CaseInsensitiveEquals(a.Name, b.Name) &&
				(!CompareAssemblyPublicKeyToken || PublicKeyBase.TokenEquals(a.PublicKeyOrToken, b.PublicKeyOrToken)) &&
				(!CompareAssemblyVersion || dnlib_Utils.Equals(a.Version, b.Version)) &&
				(!CompareAssemblyLocale || dnlib_Utils.LocaleEquals(a.Culture, b.Culture));
			if (!result)
				result = IsTargetOrSourceAssembly(a) && IsTargetOrSourceAssembly(b);

			recursionCounter.Decrement();
			return result;
		}

		bool IsTargetOrSourceAssembly(IAssembly? a) => IsTargetAssembly(a) || IsSourceAssembly(a);
		bool IsTargetAssembly(IAssembly? a) => a is not null && __AssemblyEquals(a, importOptions.TargetModule.Assembly);
		bool IsSourceAssembly(IAssembly? a) => a is not null && __AssemblyEquals(a, importOptions.SourceModule.Assembly);
		bool IsTargetOrSourceModule(IModule? a) => IsTargetModule(a) || IsSourceModule(a);
		bool IsTargetModule(IModule? a) => a is not null && __ModuleEquals(a, importOptions.TargetModule);
		bool IsSourceModule(IModule? a) => a is not null && __ModuleEquals(a, importOptions.SourceModule);
		bool __AssemblyEquals(IAssembly? a, AssemblyDef? b) {
			if ((object?)a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (a is AssemblyDef a2)
				return a2 == b;
			return AssemblyNameComparer.CompareAll.Equals(a, b);
		}
		bool __ModuleEquals(IModule? a, ModuleDef? b) {
			if ((object?)a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (a is ModuleDef a2)
				return a2 == b;
			return StringComparer.OrdinalIgnoreCase.Equals(a.Name, b.Name);
		}

		public bool Equals(TypeSig? a, TypeSig? b) {
			if (IgnoreModifiers) {
				a = a.RemoveModifiers();
				b = b.RemoveModifiers();
			}
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;
			bool result;

			if (a.ElementType != b.ElementType) {
				// Signatures must be identical. It's possible to have a U4 in a sig (short form
				// of System.UInt32), or a ValueType + System.UInt32 TypeRef (long form), but these
				// should not match in a sig (also the long form is invalid).
				result = false;
			}
			else {
				switch (a.ElementType) {
				case ElementType.Void:
				case ElementType.Boolean:
				case ElementType.Char:
				case ElementType.I1:
				case ElementType.U1:
				case ElementType.I2:
				case ElementType.U2:
				case ElementType.I4:
				case ElementType.U4:
				case ElementType.I8:
				case ElementType.U8:
				case ElementType.R4:
				case ElementType.R8:
				case ElementType.String:
				case ElementType.TypedByRef:
				case ElementType.I:
				case ElementType.U:
				case ElementType.Object:
				case ElementType.Sentinel:
					result = true;
					break;

				case ElementType.Ptr:
				case ElementType.ByRef:
				case ElementType.SZArray:
				case ElementType.Pinned:
					result = Equals(a.Next, b.Next);
					break;

				case ElementType.Array:
					ArraySig ara = (ArraySig)a, arb = (ArraySig)b;
					result = ara.Rank == arb.Rank &&
							Equals(ara.Sizes, arb.Sizes) &&
							LowerBoundsEquals(ara.LowerBounds, arb.LowerBounds) &&
							Equals(a.Next, b.Next);
					break;

				case ElementType.ValueType:
				case ElementType.Class:
					if (RawSignatureCompare)
						result = TokenEquals(((ClassOrValueTypeSig)a).TypeDefOrRef, ((ClassOrValueTypeSig)b).TypeDefOrRef);
					else
						result = Equals((IType)((ClassOrValueTypeSig)a).TypeDefOrRef, (IType)((ClassOrValueTypeSig)b).TypeDefOrRef);
					break;

				case ElementType.Var:
				case ElementType.MVar:
					result = ((GenericSig)a).Number == ((GenericSig)b).Number;
					break;

				case ElementType.GenericInst:
					var gia = (GenericInstSig)a;
					var gib = (GenericInstSig)b;
					if (RawSignatureCompare) {
						var gt1 = gia.GenericType;
						var gt2 = gib.GenericType;
						result = TokenEquals(gt1 is null ? null : gt1.TypeDefOrRef, gt2 is null ? null : gt2.TypeDefOrRef) &&
								Equals(gia.GenericArguments, gib.GenericArguments);
					}
					else {
						result = Equals(gia.GenericType, gib.GenericType) &&
								Equals(gia.GenericArguments, gib.GenericArguments);
					}
					break;

				case ElementType.FnPtr:
					result = Equals(((FnPtrSig)a).Signature, ((FnPtrSig)b).Signature);
					break;

				case ElementType.CModReqd:
				case ElementType.CModOpt:
					if (RawSignatureCompare)
						result = TokenEquals(((ModifierSig)a).Modifier, ((ModifierSig)b).Modifier) &&
								Equals(a.Next, b.Next);
					else
						result = Equals((IType)((ModifierSig)a).Modifier, (IType)((ModifierSig)b).Modifier) &&
								Equals(a.Next, b.Next);
					break;

				case ElementType.ValueArray:
					result = ((ValueArraySig)a).Size == ((ValueArraySig)b).Size && Equals(a.Next, b.Next);
					break;

				case ElementType.Module:
					result = ((ModuleSig)a).Index == ((ModuleSig)b).Index && Equals(a.Next, b.Next);
					break;

				case ElementType.End:
				case ElementType.R:
				case ElementType.Internal:
				default:
					result = false;
					break;
				}
			}

			recursionCounter.Decrement();
			return result;
		}

		static bool TokenEquals(ITypeDefOrRef? a, ITypeDefOrRef? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			return a.MDToken == b.MDToken;
		}

		public int GetHashCode(TypeSig? a) {
			if (a is null)
				return 0;
			if (!recursionCounter.Increment())
				return 0;
			int hash;

			switch (a.ElementType) {
			case ElementType.Void:
			case ElementType.Boolean:
			case ElementType.Char:
			case ElementType.I1:
			case ElementType.U1:
			case ElementType.I2:
			case ElementType.U2:
			case ElementType.I4:
			case ElementType.U4:
			case ElementType.I8:
			case ElementType.U8:
			case ElementType.R4:
			case ElementType.R8:
			case ElementType.String:
			case ElementType.TypedByRef:
			case ElementType.I:
			case ElementType.U:
			case ElementType.Object:
			case ElementType.ValueType:
			case ElementType.Class:
				// When comparing an ExportedType/TypeDef/TypeRef to a TypeDefOrRefSig/Class/ValueType,
				// the ET is ignored, so we must ignore it when calculating the hash.
				hash = GetHashCode((IType)((TypeDefOrRefSig)a).TypeDefOrRef);
				break;

			case ElementType.Sentinel:
				hash = HASHCODE_MAGIC_ET_SENTINEL;
				break;

			case ElementType.Ptr:
				hash = HASHCODE_MAGIC_ET_PTR + GetHashCode(a.Next);
				break;

			case ElementType.ByRef:
				hash = HASHCODE_MAGIC_ET_BYREF + GetHashCode(a.Next);
				break;

			case ElementType.SZArray:
				hash = HASHCODE_MAGIC_ET_SZARRAY + GetHashCode(a.Next);
				break;

			case ElementType.CModReqd:
			case ElementType.CModOpt:
			case ElementType.Pinned:
				// When comparing an ExportedType/TypeDef/TypeRef to a ModifierSig/PinnedSig,
				// the ET is ignored, so we must ignore it when calculating the hash.
				hash = GetHashCode(a.Next);
				break;

			case ElementType.Array:
				// Don't include sizes and lower bounds since GetHashCode(Type) doesn't (and can't).
				var ara = (ArraySig)a;
				hash = HASHCODE_MAGIC_ET_ARRAY + (int)ara.Rank + GetHashCode(ara.Next);
				break;

			case ElementType.Var:
				hash = HASHCODE_MAGIC_ET_VAR + (int)((GenericVar)a).Number;
				break;

			case ElementType.MVar:
				hash = HASHCODE_MAGIC_ET_MVAR + (int)((GenericMVar)a).Number;
				break;

			case ElementType.GenericInst:
				var gia = (GenericInstSig)a;
				hash = HASHCODE_MAGIC_ET_GENERICINST;
				hash += GetHashCode(gia.GenericType);
				hash += GetHashCode(gia.GenericArguments);
				break;

			case ElementType.FnPtr:
				hash = GetHashCode_FnPtr_SystemIntPtr();
				break;

			case ElementType.ValueArray:
				hash = HASHCODE_MAGIC_ET_VALUEARRAY + (int)((ValueArraySig)a).Size + GetHashCode(a.Next);
				break;

			case ElementType.Module:
				hash = HASHCODE_MAGIC_ET_MODULE + (int)((ModuleSig)a).Index + GetHashCode(a.Next);
				break;

			case ElementType.End:
			case ElementType.R:
			case ElementType.Internal:
			default:
				hash = 0;
				break;
			}

			recursionCounter.Decrement();
			return hash;
		}

		public bool Equals(IList<TypeSig>? a, IList<TypeSig>? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;
			bool result;

			if (a.Count != b.Count)
				result = false;
			else {
				int i;
				for (i = 0; i < a.Count; i++) {
					if (!Equals(a[i], b[i]))
						break;
				}
				result = i == a.Count;
			}

			recursionCounter.Decrement();
			return result;
		}

		public int GetHashCode(IList<TypeSig>? a) {
			if (a is null)
				return 0;
			if (!recursionCounter.Increment())
				return 0;
			uint hash = 0;
			for (int i = 0; i < a.Count; i++) {
				hash += (uint)GetHashCode(a[i]);
				hash = (hash << 13) | (hash >> 19);
			}
			recursionCounter.Decrement();
			return (int)hash;
		}

		bool Equals(IList<uint>? a, IList<uint>? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (a.Count != b.Count)
				return false;
			for (int i = 0; i < a.Count; i++) {
				if (a[i] != b[i])
					return false;
			}
			return true;
		}

		bool LowerBoundsEquals(IList<int>? a, IList<int>? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (a.Count != 0 && b.Count != 0 && a.Count != b.Count)
				return false;
			int count = Math.Max(a.Count, b.Count);
			for (int i = 0; i < count; i++) {
				var ai = i >= a.Count ? 0 : a[i];
				var bi = i >= b.Count ? 0 : b[i];
				if (ai != bi)
					return false;
			}
			return true;
		}

		public bool Equals(CallingConventionSig? a, CallingConventionSig? b) => Equals(a, b, true);

		bool Equals(CallingConventionSig? a, CallingConventionSig? b, bool compareHasThisFlag) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;
			bool result;

			var mask = compareHasThisFlag ? ~(CallingConvention)0 : ~(CallingConvention)0 & ~CallingConvention.HasThis;
			if ((a.GetCallingConvention() & mask) != (b.GetCallingConvention() & mask))
				result = false;
			else {
				switch (a.GetCallingConvention() & CallingConvention.Mask) {
				case CallingConvention.Default:
				case CallingConvention.C:
				case CallingConvention.StdCall:
				case CallingConvention.ThisCall:
				case CallingConvention.FastCall:
				case CallingConvention.VarArg:
				case CallingConvention.Property:
				case CallingConvention.NativeVarArg:
					MethodBaseSig ma = (MethodBaseSig)a, mb = (MethodBaseSig)b;
					result = ma is not null && mb is not null && Equals(ma, mb, compareHasThisFlag);
					break;

				case CallingConvention.Field:
					FieldSig fa = (FieldSig)a, fb = (FieldSig)b;
					result = fa is not null && fb is not null && Equals(fa, fb);
					break;

				case CallingConvention.LocalSig:
					LocalSig la = (LocalSig)a, lb = (LocalSig)b;
					result = la is not null && lb is not null && Equals(la, lb);
					break;

				case CallingConvention.GenericInst:
					GenericInstMethodSig ga = (GenericInstMethodSig)a, gb = (GenericInstMethodSig)b;
					result = ga is not null && gb is not null && Equals(ga, gb);
					break;

				case CallingConvention.Unmanaged:
				default:
					result = false;
					break;
				}
			}

			recursionCounter.Decrement();
			return result;
		}

		public int GetHashCode(CallingConventionSig? a) {
			if (a is null)
				return 0;
			if (!recursionCounter.Increment())
				return 0;
			int hash;

			switch (a.GetCallingConvention() & CallingConvention.Mask) {
			case CallingConvention.Default:
			case CallingConvention.C:
			case CallingConvention.StdCall:
			case CallingConvention.ThisCall:
			case CallingConvention.FastCall:
			case CallingConvention.VarArg:
			case CallingConvention.Property:
			case CallingConvention.NativeVarArg:
				MethodBaseSig? ma = a as MethodBaseSig;
				hash = ma is null ? 0 : GetHashCode(ma);
				break;

			case CallingConvention.Field:
				FieldSig? fa = a as FieldSig;
				hash = fa is null ? 0 : GetHashCode(fa);
				break;

			case CallingConvention.LocalSig:
				LocalSig? la = a as LocalSig;
				hash = la is null ? 0 : GetHashCode(la);
				break;

			case CallingConvention.GenericInst:
				GenericInstMethodSig? ga = a as GenericInstMethodSig;
				hash = ga is null ? 0 : GetHashCode(ga);
				break;

			case CallingConvention.Unmanaged:
			default:
				hash = GetHashCode_CallingConvention(a);
				break;
			}

			recursionCounter.Decrement();
			return hash;
		}

		public bool Equals(MethodBaseSig? a, MethodBaseSig? b) => Equals(a, b, true);

		bool Equals(MethodBaseSig? a, MethodBaseSig? b, bool compareHasThisFlag) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			var mask = compareHasThisFlag ? ~(CallingConvention)0 : ~(CallingConvention)0 & ~CallingConvention.HasThis;
			bool result = (a.GetCallingConvention() & mask) == (b.GetCallingConvention() & mask) &&
					(DontCompareReturnType || Equals(a.RetType, b.RetType)) &&
					Equals(a.Params, b.Params) &&
					(!a.Generic || a.GenParamCount == b.GenParamCount) &&
					(!CompareSentinelParams || Equals(a.ParamsAfterSentinel, b.ParamsAfterSentinel));

			recursionCounter.Decrement();
			return result;
		}

		public int GetHashCode(MethodBaseSig? a) {
			if (a is null)
				return 0;
			if (!recursionCounter.Increment())
				return 0;
			int hash;

			hash = GetHashCode_CallingConvention(a) +
					GetHashCode(a.Params);
			if (!DontCompareReturnType)
				hash += GetHashCode(a.RetType);
			if (a.Generic)
				hash += GetHashCode_ElementType_MVar((int)a.GenParamCount);
			if (CompareSentinelParams)
				hash += GetHashCode(a.ParamsAfterSentinel);

			recursionCounter.Decrement();
			return hash;
		}

		int GetHashCode_CallingConvention(CallingConventionSig a) => GetHashCode(a.GetCallingConvention());

		int GetHashCode(CallingConvention a) {
			switch (a & CallingConvention.Mask) {
			case CallingConvention.Default:
			case CallingConvention.C:
			case CallingConvention.StdCall:
			case CallingConvention.ThisCall:
			case CallingConvention.FastCall:
			case CallingConvention.VarArg:
			case CallingConvention.Property:
			case CallingConvention.GenericInst:
			case CallingConvention.Unmanaged:
			case CallingConvention.NativeVarArg:
			case CallingConvention.Field:
				return (int)(a & (CallingConvention.Generic | CallingConvention.HasThis | CallingConvention.ExplicitThis));

			case CallingConvention.LocalSig:
			default:
				return (int)a;
			}
		}

		public bool Equals(FieldSig? a, FieldSig? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result = a.GetCallingConvention() == b.GetCallingConvention() && Equals(a.Type, b.Type);

			recursionCounter.Decrement();
			return result;
		}

		public int GetHashCode(FieldSig? a) {
			if (a is null)
				return 0;
			if (!recursionCounter.Increment())
				return 0;
			int hash;

			hash = GetHashCode_CallingConvention(a) + GetHashCode(a.Type);

			recursionCounter.Decrement();
			return hash;
		}

		public bool Equals(LocalSig? a, LocalSig? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result = a.GetCallingConvention() == b.GetCallingConvention() && Equals(a.Locals, b.Locals);

			recursionCounter.Decrement();
			return result;
		}

		public int GetHashCode(LocalSig? a) {
			if (a is null)
				return 0;
			if (!recursionCounter.Increment())
				return 0;
			int hash;

			hash = GetHashCode_CallingConvention(a) + GetHashCode(a.Locals);

			recursionCounter.Decrement();
			return hash;
		}

		public bool Equals(GenericInstMethodSig? a, GenericInstMethodSig? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result = a.GetCallingConvention() == b.GetCallingConvention() && Equals(a.GenericArguments, b.GenericArguments);

			recursionCounter.Decrement();
			return result;
		}

		public int GetHashCode(GenericInstMethodSig? a) {
			if (a is null)
				return 0;
			if (!recursionCounter.Increment())
				return 0;
			int hash;

			hash = GetHashCode_CallingConvention(a) + GetHashCode(a.GenericArguments);

			recursionCounter.Decrement();
			return hash;
		}

		public bool Equals(IMethod? a, IMethod? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result;
			MethodDef? mda, mdb;
			MemberRef? mra, mrb;
			MethodSpec? msa, msb;

			if ((mda = a as MethodDef) is not null & (mdb = b as MethodDef) is not null)
				result = Equals(mda, mdb);
			else if ((mra = a as MemberRef) is not null & (mrb = b as MemberRef) is not null)
				result = Equals(mra, mrb);
			else if ((msa = a as MethodSpec) is not null && (msb = b as MethodSpec) is not null)
				result = Equals(msa, msb);
			else if (mda is not null && mrb is not null)
				result = Equals(mda, mrb);
			else if (mra is not null && mdb is not null)
				result = Equals(mdb, mra);
			else
				result = false;

			recursionCounter.Decrement();
			return result;
		}

		public int GetHashCode(IMethod? a) {
			if (a is null)
				return 0;
			if (!recursionCounter.Increment())
				return 0;

			int hash;
			MethodDef? mda;
			MemberRef? mra;
			MethodSpec? msa;

			if ((mda = a as MethodDef) is not null)
				hash = GetHashCode(mda);
			else if ((mra = a as MemberRef) is not null)
				hash = GetHashCode(mra);
			else if ((msa = a as MethodSpec) is not null)
				hash = GetHashCode(msa);
			else
				hash = 0;

			recursionCounter.Decrement();
			return hash;
		}

		public bool Equals(MemberRef? a, MethodDef? b) => Equals(b, a);

		public bool Equals(MethodDef? a, MemberRef? b) {
			if ((object?)a == b)
				return true;	// both are null
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result;
			result = (PrivateScopeMethodIsComparable || !a.IsPrivateScope) &&
					Equals_MethodFieldNames(a.Name, b.Name) &&
					Equals(a.Signature, b.Signature) &&
					(!CompareMethodFieldDeclaringType || Equals(a.DeclaringType, b.Class));

			recursionCounter.Decrement();
			return result;
		}

		public bool Equals(MethodDef? a, MethodDef? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result;
			result = Equals_MethodFieldNames(a.Name, b.Name) &&
					Equals(a.Signature, b.Signature) &&
					(!CompareMethodFieldDeclaringType || Equals(a.DeclaringType, b.DeclaringType));

			recursionCounter.Decrement();
			return result;
		}

		public int GetHashCode(MethodDef? a) {
			if (a is null)
				return 0;

			if (!recursionCounter.Increment())
				return 0;

			int hash = GetHashCode_MethodFieldName(a.Name) +
					GetHashCode(a.Signature);
			if (CompareMethodFieldDeclaringType)
				hash += GetHashCode(a.DeclaringType);

			recursionCounter.Decrement();
			return hash;
		}

		public bool Equals(MemberRef? a, MemberRef? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result = Equals_MethodFieldNames(a.Name, b.Name) &&
					Equals(a.Signature, b.Signature) &&
					(!CompareMethodFieldDeclaringType || Equals(a.Class, b.Class));

			recursionCounter.Decrement();
			return result;
		}

		public int GetHashCode(MemberRef? a) {
			if (a is null)
				return 0;
			if (!recursionCounter.Increment())
				return 0;

			int hash = GetHashCode_MethodFieldName(a.Name);
			hash += GetHashCode(a.Signature);
			if (CompareMethodFieldDeclaringType)
				hash += GetHashCode(a.Class);

			recursionCounter.Decrement();
			return hash;
		}

		public bool Equals(MethodSpec? a, MethodSpec? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result = Equals(a.Method, b.Method) && Equals(a.Instantiation, b.Instantiation);

			recursionCounter.Decrement();
			return result;
		}

		public int GetHashCode(MethodSpec? a) {
			if (a is null)
				return 0;
			if (!recursionCounter.Increment())
				return 0;

			int hash = GetHashCode(a.Method);

			recursionCounter.Decrement();
			return hash;
		}

		bool Equals(IMemberRefParent? a, IMemberRefParent? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result;
			ITypeDefOrRef? ita, itb;
			ModuleRef? moda, modb;
			MethodDef? ma, mb;
			TypeDef? td;

			if ((ita = a as ITypeDefOrRef) is not null && (itb = b as ITypeDefOrRef) is not null)
				result = Equals((IType)ita, (IType)itb);
			else if ((moda = a as ModuleRef) is not null & (modb = b as ModuleRef) is not null) {
				ModuleDef omoda = moda!.Module, omodb = modb!.Module;
				result = Equals((IModule)moda, (IModule)modb) &&
						Equals(omoda is null ? null : omoda.Assembly, omodb is null ? null : omodb.Assembly);
			}
			else if ((ma = a as MethodDef) is not null && (mb = b as MethodDef) is not null)
				result = Equals(ma, mb);
			else if (modb is not null && (td = a as TypeDef) is not null)
				result = EqualsGlobal(td, modb);
			else if (moda is not null && (td = b as TypeDef) is not null)
				result = EqualsGlobal(td, moda);
			else
				result = false;

			recursionCounter.Decrement();
			return result;
		}

		int GetHashCode(IMemberRefParent? a) {
			if (a is null)
				return 0;
			if (!recursionCounter.Increment())
				return 0;

			int hash;
			ITypeDefOrRef? ita;
			MethodDef? ma;

			if ((ita = a as ITypeDefOrRef) is not null)
				hash = GetHashCode((IType)ita);
			else if (a is ModuleRef)
				hash = GetHashCodeGlobalType();
			else if ((ma = a as MethodDef) is not null) {
				// Only use the declaring type so we get the same hash code when hashing a MethodBase.
				hash = GetHashCode(ma.DeclaringType);
			}
			else
				hash = 0;

			recursionCounter.Decrement();
			return hash;
		}

		public bool Equals(IField? a, IField? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result;
			FieldDef? fa, fb;
			MemberRef? ma, mb;

			if ((fa = a as FieldDef) is not null & (fb = b as FieldDef) is not null)
				result = Equals(fa, fb);
			else if ((ma = a as MemberRef) is not null & (mb = b as MemberRef) is not null)
				result = Equals(ma, mb);
			else if (fa is not null && mb is not null)
				result = Equals(fa, mb);
			else if (fb is not null && ma is not null)
				result = Equals(fb, ma);
			else
				result = false;

			recursionCounter.Decrement();
			return result;
		}

		public int GetHashCode(IField? a) {
			if (a is null)
				return 0;
			if (!recursionCounter.Increment())
				return 0;

			int hash;
			FieldDef? fa;
			MemberRef? ma;

			if ((fa = a as FieldDef) is not null)
				hash = GetHashCode(fa);
			else if ((ma = a as MemberRef) is not null)
				hash = GetHashCode(ma);
			else
				hash = 0;

			recursionCounter.Decrement();
			return hash;
		}

		public bool Equals(MemberRef? a, FieldDef? b) => Equals(b, a);

		public bool Equals(FieldDef? a, MemberRef? b) {
			if ((object?)a == b)
				return true;	// both are null
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result = (PrivateScopeFieldIsComparable || !a.IsPrivateScope) &&
					Equals_MethodFieldNames(a.Name, b.Name) &&
					Equals(a.Signature, b.Signature) &&
					(!CompareMethodFieldDeclaringType || Equals(a.DeclaringType, b.Class));

			recursionCounter.Decrement();
			return result;
		}

		public bool Equals(FieldDef? a, FieldDef? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result = Equals_MethodFieldNames(a.Name, b.Name) &&
					Equals(a.Signature, b.Signature) &&
					(!CompareMethodFieldDeclaringType || Equals(a.DeclaringType, b.DeclaringType));

			recursionCounter.Decrement();
			return result;
		}

		public int GetHashCode(FieldDef? a) {
			if (a is null)
				return 0;
			if (!recursionCounter.Increment())
				return 0;

			int hash = GetHashCode_MethodFieldName(a.Name) +
					GetHashCode(a.Signature);
			if (CompareMethodFieldDeclaringType)
				hash += GetHashCode(a.DeclaringType);

			recursionCounter.Decrement();
			return hash;
		}

		public bool Equals(PropertyDef? a, PropertyDef? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result = Equals_PropertyNames(a.Name, b.Name) &&
					// The mcs compiler doesn't set the HasThis flag even if it's an instance property so ignore it
					// when comparing properties.
					Equals(a.Type, b.Type, false) &&
					(!ComparePropertyDeclaringType || Equals(a.DeclaringType, b.DeclaringType));

			recursionCounter.Decrement();
			return result;
		}

		public int GetHashCode(PropertyDef? a) {
			if (a is null)
				return 0;
			if (!recursionCounter.Increment())
				return 0;

			var sig = a.PropertySig;
			int hash = GetHashCode_PropertyName(a.Name) +
					GetHashCode(sig is null ? null : sig.RetType);
			if (ComparePropertyDeclaringType)
				hash += GetHashCode(a.DeclaringType);

			recursionCounter.Decrement();
			return hash;
		}

		public bool Equals(EventDef? a, EventDef? b) {
			if (a == b)
				return true;
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result = Equals_EventNames(a.Name, b.Name) &&
					Equals((IType)a.EventType, (IType)b.EventType) &&
					(!CompareEventDeclaringType || Equals(a.DeclaringType, b.DeclaringType));

			recursionCounter.Decrement();
			return result;
		}

		public int GetHashCode(EventDef? a) {
			if (a is null)
				return 0;
			if (!recursionCounter.Increment())
				return 0;

			int hash = GetHashCode_EventName(a.Name) +
					GetHashCode((IType)a.EventType);
			if (CompareEventDeclaringType)
				hash += GetHashCode(a.DeclaringType);

			recursionCounter.Decrement();
			return hash;
		}

		// Compares a with b, and a must be the global type
		bool EqualsGlobal(TypeDef? a, ModuleRef? b) {
			if ((object?)a == b)
				return true;	// both are null
			if (a is null || b is null)
				return false;
			if (!recursionCounter.Increment())
				return false;

			bool result = a.IsGlobalModuleType &&
				Equals((IModule)a.Module, (IModule)b) &&
				Equals(a.DefinitionAssembly, GetAssembly(b.Module));

			recursionCounter.Decrement();
			return result;
		}

		static AssemblyDef? GetAssembly(ModuleDef? module) => module is null ? null : module.Assembly;

		static int GetHashCode_ElementType_MVar(int numGenericParams) => GetHashCode(numGenericParams, HASHCODE_MAGIC_ET_MVAR);

		static int GetHashCode(int numGenericParams, int etypeHashCode) {
			uint hash = 0;
			for (int i = 0; i < numGenericParams; i++) {
				hash += (uint)(etypeHashCode + i);
				hash = (hash << 13) | (hash >> 19);
			}
			return (int)hash;
		}

		public override string ToString() => $"{recursionCounter} - {options}";
	}

	// From dnlib.DotNet.dnlib_Utils
	static class dnlib_Utils {
		static int CompareTo(Version? a, Version? b) {
			if (a is null)
				a = new Version();
			if (b is null)
				b = new Version();
			if (a.Major != b.Major)
				return a.Major.CompareTo(b.Major);
			if (a.Minor != b.Minor)
				return a.Minor.CompareTo(b.Minor);
			if (GetDefaultVersionValue(a.Build) != GetDefaultVersionValue(b.Build))
				return GetDefaultVersionValue(a.Build).CompareTo(GetDefaultVersionValue(b.Build));
			return GetDefaultVersionValue(a.Revision).CompareTo(GetDefaultVersionValue(b.Revision));
		}

		internal static bool Equals(Version a, Version b) => CompareTo(a, b) == 0;
		static int GetDefaultVersionValue(int val) => val == -1 ? 0 : val;
		static int LocaleCompareTo(UTF8String a, UTF8String b) => GetCanonicalLocale(a).CompareTo(GetCanonicalLocale(b));
		internal static bool LocaleEquals(UTF8String a, UTF8String b) => LocaleCompareTo(a, b) == 0;
		static string GetCanonicalLocale(UTF8String locale) => GetCanonicalLocale(UTF8String.ToSystemStringOrEmpty(locale));

		static string GetCanonicalLocale(string locale) {
			var s = locale.ToUpperInvariant();
			if (s == "NEUTRAL")
				s = string.Empty;
			return s;
		}
	}
}