/// <summary> /// This method's custom attributes, empty if none /// </summary> override public ImmutableArray <MrCustomAttribute> GetCustomAttributes() { var customAttributeHandles = this.MethodDefinition.GetCustomAttributes(); var customAttributes = MrAssembly.GetCustomAttributesFromHandles(customAttributeHandles, this.DeclaringType); return(customAttributes.ToImmutableArray()); }
/// <summary> /// Load an assembly from its MetadataReader. If reader is null, create a fake assembly. /// </summary> private MrAssembly LoadFromReader(MetadataReader reader, string name, string path, bool implicitLoad) { if (!_loading && !implicitLoad) { throw new Exception("Once FinishLoading() has been called, no more assemblies can be loaded"); } MrAssembly newAssembly; if (reader == null) { newAssembly = MrAssembly.CreateFakeAssembly(name, this); } else { Debug.Assert(name == reader.GetString(reader.GetAssemblyDefinition().Name) || name == "mscorlib"); // See if the assembly was already explicitly loaded if (_loadedAssemblies.TryGetValue(name, out var loadedAssembly)) { return(loadedAssembly); } // Or it might have been implicitly loaded if (_implicitAssemblies.TryGetValue(name, out loadedAssembly)) { if (implicitLoad) { return(loadedAssembly); } // This assembly was implicitly loaded, now it's being explicitly loaded, // so move it from implicit to explicit. _loadedAssemblies[name] = loadedAssembly; _implicitAssemblies.Remove(name); return(loadedAssembly); } // Prevent stack overflow by making this assembly exist before creating it // (which might trigger a cycle of assembly references) if (implicitLoad) { _implicitAssemblies[name] = null; } newAssembly = MrAssembly.Create(reader, path, this); } // Save the assembly if (implicitLoad) { _implicitAssemblies[name] = newAssembly; } else { _loadedAssemblies[name] = newAssembly; } return(newAssembly); }
internal static MrAssembly CreateFakeAssembly(string name, MrLoadContext loadContext) { var mrAssembly = new MrAssembly(null, null, loadContext); mrAssembly.IsFakeAssembly = true; mrAssembly.Name = name; return(mrAssembly); }
public MrCustomAttribute(CustomAttributeHandle handle, MrType targetType, MrAssembly assembly) { Handle = handle; Assembly = assembly; TargetType = targetType; CustomAttribute = assembly.Reader.GetCustomAttribute(handle); }
internal static MrType CreateFromGenericParameterHandle( GenericParameterHandle handle, MrAssembly assembly, int arrayRank = 0, bool isReference = false, bool isPointer = false) { return(new MrType(handle, assembly) { ArrayRank = arrayRank, IsReference = isReference, IsPointer = isPointer }); }
private MrType(string fakeFullName, MrAssembly assembly) { this.Assembly = assembly; var index = fakeFullName.LastIndexOf('.'); if (index == -1) { _fakeName = fakeFullName; } else { _fakeNamespace = fakeFullName.Substring(0, index); _fakeName = fakeFullName.Substring(index + 1); } Debug.WriteLine($"Faking {_fakeName}"); }
static public MrAssembly Create(MetadataReader reader, string location, MrLoadContext loadContext) { var mrAssembly = new MrAssembly(reader, location, loadContext); return(mrAssembly); }
static public MrType AsMrType(this PrimitiveTypeCode typeCode, MrAssembly assembly) { return(MrType.CreatePrimitiveType(typeCode)); }
static public MrType AsMrType(this TypeDefinitionHandle handle, MrAssembly assembly) { return(MrType.CreateFromTypeDefinition(handle, assembly)); }
// Create a placeholder type that was referenced but wasn't in any of the loaded assemblies static internal MrType CreateFakeType(string name, MrAssembly assembly) { return(new MrType(name, assembly)); }
private MrType(TypeDefinitionHandle typeDefinitionHandle, MrAssembly assembly) { TypeDefinitionHandle = typeDefinitionHandle; Assembly = assembly; TypeDefinition = Assembly.Reader.GetTypeDefinition(typeDefinitionHandle); }
/// <summary> /// Create a type from the type table. /// </summary> static internal MrType CreateFromTypeDefinition(TypeDefinitionHandle typeDefinitionHandle, MrAssembly assembly) { var type = assembly.GetFromCacheOrCreate( typeDefinitionHandle, () => new MrType(typeDefinitionHandle, assembly)); Debug.Assert(type == assembly.GetFromCacheOrCreate(typeDefinitionHandle, null)); return(type); }
private MrType(GenericParameterHandle handle, MrAssembly assembly) { Assembly = assembly; GenericParameterHandle = handle; }
/// <summary> /// Converts a StringHandle to a String /// </summary> internal static string AsString(this StringHandle stringHandle, MrAssembly assembly) { return(assembly.Reader.GetString(stringHandle)); }
public DisassemblingTypeProvider(MrAssembly assembly) { Assembly = assembly; }
public CustomAttributeTypeProvider(MrAssembly assembly) : base(assembly) { }