/// <summary>
 /// Returns the namespace of a <see cref="ExportedType"/>
 /// </summary>
 /// <param name="exportedType">The <c>ExportedType</c></param>
 /// <param name="isReflection">Set if output should be compatible with reflection</param>
 /// <param name="sb">String builder to use or null</param>
 /// <returns>The namespace</returns>
 public static string Namespace(ExportedType exportedType, bool isReflection, StringBuilder sb)
 {
     return NamespaceSB(exportedType, isReflection, sb).ToString();
 }

		/// <summary>
		/// Returns the assembly where this type is defined
		/// </summary>
		/// <param name="exportedType">The <c>ExportedType</c></param>
		/// <returns>A <see cref="IAssembly"/> or <c>null</c> if none found</returns>
		public static IAssembly DefinitionAssembly(ExportedType exportedType) {
			return new FullNameCreator().GetDefinitionAssembly(exportedType);
		}

		/// <summary>
		/// Gets the scope
		/// </summary>
		/// <param name="exportedType">The <c>ExportedType</c></param>
		/// <returns>The <see cref="IScope"/> or <c>null</c> if none found</returns>
		public static IScope Scope(ExportedType exportedType) {
			return new FullNameCreator().GetScope(exportedType);
		}

		/// <summary>
		/// Returns the full name of a <see cref="ExportedType"/>
		/// </summary>
		/// <param name="exportedType">The <c>ExportedType</c></param>
		/// <param name="isReflection">Set if output should be compatible with reflection</param>
		/// <returns>The full name</returns>
		public static string FullName(ExportedType exportedType, bool isReflection) {
			return FullName(exportedType, isReflection, null);
		}

		/// <summary>
		/// Returns the assembly qualified full name of a <see cref="ExportedType"/>
		/// </summary>
		/// <param name="exportedType">The <c>ExportedType</c></param>
		/// <returns>The assembly qualified full name</returns>
		public static string AssemblyQualifiedName(ExportedType exportedType) {
			return AssemblyQualifiedName(exportedType, null);
		}

		ITypeDefOrRef GetScopeType(ExportedType exportedType) {
			return null;
		}

		ModuleDef GetOwnerModule(ExportedType exportedType) {
			if (exportedType == null)
				return null;
			return exportedType.Module;
		}

 void Find(ExportedType et)
 {
     if (et == null)
         return;
     // The type might've been moved, so always resolve it instead of using DefinitionAssembly
     var td = et.Resolve(assembly.ModuleDefinition);
     if (td == null)
         Find(et.DefinitionAssembly);
     else
         Find(td.DefinitionAssembly ?? et.DefinitionAssembly);
 }

 static ExportedType FindExportedType(AssemblyDef asm, ExportedType et)
 {
     foreach (var mod in asm.Modules.GetSafeEnumerable()) {
         foreach (var et2 in mod.ExportedTypes.GetSafeEnumerable()) {
             if (new SigComparer(SigComparerOptions.DontCompareTypeScope).Equals(et, et2))
                 return et2;
         }
     }
     return null;
 }

 /// <summary>
 /// Returns the full name of a <see cref="ExportedType"/>
 /// </summary>
 /// <param name="exportedType">The <c>ExportedType</c></param>
 /// <param name="isReflection">Set if output should be compatible with reflection</param>
 /// <param name="helper">Helps print the name</param>
 /// <param name="sb">String builder to use or null</param>
 /// <returns>The full name</returns>
 public static string FullName(ExportedType exportedType, bool isReflection, IFullNameCreatorHelper helper, StringBuilder sb)
 {
     return FullNameSB(exportedType, isReflection, helper, sb).ToString();
 }

 /// <summary>
 /// Returns the full name of a <see cref="ExportedType"/>
 /// </summary>
 /// <param name="exportedType">The <c>ExportedType</c></param>
 /// <param name="isReflection">Set if output should be compatible with reflection</param>
 /// <param name="helper">Helps print the name</param>
 /// <param name="sb">String builder to use or null</param>
 /// <returns>The full name</returns>
 public static StringBuilder FullNameSB(ExportedType exportedType, bool isReflection, IFullNameCreatorHelper helper, StringBuilder sb)
 {
     var fnc = new FullNameCreator(isReflection, helper, sb);
     fnc.CreateFullName(exportedType);
     return fnc.sb ?? new StringBuilder();
 }

 /// <summary>
 /// Returns the assembly qualified full name of a <see cref="ExportedType"/>
 /// </summary>
 /// <param name="exportedType">The <c>ExportedType</c></param>
 /// <param name="helper">Helps print the name</param>
 /// <param name="sb">String builder to use or null</param>
 /// <returns>The assembly qualified full name</returns>
 public static StringBuilder AssemblyQualifiedNameSB(ExportedType exportedType, IFullNameCreatorHelper helper, StringBuilder sb)
 {
     var fnc = new FullNameCreator(true, helper, sb);
     fnc.CreateAssemblyQualifiedName(exportedType);
     return fnc.sb ?? new StringBuilder();
 }

 /// <summary>
 /// Returns the assembly qualified full name of a <see cref="ExportedType"/>
 /// </summary>
 /// <param name="exportedType">The <c>ExportedType</c></param>
 /// <param name="helper">Helps print the name</param>
 /// <param name="sb">String builder to use or null</param>
 /// <returns>The assembly qualified full name</returns>
 public static string AssemblyQualifiedName(ExportedType exportedType, IFullNameCreatorHelper helper, StringBuilder sb)
 {
     return AssemblyQualifiedNameSB(exportedType, helper, sb).ToString();
 }

 /// <summary>
 /// Returns the namespace of a <see cref="ExportedType"/>
 /// </summary>
 /// <param name="exportedType">The <c>ExportedType</c></param>
 /// <param name="isReflection">Set if output should be compatible with reflection</param>
 /// <param name="sb">String builder to use or null</param>
 /// <returns>The namespace</returns>
 public static StringBuilder NamespaceSB(ExportedType exportedType, bool isReflection, StringBuilder sb)
 {
     var fnc = new FullNameCreator(isReflection, null, sb);
     fnc.CreateNamespace(exportedType);
     return fnc.sb ?? new StringBuilder();
 }

		void CreateName(ExportedType exportedType) {
			if (exportedType == null) {
				sb.Append(NULLVALUE);
				return;
			}
			AddName(exportedType.TypeName);
		}

        static TypeDef Resolve(ModuleDef sourceModule, ExportedType et)
        {
            for (int i = 0; i < MAX_LOOP_ITERS; i++) {
                if (et == null || et.module == null)
                    break;
                var resolver = et.module.Context.AssemblyResolver;
                var etAsm = resolver.Resolve(et.DefinitionAssembly, sourceModule ?? et.module);
                if (etAsm == null)
                    break;

                var td = etAsm.Find(et.FullName, false);
                if (td != null)
                    return td;

                et = FindExportedType(etAsm, et);
            }

            return null;
        }

		IAssembly GetDefinitionAssembly(ExportedType exportedType) {
			if (exportedType == null)
				return null;
			if (!recursionCounter.Increment())
				return null;
			IAssembly result;
			ExportedType et;
			AssemblyRef asmRef;

			var scope = exportedType.Implementation;
			if ((et = scope as ExportedType) != null)
				result = GetDefinitionAssembly(et);
			else if ((asmRef = scope as AssemblyRef) != null)
				result = asmRef;
			else if (scope is FileDef) {
				var ownerModule = GetOwnerModule(exportedType);
				result = ownerModule == null ? null : ownerModule.Assembly;
			}
			else
				result = null;

			recursionCounter.Decrement();
			return result;
		}

        public static TextTokenKind GetTextTokenType(ExportedType et)
        {
            if (et == null)
                return TextTokenKind.Text;

            return GetTextTokenType(et.ToTypeRef());
        }

		IScope GetScope(ExportedType exportedType) {
			if (exportedType == null)
				return null;
			if (!recursionCounter.Increment())
				return null;
			IScope result;
			ExportedType et;
			AssemblyRef asmRef;
			FileDef file;

			var scope = exportedType.Implementation;
			if ((et = scope as ExportedType) != null)
				result = GetScope(et);
			else if ((asmRef = scope as AssemblyRef) != null)
				result = asmRef;
			else if ((file = scope as FileDef) != null) {
				var ownerModule = GetOwnerModule(exportedType);
				//TODO: Not all modules' names are equal to the name in FileDef.Name
				var modRef = new ModuleRefUser(ownerModule, file.Name);
				if (ownerModule != null)
					ownerModule.UpdateRowId(modRef);
				result = modRef;
			}
			else
				result = null;

			recursionCounter.Decrement();
			return result;
		}

		/// <summary>
		/// Checks whether <paramref name="type"/> contains a <see cref="GenericVar"/> or a
		/// <see cref="GenericMVar"/>.
		/// </summary>
		/// <param name="type">Type</param>
		/// <returns><c>true</c> if <paramref name="type"/> contains a <see cref="GenericVar"/> or a
		/// <see cref="GenericMVar"/>.</returns>
		public static bool ContainsGenericParameter(ExportedType type) {
			return new TypeHelper().ContainsGenericParameterInternal(type);
		}