Initialize the debugger type system asynchronously.

src/AddIns/Debugger/Debugger.Core/Debugger.Core.csproj

@@ -36,8 +36,9 @@
     <IsWebBootstrapper>true</IsWebBootstrapper>
     <UseApplicationTrust>false</UseApplicationTrust>
     <BootstrapperEnabled>true</BootstrapperEnabled>
-    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
-    <TargetFrameworkProfile>Client</TargetFrameworkProfile>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>

src/AddIns/Debugger/Debugger.Core/Module.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Runtime.InteropServices;
+using System.Threading.Tasks;
 using Debugger.Interop;
 using Debugger.Interop.CorDebug;
 using Debugger.Interop.CorSym;
@@ -27,15 +28,15 @@ namespace Debugger
 		ISymUnmanagedReader symReader;
 		MetaDataImport metaData;
 		
-		IUnresolvedAssembly unresolvedAssembly;
+		Task<IUnresolvedAssembly> unresolvedAssembly;
 		internal Dictionary<string, DebugType> LoadedDebugTypes = new Dictionary<string, DebugType>();
 		
 		public IUnresolvedAssembly UnresolvedAssembly {
-			get { return unresolvedAssembly; }
+			get { return unresolvedAssembly.Result; }
 		}
 		
 		public IAssembly Assembly {
-			get { return unresolvedAssembly.Resolve(appDomain.Compilation.TypeResolveContext); }
+			get { return this.UnresolvedAssembly.Resolve(appDomain.Compilation.TypeResolveContext); }
 		}
 		
 		public AppDomain AppDomain {
@@ -194,7 +195,7 @@ namespace Debugger
 			this.process = appDomain.Process;
 			this.corModule = corModule;
 			
-			unresolvedAssembly = TypeSystemExtensions.LoadModule(this, corModule);
+			unresolvedAssembly = TypeSystemExtensions.LoadModuleAsync(this, corModule);
 			metaData = new MetaDataImport(corModule);
 			
 			if (IsDynamic || IsInMemory) {

src/AddIns/Debugger/Debugger.Core/TypeSystemExtensions.cs

@@ -4,12 +4,14 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+
 using Debugger.Interop.CorDebug;
 using Debugger.MetaData;
 using ICSharpCode.NRefactory.TypeSystem;
 using ICSharpCode.NRefactory.TypeSystem.Implementation;
-using Mono.Cecil;
 using Mono.Cecil.Metadata;
 
 namespace Debugger
@@ -33,21 +35,24 @@ namespace Debugger
 			}
 		}
 		
-		internal static IUnresolvedAssembly LoadModule(Module module, ICorDebugModule corModule)
+		internal static Task<IUnresolvedAssembly> LoadModuleAsync(Module module, ICorDebugModule corModule)
 		{
 			string name = corModule.GetName();
 			if (corModule.IsDynamic() == 1 || corModule.IsInMemory() == 1)
-				return new DefaultUnresolvedAssembly(name);
-			CecilLoader loader = new CecilLoader(true);
-			loader.IncludeInternalMembers = true;
-			var asm = loader.LoadAssemblyFile(name);
-			var moduleMetadataInfo = new ModuleMetadataInfo(module);
-			foreach (var typeDef in asm.GetAllTypeDefinitions()) {
-				var cecilTypeDef = loader.GetCecilObject(typeDef);
-				moduleMetadataInfo.MetadataTokens[typeDef] = cecilTypeDef.MetadataToken.ToUInt32();
-			}
-			weakTable.Add(asm, moduleMetadataInfo);
-			return asm;
+				return Task.FromResult<IUnresolvedAssembly>(new DefaultUnresolvedAssembly(name));
+			return Task.Run(
+				delegate {
+					CecilLoader loader = new CecilLoader(true);
+					loader.IncludeInternalMembers = true;
+					var asm = loader.LoadAssemblyFile(name);
+					var moduleMetadataInfo = new ModuleMetadataInfo(module);
+					foreach (var typeDef in asm.GetAllTypeDefinitions()) {
+						var cecilTypeDef = loader.GetCecilObject(typeDef);
+						moduleMetadataInfo.MetadataTokens[typeDef] = cecilTypeDef.MetadataToken.ToUInt32();
+					}
+					weakTable.Add(asm, moduleMetadataInfo);
+					return asm;
+				});
 		}
 		
 		static ModuleMetadataInfo GetInfo(IAssembly assembly)
@@ -66,6 +71,12 @@ namespace Debugger
 		
 		#region IType -> ICorDebugType
 		public static ICorDebugType ToCorDebug(this IType type)
+		{
+			AppDomain appDomain;
+			return ToCorDebug(type, out appDomain);
+		}
+		
+		static ICorDebugType ToCorDebug(IType type, out AppDomain appDomain)
 		{
 			switch (type.Kind) {
 				case TypeKind.Class:
@@ -75,19 +86,33 @@ namespace Debugger
 				case TypeKind.Enum:
 				case TypeKind.Module:
 				case TypeKind.Void:
-					return ConvertTypeDefOrParameterizedType(type);
+					return ConvertTypeDefOrParameterizedType(type, out appDomain);
 				case TypeKind.Array:
+					{
+						var arrayType = (ArrayType)type;
+						var elementType = ToCorDebug(arrayType.ElementType, out appDomain);
+						return appDomain.CorAppDomain2.GetArrayOrPointerType(
+							(uint)(arrayType.Dimensions == 1 ? CorElementType.SZARRAY : CorElementType.ARRAY),
+							(uint)arrayType.Dimensions, elementType);
+					}
 				case TypeKind.Pointer:
 				case TypeKind.ByReference:
-					throw new NotImplementedException();
+					{
+						var pointerType = (TypeWithElementType)type;
+						var elementType = ToCorDebug(pointerType.ElementType, out appDomain);
+						return appDomain.CorAppDomain2.GetArrayOrPointerType(
+							(uint)(type.Kind == TypeKind.Pointer ? CorElementType.PTR : CorElementType.BYREF),
+							0, elementType);
+					}
 				default:
 					throw new System.Exception("Invalid value for TypeKind");
 			}
 		}
 		
-		static ICorDebugType ConvertTypeDefOrParameterizedType(IType type)
+		static ICorDebugType ConvertTypeDefOrParameterizedType(IType type, out AppDomain appDomain)
 		{
 			ITypeDefinition typeDef = type.GetDefinition();
+			appDomain = GetAppDomain(typeDef.Compilation);
 			var info = GetInfo(typeDef.ParentAssembly);
 			uint token = info.MetadataTokens[typeDef.Parts[0]];
 			ICorDebugClass corClass = info.Module.CorModule.GetClassFromToken(token);