void AddTestClass(TopLevelTypeName fullName, ITest test)
{
topLevelTestClasses.Add(fullName, test);
TestCollection testNamespace = FindOrCreateNamespace(NestedTestCollection, project.RootNamespace, fullName.Namespace);
testNamespace.Add(test);
}
/// <summary>
/// Finds the top-level-type with the specified name.
/// </summary>
public TypeDefinitionHandle GetTypeDefinition(TopLevelTypeName typeName)
{
var lookup = LazyInit.VolatileRead(ref typeLookup);
if (lookup == null)
{
lookup = new Dictionary <TopLevelTypeName, TypeDefinitionHandle>();
foreach (var handle in Metadata.TypeDefinitions)
{
var td = Metadata.GetTypeDefinition(handle);
if (!td.GetDeclaringType().IsNil)
{
continue; // nested type
}
var nsHandle = td.Namespace;
string ns = nsHandle.IsNil ? string.Empty : Metadata.GetString(nsHandle);
string name = ReflectionHelper.SplitTypeParameterCountFromReflectionName(Metadata.GetString(td.Name), out int typeParameterCount);
lookup[new TopLevelTypeName(ns, name, typeParameterCount)] = handle;
}
lookup = LazyInit.GetOrSet(ref typeLookup, lookup);
}
if (lookup.TryGetValue(typeName, out var resultHandle))
{
return(resultHandle);
}
else
{
return(default);
public static void NavigateTo(FileName assemblyFile, string typeName, string entityIdString)
{
if (assemblyFile == null)
{
throw new ArgumentNullException("assemblyFile");
}
if (string.IsNullOrEmpty(typeName))
{
throw new ArgumentException("typeName is null or empty");
}
var type = new TopLevelTypeName(typeName);
var target = new DecompiledTypeReference(assemblyFile, type);
foreach (var viewContent in SD.Workbench.ViewContentCollection.OfType <DecompiledViewContent>())
{
var viewContentName = viewContent.DecompiledTypeName;
if (viewContentName.AssemblyFile == assemblyFile && type == viewContentName.Type)
{
viewContent.WorkbenchWindow.SelectWindow();
viewContent.JumpToEntity(entityIdString);
return;
}
}
SD.Workbench.ShowView(new DecompiledViewContent(target, entityIdString));
}
public AstType ConvertType(FullTypeName fullTypeName)
{
if (resolver != null)
{
foreach (var asm in resolver.Compilation.Assemblies)
{
var def = asm.GetTypeDefinition(fullTypeName);
if (def != null)
{
return(ConvertType(def));
}
}
}
TopLevelTypeName top = fullTypeName.TopLevelTypeName;
AstType type;
if (string.IsNullOrEmpty(top.Namespace))
{
type = new SimpleType(top.Name);
}
else
{
type = new SimpleType(top.Namespace).MemberType(top.Name);
}
for (int i = 0; i < fullTypeName.NestingLevel; i++)
{
type = type.MemberType(fullTypeName.GetNestedTypeName(i));
}
return(type);
}
/// <summary>
/// Adds/Updates/Removes the test class for the type definition.
/// </summary>
void UpdateType(TopLevelTypeName dirtyTypeDef, ITypeDefinition typeDef)
{
ITest test;
if (topLevelTestClasses.TryGetValue(dirtyTypeDef, out test))
{
if (typeDef == null)
{
// Test class was removed completely (no parts left)
RemoveTestClass(dirtyTypeDef, test);
}
else
{
// Test class was modified
// Check if it's still a test class:
if (IsTestClass(typeDef))
{
UpdateTestClass(test, typeDef);
}
else
{
RemoveTestClass(dirtyTypeDef, test);
}
}
}
else if (typeDef != null)
{
// Test class was added
var testClass = CreateTestClass(typeDef);
if (testClass != null)
{
AddTestClass(dirtyTypeDef, testClass);
}
}
}
protected override void AddToDirtyList(TopLevelTypeName className)
{
// When a base class is invalidated, also invalidate all derived classes
base.AddToDirtyList(className);
foreach (var derivedClass in inheritedTestClasses[className])
{
base.AddToDirtyList(derivedClass.FullTypeName.TopLevelTypeName);
}
}
/// <summary>
/// Adds a type forwarder.
/// This adds both an assembly attribute and an internal forwarder entry, which will be used
/// by the resolved assembly to provide the forwarded types.
/// </summary>
/// <param name="typeName">The name of the type.</param>
/// <param name="referencedType">The reference used to look up the type in the target assembly.</param>
public void AddTypeForwarder(TopLevelTypeName typeName, ITypeReference referencedType)
{
if (referencedType == null)
{
throw new ArgumentNullException("referencedType");
}
FreezableHelper.ThrowIfFrozen(this);
typeForwarders[typeName] = referencedType;
}
public ITypeDefinition GetTypeDefinition(TopLevelTypeName topLevelTypeName)
{
foreach (var typeDef in typeDefinitions)
{
if (typeDef != null && typeDef.FullTypeName == topLevelTypeName)
{
return(typeDef);
}
}
return(null);
}
IType SearchType(KnownTypeCode typeCode)
{
KnownTypeReference typeRef = KnownTypeReference.Get(typeCode);
if (typeRef == null)
return SpecialType.UnknownType;
var typeName = new TopLevelTypeName(typeRef.Namespace, typeRef.Name, typeRef.TypeParameterCount);
foreach (IAssembly asm in compilation.Assemblies) {
var typeDef = asm.GetTypeDefinition(typeName);
if (typeDef != null)
return typeDef;
}
return new UnknownType(typeName);
}
public ITypeDefinitionModel this[TopLevelTypeName topLevelName] {
get {
TypeDefinitionModel model;
if (dict.TryGetValue(topLevelName, out model))
{
return(model);
}
else
{
return(null);
}
}
}
public ITypeDefinition GetTypeDefinition(TopLevelTypeName topLevelTypeName)
{
ITypeDefinition def;
if (GetTypes().TryGetValue(topLevelTypeName, out def))
{
return(def);
}
else
{
return(null);
}
}
/// <summary>
/// Adds a type forwarder.
/// This adds both an assembly attribute and an internal forwarder entry, which will be used
/// by the resolved assembly to provide the forwarded types.
/// </summary>
/// <param name="typeName">The name of the type.</param>
/// <param name="referencedType">The reference used to look up the type in the target assembly.</param>
public void AddTypeForwarder(TopLevelTypeName typeName, ITypeReference referencedType)
{
if (referencedType == null)
{
throw new ArgumentNullException("referencedType");
}
FreezableHelper.ThrowIfFrozen(this);
var attribute = new DefaultUnresolvedAttribute(typeForwardedToAttributeTypeRef, new[] { KnownTypeReference.Type });
attribute.PositionalArguments.Add(new TypeOfConstantValue(referencedType));
assemblyAttributes.Add(attribute);
typeForwarders[typeName] = referencedType;
}
ITypeDefinition INamespace.GetTypeDefinition(string name, int typeParameterCount)
{
var key = new TopLevelTypeName(ns.FullName, name, typeParameterCount);
IUnresolvedTypeDefinition unresolvedTypeDef;
if (assembly.unresolvedTypeDict.TryGetValue(key, out unresolvedTypeDef))
{
return(assembly.GetTypeDefinition(unresolvedTypeDef));
}
else
{
return(null);
}
}
public IUnresolvedTypeDefinition GetTypeDefinition(string ns, string name, int typeParameterCount)
{
var key = new TopLevelTypeName(ns ?? string.Empty, name, typeParameterCount);
IUnresolvedTypeDefinition td;
if (typeDefinitions.TryGetValue(key, out td))
{
return(td);
}
else
{
return(null);
}
}
IType SearchType(BVEPrimitiveTypeCode typeCode)
{
var type_ref = PrimitiveTypeReference.Get(typeCode);
if(type_ref == null)
return SpecialType.UnknownType;
var type_name = new TopLevelTypeName(type_ref.Namespace, type_ref.Name, 0);
foreach(var asm in compilation.Assemblies){
var type_def = asm.GetTypeDefinition(type_name);
if(type_def != null)
return type_def;
}
return new UnknownType(type_name);
}
/// <summary>
/// Adds a new top-level type definition to this assembly.
/// </summary>
/// <remarks>DefaultUnresolvedAssembly does not support partial classes.
/// Adding more than one part of a type will cause an ArgumentException.</remarks>
public void AddTypeDefinition(IUnresolvedTypeDefinition typeDefinition)
{
if (typeDefinition == null)
{
throw new ArgumentNullException("typeDefinition");
}
if (typeDefinition.DeclaringTypeDefinition != null)
{
throw new ArgumentException("Cannot add nested types.");
}
FreezableHelper.ThrowIfFrozen(this);
var key = new TopLevelTypeName(typeDefinition.Namespace, typeDefinition.Name, typeDefinition.TypeParameters.Count);
typeDefinitions.Add(key, typeDefinition);
}
ITypeDefinition GetTypeDefinition(string name)
{
ICompilation compilation = project.GetCompilationUnit();
var typeName = new TopLevelTypeName(name);
foreach (IAssembly assembly in compilation.Assemblies)
{
ITypeDefinition typeDefinition = assembly.GetTypeDefinition(typeName);
if (typeDefinition != null)
{
return(typeDefinition);
}
}
return(null);
}
static IEntity GetEntity(ICompilation compilation, string className, string memberName)
{
var typeName = new TopLevelTypeName(className);
ITypeDefinition type = compilation.MainAssembly.GetTypeDefinition(typeName);
if (type != null) {
if (string.IsNullOrEmpty(memberName))
return type;
IMember m = GetMember(type, memberName);
if (m != null)
return m;
return type;
}
return null;
}
void RemoveTestClass(TopLevelTypeName fullName, ITest test)
{
topLevelTestClasses.Remove(fullName);
TestCollection testNamespace = FindNamespace(NestedTestCollection, project.RootNamespace, fullName.Namespace);
if (testNamespace != null)
{
testNamespace.Remove(test);
if (testNamespace.Count == 0)
{
// Remove the namespace
RemoveTestNamespace(NestedTestCollection, project.RootNamespace, fullName.Namespace);
}
}
OnTestClassRemoved(test);
}
public ITypeDefinition GetTypeDefinition(TopLevelTypeName topLevelTypeName)
{
IUnresolvedTypeDefinition td;
ITypeReference typeRef;
if (unresolvedAssembly.typeDefinitions.TryGetValue(topLevelTypeName, out td))
{
return(GetTypeDefinition(td));
}
else if (unresolvedAssembly.typeForwarders.TryGetValue(topLevelTypeName, out typeRef))
{
return(typeRef.Resolve(compilation.TypeResolveContext).GetDefinition());
}
else
{
return(null);
}
}
public static void NavigateTo(FileName assemblyFile, string typeName, string entityIdString)
{
if (assemblyFile == null)
throw new ArgumentNullException("assemblyFile");
if (string.IsNullOrEmpty(typeName))
throw new ArgumentException("typeName is null or empty");
var type = new TopLevelTypeName(typeName);
var target = new DecompiledTypeReference(assemblyFile, type);
foreach (var viewContent in SD.Workbench.ViewContentCollection.OfType<DecompiledViewContent>()) {
var viewContentName = viewContent.DecompiledTypeName;
if (viewContentName.AssemblyFile == assemblyFile && type == viewContentName.Type) {
viewContent.WorkbenchWindow.SelectWindow();
viewContent.JumpToEntity(entityIdString);
return;
}
}
SD.Workbench.ShowView(new DecompiledViewContent(target, entityIdString));
}
IType SearchType(KnownTypeCode typeCode)
{
KnownTypeReference typeRef = KnownTypeReference.Get(typeCode);
if (typeRef == null)
{
return(SpecialType.UnknownType);
}
var typeName = new TopLevelTypeName(typeRef.Namespace, typeRef.Name, typeRef.TypeParameterCount);
foreach (IAssembly asm in compilation.Assemblies)
{
var typeDef = asm.GetTypeDefinition(typeName);
if (typeDef != null)
{
return(typeDef);
}
}
return(new UnknownType(typeName));
}
ITypeDefinition INamespace.GetTypeDefinition(string name, int typeParameterCount)
{
var key = new TopLevelTypeName(fullName, name, typeParameterCount);
if (types != null)
{
ITypeDefinition typeDef;
if (types.TryGetValue(key, out typeDef))
{
return(typeDef);
}
else
{
return(null);
}
}
else
{
return(assembly.GetTypeDefinition(key));
}
}
public ITypeDefinition GetTypeDefinition(TopLevelTypeName topLevelTypeName)
{
IUnresolvedTypeDefinition td;
ITypeReference typeRef;
if (unresolvedAssembly.typeDefinitions.TryGetValue(topLevelTypeName, out td))
{
return(GetTypeDefinition(td));
}
if (unresolvedAssembly.typeForwarders.TryGetValue(topLevelTypeName, out typeRef))
{
// Protect against cyclic type forwarders:
using (var busyLock = BusyManager.Enter(typeRef)) {
if (busyLock.Success)
{
return(typeRef.Resolve(compilation.TypeResolveContext).GetDefinition());
}
}
}
return(null);
}
static IEntity GetEntity(ICompilation compilation, string className, string memberName)
{
var typeName = new TopLevelTypeName(className);
ITypeDefinition type = compilation.MainAssembly.GetTypeDefinition(typeName);
if (type != null)
{
if (string.IsNullOrEmpty(memberName))
{
return(type);
}
IMember m = GetMember(type, memberName);
if (m != null)
{
return(m);
}
return(type);
}
return(null);
}
/// <summary>
/// Resolves the type reference within the context of the given PE file.
/// </summary>
/// <returns>Either TypeDefinitionHandle, if the type is defined in the module or ExportedTypeHandle,
/// if the module contains a type forwarder. Returns a nil handle, if the type was not found.</returns>
public EntityHandle ResolveInPEFile(PEFile module)
{
string[] parts = typeName.Split('.');
for (int i = parts.Length - 1; i >= 0; i--)
{
string ns = string.Join(".", parts, 0, i);
string name = parts[i];
int topLevelTPC = (i == parts.Length - 1 ? typeParameterCount : 0);
var topLevelName = new TopLevelTypeName(ns, name, topLevelTPC);
var typeHandle = module.GetTypeDefinition(topLevelName);
for (int j = i + 1; j < parts.Length && !typeHandle.IsNil; j++)
{
int tpc = (j == parts.Length - 1 ? typeParameterCount : 0);
var typeDef = module.Metadata.GetTypeDefinition(typeHandle);
string lookupName = parts[j] + (tpc > 0 ? "`" + tpc : "");
typeHandle = typeDef.GetNestedTypes().FirstOrDefault(n => IsEqualShortName(n, module.Metadata, lookupName));
}
if (!typeHandle.IsNil)
{
return(typeHandle);
}
FullTypeName typeName = topLevelName;
for (int j = i + 1; j < parts.Length; j++)
{
int tpc = (j == parts.Length - 1 ? typeParameterCount : 0);
typeName = typeName.NestedType(parts[j], tpc);
}
var exportedType = module.GetTypeForwarder(typeName);
if (!exportedType.IsNil)
{
return(exportedType);
}
}
return(default);
ITypeDefinition GetBuiltinTypeDefinition(string typeName)
{
var type_name = new TopLevelTypeName("global", typeName);
foreach(var asm in compilation.Assemblies){
var type_def = asm.GetTypeDefinition(type_name);
if(type_def != null)
return type_def;
}
return null;
}
public BamlDecompilerTypeSystem(PEFile mainModule, IAssemblyResolver assemblyResolver)
{
if (mainModule == null)
{
throw new ArgumentNullException(nameof(mainModule));
}
if (assemblyResolver == null)
{
throw new ArgumentNullException(nameof(assemblyResolver));
}
// Load referenced assemblies and type-forwarder references.
// This is necessary to make .NET Core/PCL binaries work better.
var referencedAssemblies = new List <PEFile>();
var assemblyReferenceQueue = new Queue <(bool IsAssembly, PEFile MainModule, object Reference)>();
var mainMetadata = mainModule.Metadata;
foreach (var h in mainMetadata.GetModuleReferences())
{
var moduleRef = mainMetadata.GetModuleReference(h);
var moduleName = mainMetadata.GetString(moduleRef.Name);
foreach (var fileHandle in mainMetadata.AssemblyFiles)
{
var file = mainMetadata.GetAssemblyFile(fileHandle);
if (mainMetadata.StringComparer.Equals(file.Name, moduleName) && file.ContainsMetadata)
{
assemblyReferenceQueue.Enqueue((false, mainModule, moduleName));
break;
}
}
}
foreach (var refs in mainModule.AssemblyReferences)
{
assemblyReferenceQueue.Enqueue((true, mainModule, refs));
}
foreach (var bamlReference in defaultBamlReferences)
{
assemblyReferenceQueue.Enqueue((true, mainModule, AssemblyNameReference.Parse(bamlReference)));
}
var comparer = KeyComparer.Create(((bool IsAssembly, PEFile MainModule, object Reference)reference) =>
reference.IsAssembly ? "A:" + ((IAssemblyReference)reference.Reference).FullName :
"M:" + reference.Reference);
var processedAssemblyReferences = new HashSet <(bool IsAssembly, PEFile Parent, object Reference)>(comparer);
while (assemblyReferenceQueue.Count > 0)
{
var asmRef = assemblyReferenceQueue.Dequeue();
if (!processedAssemblyReferences.Add(asmRef))
{
continue;
}
PEFile asm;
if (asmRef.IsAssembly)
{
asm = assemblyResolver.Resolve((IAssemblyReference)asmRef.Reference);
}
else
{
asm = assemblyResolver.ResolveModule(asmRef.MainModule, (string)asmRef.Reference);
}
if (asm != null)
{
referencedAssemblies.Add(asm);
var metadata = asm.Metadata;
foreach (var h in metadata.ExportedTypes)
{
var exportedType = metadata.GetExportedType(h);
switch (exportedType.Implementation.Kind)
{
case SRM.HandleKind.AssemblyReference:
assemblyReferenceQueue.Enqueue((true, asm, new AssemblyReference(asm, (SRM.AssemblyReferenceHandle)exportedType.Implementation)));
break;
case SRM.HandleKind.AssemblyFile:
var file = metadata.GetAssemblyFile((SRM.AssemblyFileHandle)exportedType.Implementation);
assemblyReferenceQueue.Enqueue((false, asm, metadata.GetString(file.Name)));
break;
}
}
}
}
var mainModuleWithOptions = mainModule.WithOptions(TypeSystemOptions.Default);
var referencedAssembliesWithOptions = referencedAssemblies.Select(file => file.WithOptions(TypeSystemOptions.Default));
// Primitive types are necessary to avoid assertions in ILReader.
// Fallback to MinimalCorlib to provide the primitive types.
if (!HasType(KnownTypeCode.Void) || !HasType(KnownTypeCode.Int32))
{
Init(mainModule.WithOptions(TypeSystemOptions.Default), referencedAssembliesWithOptions.Concat(new[] { MinimalCorlib.Instance }));
}
else
{
Init(mainModuleWithOptions, referencedAssembliesWithOptions);
}
this.MainModule = (MetadataModule)base.MainModule;
bool HasType(KnownTypeCode code)
{
TopLevelTypeName name = KnownTypeReference.Get(code).TypeName;
if (mainModule.GetTypeDefinition(name) != null)
{
return(true);
}
foreach (var file in referencedAssemblies)
{
if (file.GetTypeDefinition(name) != null)
{
return(true);
}
}
return(false);
}
}
ITypeDefinition INamespace.GetTypeDefinition(string name, int typeParameterCount)
{
var key = new TopLevelTypeName(fullName, name, typeParameterCount);
if (types != null) {
ITypeDefinition typeDef;
if (types.TryGetValue(key, out typeDef))
return typeDef;
else
return null;
} else {
return assembly.GetTypeDefinition(key);
}
}
protected override void AddToDirtyList(TopLevelTypeName className)
{
// When a base class is invalidated, also invalidate all derived classes
base.AddToDirtyList(className);
foreach (var derivedClass in inheritedTestClasses[className]) {
base.AddToDirtyList(derivedClass.FullTypeName.TopLevelTypeName);
}
}
public ITypeDefinition GetTypeDefinition(TopLevelTypeName topLevelTypeName)
{
IUnresolvedTypeDefinition td;
ITypeReference typeRef;
if (unresolvedAssembly.typeDefinitions.TryGetValue(topLevelTypeName, out td))
return GetTypeDefinition(td);
else if (unresolvedAssembly.typeForwarders.TryGetValue(topLevelTypeName, out typeRef))
return typeRef.Resolve(compilation.TypeResolveContext).GetDefinition();
else
return null;
}
/// <summary>
/// Adds a new top-level type definition to this assembly.
/// </summary>
/// <remarks>DefaultUnresolvedAssembly does not support partial classes.
/// Adding more than one part of a type will cause an ArgumentException.</remarks>
public void AddTypeDefinition(IUnresolvedTypeDefinition typeDefinition)
{
if (typeDefinition == null)
throw new ArgumentNullException("typeDefinition");
if (typeDefinition.DeclaringTypeDefinition != null)
throw new ArgumentException("Cannot add nested types.");
FreezableHelper.ThrowIfFrozen(this);
var key = new TopLevelTypeName(typeDefinition.Namespace, typeDefinition.Name, typeDefinition.TypeParameters.Count);
typeDefinitions.Add(key, typeDefinition);
}
void RemoveTestClass(TopLevelTypeName fullName, ITest test)
{
topLevelTestClasses.Remove(fullName);
TestCollection testNamespace = FindNamespace(NestedTestCollection, project.RootNamespace, fullName.Namespace);
if (testNamespace != null) {
testNamespace.Remove(test);
if (testNamespace.Count == 0) {
// Remove the namespace
RemoveTestNamespace(NestedTestCollection, project.RootNamespace, fullName.Namespace);
}
}
OnTestClassRemoved(test);
}
void AddTestClass(TopLevelTypeName fullName, ITest test)
{
topLevelTestClasses.Add(fullName, test);
TestCollection testNamespace = FindOrCreateNamespace(NestedTestCollection, project.RootNamespace, fullName.Namespace);
testNamespace.Add(test);
}
protected ITest GetTestClass(TopLevelTypeName fullName)
{
EnsureNestedTestsInitialized();
return topLevelTestClasses.GetOrDefault(fullName);
}
/// <summary>
/// Adds/Updates/Removes the test class for the type definition.
/// </summary>
void UpdateType(TopLevelTypeName dirtyTypeDef, ITypeDefinition typeDef)
{
ITest test;
if (topLevelTestClasses.TryGetValue(dirtyTypeDef, out test)) {
if (typeDef == null) {
// Test class was removed completely (no parts left)
RemoveTestClass(dirtyTypeDef, test);
} else {
// Test class was modified
// Check if it's still a test class:
if (IsTestClass(typeDef))
UpdateTestClass(test, typeDef);
else
RemoveTestClass(dirtyTypeDef, test);
}
} else if (typeDef != null) {
// Test class was added
var testClass = CreateTestClass(typeDef);
if (testClass != null)
AddTestClass(dirtyTypeDef, testClass);
}
}
/// <summary>
/// Adds a type forwarder.
/// This adds both an assembly attribute and an internal forwarder entry, which will be used
/// by the resolved assembly to provide the forwarded types.
/// </summary>
/// <param name="typeName">The name of the type.</param>
/// <param name="referencedType">The reference used to look up the type in the target assembly.</param>
public void AddTypeForwarder(TopLevelTypeName typeName, ITypeReference referencedType)
{
if (referencedType == null)
throw new ArgumentNullException("referencedType");
FreezableHelper.ThrowIfFrozen(this);
var attribute = new DefaultUnresolvedAttribute(typeForwardedToAttributeTypeRef, new[] { KnownTypeReference.Type });
attribute.PositionalArguments.Add(new TypeOfConstantValue(referencedType));
assemblyAttributes.Add(attribute);
typeForwarders[typeName] = referencedType;
}
public void AddNamedArg(string name, TopLevelTypeName type, object value)
{
AddNamedArg(name, compilation.FindType(type), value);
}
public ResolveResult ResolveTypeName(string typeName)
{
if(!BVE5ResourceManager.IsBuiltinTypeName(typeName)) //Try to match in case-insensitive way
return ErrorResult;
var type_name = new TopLevelTypeName("global", typeName, 0);
var type_def = compilation.MainAssembly.GetTypeDefinition(type_name);
if(type_def != null)
return new TypeResolveResult(type_def);
return ErrorResult;
}
public IUnresolvedAssembly LoadAssembly(Assembly assembly)
{
if (assembly == null)
throw new ArgumentNullException ("assembly");
// Read assembly and module attributes
IList<IUnresolvedAttribute> assemblyAttributes = new List<IUnresolvedAttribute>();
IList<IUnresolvedAttribute> moduleAttributes = new List<IUnresolvedAttribute>();
AddAttributes(assembly, assemblyAttributes);
AddAttributes(assembly.ManifestModule, moduleAttributes);
assemblyAttributes = interningProvider.InternList(assemblyAttributes);
moduleAttributes = interningProvider.InternList(moduleAttributes);
currentAssemblyDefinition = assembly;
currentAssembly = new IkvmUnresolvedAssembly (assembly.FullName, DocumentationProvider);
currentAssembly.Location = assembly.Location;
currentAssembly.AssemblyAttributes.AddRange(assemblyAttributes);
currentAssembly.ModuleAttributes.AddRange(moduleAttributes);
// Register type forwarders:
foreach (var type in assembly.ManifestModule.__GetExportedTypes ()) {
if (type.Assembly != assembly) {
int typeParameterCount;
string ns = type.Namespace;
string name = ReflectionHelper.SplitTypeParameterCountFromReflectionName(type.Name, out typeParameterCount);
ns = interningProvider.Intern(ns);
name = interningProvider.Intern(name);
var typeRef = new GetClassTypeReference(GetAssemblyReference(type.Assembly), ns, name, typeParameterCount);
typeRef = interningProvider.Intern(typeRef);
var key = new TopLevelTypeName(ns, name, typeParameterCount);
currentAssembly.AddTypeForwarder(key, typeRef);
}
}
// Create and register all types:
var ikvmTypeDefs = new List<IKVM.Reflection.Type>();
var typeDefs = new List<DefaultUnresolvedTypeDefinition>();
foreach (var td in assembly.GetTypes ()) {
if (td.DeclaringType != null)
continue;
CancellationToken.ThrowIfCancellationRequested();
if (IncludeInternalMembers || td.IsPublic) {
string name = td.Name;
if (name.Length == 0)
continue;
var t = CreateTopLevelTypeDefinition(td);
ikvmTypeDefs.Add(td);
typeDefs.Add(t);
currentAssembly.AddTypeDefinition(t);
// The registration will happen after the members are initialized
}
}
// Initialize the type's members:
for (int i = 0; i < typeDefs.Count; i++) {
InitTypeDefinition(ikvmTypeDefs[i], typeDefs[i]);
}
// Freezing the assembly here is important:
// otherwise it will be frozen when a compilation is first created
// from it. But freezing has the effect of changing some collection instances
// (to ReadOnlyCollection). This hidden mutation was causing a crash
// when the FastSerializer was saving the assembly at the same time as
// the first compilation was created from it.
// By freezing the assembly now, we ensure it is usable on multiple
// threads without issues.
currentAssembly.Freeze();
var result = currentAssembly;
currentAssembly = null;
return result;
}
IAttribute ConvertMarshalInfo(SRM.BlobReader marshalInfo)
{
var b = new AttributeBuilder(module, KnownAttribute.MarshalAs);
IType unmanagedTypeType = module.Compilation.FindType(new TopLevelTypeName(InteropServices, nameof(UnmanagedType)));
int type = marshalInfo.ReadByte();
b.AddFixedArg(unmanagedTypeType, type);
int size;
switch (type)
{
case 0x1e: // FixedArray
if (!marshalInfo.TryReadCompressedInteger(out size))
{
size = 0;
}
b.AddNamedArg("SizeConst", KnownTypeCode.Int32, size);
if (marshalInfo.RemainingBytes > 0)
{
type = marshalInfo.ReadByte();
if (type != 0x66) // None
{
b.AddNamedArg("ArraySubType", unmanagedTypeType, type);
}
}
break;
case 0x1d: // SafeArray
if (marshalInfo.RemainingBytes > 0)
{
VarEnum varType = (VarEnum)marshalInfo.ReadByte();
if (varType != VarEnum.VT_EMPTY)
{
var varEnumType = new TopLevelTypeName(InteropServices, nameof(VarEnum));
b.AddNamedArg("SafeArraySubType", varEnumType, (int)varType);
}
}
break;
case 0x2a: // NATIVE_TYPE_ARRAY
if (marshalInfo.RemainingBytes > 0)
{
type = marshalInfo.ReadByte();
}
else
{
type = 0x66; // Cecil uses NativeType.None as default.
}
if (type != 0x50) // Max
{
b.AddNamedArg("ArraySubType", unmanagedTypeType, type);
}
int sizeParameterIndex = marshalInfo.TryReadCompressedInteger(out int value) ? value : -1;
size = marshalInfo.TryReadCompressedInteger(out value) ? value : -1;
int sizeParameterMultiplier = marshalInfo.TryReadCompressedInteger(out value) ? value : -1;
if (size >= 0)
{
b.AddNamedArg("SizeConst", KnownTypeCode.Int32, size);
}
if (sizeParameterMultiplier != 0 && sizeParameterIndex >= 0)
{
b.AddNamedArg("SizeParamIndex", KnownTypeCode.Int16, (short)sizeParameterIndex);
}
break;
case 0x2c: // CustomMarshaler
string guidValue = marshalInfo.ReadSerializedString();
string unmanagedType = marshalInfo.ReadSerializedString();
string managedType = marshalInfo.ReadSerializedString();
string cookie = marshalInfo.ReadSerializedString();
if (managedType != null)
{
b.AddNamedArg("MarshalType", KnownTypeCode.String, managedType);
}
if (!string.IsNullOrEmpty(cookie))
{
b.AddNamedArg("MarshalCookie", KnownTypeCode.String, cookie);
}
break;
case 0x17: // FixedSysString
b.AddNamedArg("SizeConst", KnownTypeCode.Int32, marshalInfo.ReadCompressedInteger());
break;
}
return(b.Build());
}
public ITypeDefinition GetTypeDefinition(TopLevelTypeName topLevelTypeName)
{
IUnresolvedTypeDefinition td;
ITypeReference typeRef;
if (unresolvedAssembly.typeDefinitions.TryGetValue(topLevelTypeName, out td))
return GetTypeDefinition(td);
if (unresolvedAssembly.typeForwarders.TryGetValue(topLevelTypeName, out typeRef)) {
// Protect against cyclic type forwarders:
using (var busyLock = BusyManager.Enter(typeRef)) {
if (busyLock.Success)
return typeRef.Resolve(compilation.TypeResolveContext).GetDefinition();
}
}
return null;
}
protected ITest GetTestClass(TopLevelTypeName fullName)
{
EnsureNestedTestsInitialized();
return(topLevelTestClasses.GetOrDefault(fullName));
}
public ITypeDefinition GetTypeDefinition(TopLevelTypeName topLevelTypeName)
{
ITypeDefinition def;
if (GetTypes().TryGetValue(topLevelTypeName, out def))
return def;
else
return null;
}
ITypeDefinitionModel ITypeDefinitionModelCollection.this[TopLevelTypeName name] {
get { return(null); }
}
public DecompiledTypeReference(FileName assemblyFile, TopLevelTypeName type)
{
this.AssemblyFile = assemblyFile;
this.Type = type;
}
ITypeDefinition GetTypeDefinition(string name)
{
ICompilation compilation = project.GetCompilationUnit();
var typeName = new TopLevelTypeName(name);
foreach (IAssembly assembly in compilation.Assemblies) {
ITypeDefinition typeDefinition = assembly.GetTypeDefinition(typeName);
if (typeDefinition != null) {
return typeDefinition;
}
}
return null;
}
public ITypeDefinition GetTypeDefinition(TopLevelTypeName topLevelTypeName)
{
throw new NotImplementedException();
}
public IUnresolvedTypeDefinition GetTypeDefinition(string ns, string name, int typeParameterCount)
{
var key = new TopLevelTypeName(ns ?? string.Empty, name, typeParameterCount);
IUnresolvedTypeDefinition td;
if (typeDefinitions.TryGetValue(key, out td))
return td;
else
return null;
}
public void AddFixedArg(TopLevelTypeName type, object value)
{
AddFixedArg(compilation.FindType(type), value);
}
ITypeDefinition INamespace.GetTypeDefinition(string name, int typeParameterCount)
{
var key = new TopLevelTypeName(ns.FullName, name, typeParameterCount);
IUnresolvedTypeDefinition unresolvedTypeDef;
if (assembly.unresolvedTypeDict.TryGetValue(key, out unresolvedTypeDef))
return assembly.GetTypeDefinition(unresolvedTypeDef);
else
return null;
}
/// <summary>
/// Construct a builtin attribute with a single positional argument of known type.
/// </summary>
public void Add(KnownAttribute type, TopLevelTypeName argType, object argValue)
{
Add(type, ImmutableArray.Create(new CustomAttributeTypedArgument <IType>(module.Compilation.FindType(argType), argValue)));
}
protected virtual void AddToDirtyList(TopLevelTypeName className)
{
dirtyTypeDefinitions.Add(className);
}
