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); } }
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); }
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); }