//private PEEventSymbol _associatedEventOpt; internal PEFieldSymbol( PEModuleSymbol moduleSymbol, PENamedTypeSymbol containingType, FieldDefinitionHandle fieldDef) { Debug.Assert((object)moduleSymbol != null); Debug.Assert((object)containingType != null); Debug.Assert(!fieldDef.IsNil); _handle = fieldDef; _containingType = containingType; try { moduleSymbol.Module.GetFieldDefPropsOrThrow(fieldDef, out _name, out _flags); } catch (BadImageFormatException) { if ((object)_name == null) { _name = String.Empty; } throw new NotImplementedException(); //_lazyUseSiteDiagnostic = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this); } }
internal PETypeParameterSymbol( PEModuleSymbol moduleSymbol, PEMethodSymbol definingMethod, ushort ordinal, GenericParameterHandle handle) : this(moduleSymbol, (Symbol)definingMethod, ordinal, handle) { }
public PEParameterSymbolWithCustomModifiers( PEModuleSymbol moduleSymbol, Symbol containingSymbol, int ordinal, bool isByRef, TypeSymbol type, ParameterHandle handle, ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers, out bool isBad) : base(moduleSymbol, containingSymbol, ordinal, isByRef, type, handle, out isBad) { _customModifiers = CSharpCustomModifier.Convert(customModifiers); // TODO: RefCustomModifiers }
private static PEParameterSymbol Create( PEModuleSymbol moduleSymbol, Symbol containingSymbol, int ordinal, bool isByRef, TypeSymbol type, ParameterHandle handle, ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers, out bool isBad) { if (customModifiers.IsDefaultOrEmpty) { return(new PEParameterSymbol(moduleSymbol, containingSymbol, ordinal, isByRef, type, handle, out isBad)); } return(new PEParameterSymbolWithCustomModifiers(moduleSymbol, containingSymbol, ordinal, isByRef, type, handle, customModifiers, out isBad)); }
public PEParameterSymbolWithCustomModifiers( PEModuleSymbol moduleSymbol, Symbol containingSymbol, int ordinal, bool isByRef, ushort countOfCustomModifiersPrecedingByRef, TypeSymbol type, ParameterHandle handle, ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers, out bool isBad) : base(moduleSymbol, containingSymbol, ordinal, isByRef, type, handle, customModifiers.Length, out isBad) { _customModifiers = CSharpCustomModifier.Convert(customModifiers); _countOfCustomModifiersPrecedingByRef = countOfCustomModifiersPrecedingByRef; Debug.Assert(_countOfCustomModifiersPrecedingByRef == 0 || isByRef); Debug.Assert(_countOfCustomModifiersPrecedingByRef <= _customModifiers.Length); }
internal PEAssemblySymbol(PEAssembly assembly, DocumentationProvider documentationProvider, string filePath, bool isLinked, MetadataImportOptions importOptions) { Debug.Assert(assembly != null); Debug.Assert(documentationProvider != null); _assembly = assembly; _documentationProvider = documentationProvider; _filePath = filePath; var modules = new ModuleSymbol[assembly.Modules.Length]; for (int i = 0; i < assembly.Modules.Length; i++) { modules[i] = new PEModuleSymbol(this, assembly.Modules[i], importOptions, i); } _modules = modules.AsImmutableOrNull(); _isLinked = isLinked; if (IsPchpCor(assembly)) { _specialAssembly = SpecialAssembly.PchpCorLibrary; // initialize CoreTypes this.PrimaryModule.GlobalNamespace.GetTypeMembers(); } else if (assembly.Identity.Name == "System.Runtime") { _specialAssembly = SpecialAssembly.CorLibrary; } else if (assembly.AssemblyReferences.Length == 0 && assembly.DeclaresTheObjectClass) { _specialAssembly = SpecialAssembly.CorLibrary; } else { // extension assembly ? //var attrs = this.GetAttributes(); } }
private bool IsFixedBuffer(out int fixedSize, out TypeSymbol fixedElementType) { fixedSize = 0; fixedElementType = null; string elementTypeName; int bufferSize; PEModuleSymbol containingPEModule = this.ContainingPEModule; if (containingPEModule.Module.HasFixedBufferAttribute(_handle, out elementTypeName, out bufferSize)) { var decoder = new MetadataDecoder(containingPEModule); var elementType = decoder.GetTypeSymbolForSerializedType(elementTypeName); if (elementType.FixedBufferElementSizeInBytes() != 0) { fixedSize = bufferSize; fixedElementType = elementType; return(true); } } return(false); }
private PETypeParameterSymbol( PEModuleSymbol moduleSymbol, Symbol definingSymbol, ushort ordinal, GenericParameterHandle handle) { Debug.Assert((object)moduleSymbol != null); Debug.Assert((object)definingSymbol != null); Debug.Assert(ordinal >= 0); Debug.Assert(!handle.IsNil); _containingSymbol = definingSymbol; GenericParameterAttributes flags = 0; try { moduleSymbol.Module.GetGenericParamPropsOrThrow(handle, out _name, out flags); } catch (BadImageFormatException) { if ((object)_name == null) { _name = string.Empty; } //_lazyBoundsErrorInfo = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this); } // Clear the '.ctor' flag if both '.ctor' and 'valuetype' are // set since '.ctor' is redundant in that case. _flags = ((flags & GenericParameterAttributes.NotNullableValueTypeConstraint) == 0) ? flags : (flags & ~GenericParameterAttributes.DefaultConstructorConstraint); _ordinal = ordinal; _handle = handle; }
private static ImmutableArray <ParameterSymbol> GetParameters( PEModuleSymbol moduleSymbol, PEPropertySymbol property, ParamInfo <TypeSymbol>[] propertyParams, ParamInfo <TypeSymbol>[] accessorParams, out bool anyParameterIsBad) { anyParameterIsBad = false; // First parameter is the property type. if (propertyParams.Length < 2) { return(ImmutableArray <ParameterSymbol> .Empty); } var numAccessorParams = accessorParams.Length; var parameters = new ParameterSymbol[propertyParams.Length - 1]; for (int i = 1; i < propertyParams.Length; i++) // from 1 to skip property/return type { // NOTE: this is a best guess at the Dev10 behavior. The actual behavior is // in the unmanaged helper code that Dev10 uses to load the metadata. var propertyParam = propertyParams[i]; var paramHandle = i < numAccessorParams ? accessorParams[i].Handle : propertyParam.Handle; var ordinal = i - 1; bool isBad; parameters[ordinal] = PEParameterSymbol.Create(moduleSymbol, property, ordinal, paramHandle, propertyParam, out isBad); if (isBad) { anyParameterIsBad = true; } } return(parameters.AsImmutableOrNull()); }
private static PEParameterSymbol Create( PEModuleSymbol moduleSymbol, Symbol containingSymbol, int ordinal, bool isByRef, ushort countOfCustomModifiersPrecedingByRef, TypeSymbol type, ParameterHandle handle, ImmutableArray<ModifierInfo<TypeSymbol>> customModifiers, out bool isBad) { if (customModifiers.IsDefaultOrEmpty) { return new PEParameterSymbol(moduleSymbol, containingSymbol, ordinal, isByRef, type, handle, 0, out isBad); } return new PEParameterSymbolWithCustomModifiers(moduleSymbol, containingSymbol, ordinal, isByRef, countOfCustomModifiersPrecedingByRef, type, handle, customModifiers, out isBad); }
private PEParameterSymbol( PEModuleSymbol moduleSymbol, Symbol containingSymbol, int ordinal, bool isByRef, TypeSymbol type, ParameterHandle handle, out bool isBad) { Debug.Assert((object)moduleSymbol != null); Debug.Assert((object)containingSymbol != null); Debug.Assert(ordinal >= 0); Debug.Assert((object)type != null); isBad = false; _moduleSymbol = moduleSymbol; _containingSymbol = containingSymbol; _ordinal = (ushort)ordinal; _handle = handle; RefKind refKind = RefKind.None; if (handle.IsNil) { refKind = isByRef ? RefKind.Ref : RefKind.None; _type = type; _lazyCustomAttributes = ImmutableArray <AttributeData> .Empty; _lazyHiddenAttributes = ImmutableArray <AttributeData> .Empty; _lazyDefaultValue = ConstantValue.NotAvailable; _lazyIsParams = ThreeState.False; } else { try { moduleSymbol.Module.GetParamPropsOrThrow(handle, out _name, out _flags); } catch (BadImageFormatException) { isBad = true; } if (isByRef) { ParameterAttributes inOutFlags = _flags & (ParameterAttributes.Out | ParameterAttributes.In); refKind = (inOutFlags == ParameterAttributes.Out) ? RefKind.Out : RefKind.Ref; } // CONSIDER: Can we make parameter type computation lazy? _type = type; // DynamicTypeDecoder.TransformType(type, countOfCustomModifiers, handle, moduleSymbol, refKind); } bool hasNameInMetadata = !string.IsNullOrEmpty(_name); if (!hasNameInMetadata) { // As was done historically, if the parameter doesn't have a name, we give it the name "value". _name = "value"; } _packedFlags = new PackedFlags(refKind, attributesAreComplete: handle.IsNil, hasNameInMetadata: hasNameInMetadata); Debug.Assert(refKind == this.RefKind); Debug.Assert(hasNameInMetadata == this.HasNameInMetadata); }
internal PEGlobalNamespaceSymbol(PEModuleSymbol moduleSymbol) { Debug.Assert((object)moduleSymbol != null); _moduleSymbol = moduleSymbol; }
internal PEPropertySymbol( PEModuleSymbol moduleSymbol, PENamedTypeSymbol containingType, PropertyDefinitionHandle handle, PEMethodSymbol getMethod, PEMethodSymbol setMethod) { Debug.Assert((object)moduleSymbol != null); Debug.Assert((object)containingType != null); Debug.Assert(!handle.IsNil); _containingType = containingType; var module = moduleSymbol.Module; PropertyAttributes mdFlags = 0; BadImageFormatException mrEx = null; try { module.GetPropertyDefPropsOrThrow(handle, out _name, out mdFlags); } catch (BadImageFormatException e) { mrEx = e; if ((object)_name == null) { _name = string.Empty; } } _getMethod = getMethod; _setMethod = setMethod; _handle = handle; var metadataDecoder = new MetadataDecoder(moduleSymbol, containingType); SignatureHeader callingConvention; BadImageFormatException propEx; var propertyParams = metadataDecoder.GetSignatureForProperty(handle, out callingConvention, out propEx); Debug.Assert(propertyParams.Length > 0); SignatureHeader unusedCallingConvention; BadImageFormatException getEx = null; var getMethodParams = (object)getMethod == null ? null : metadataDecoder.GetSignatureForMethod(getMethod.Handle, out unusedCallingConvention, out getEx); BadImageFormatException setEx = null; var setMethodParams = (object)setMethod == null ? null : metadataDecoder.GetSignatureForMethod(setMethod.Handle, out unusedCallingConvention, out setEx); // NOTE: property parameter names are not recorded in metadata, so we have to // use the parameter names from one of the indexers. // NB: prefer setter names to getter names if both are present. bool isBad; _parameters = GetParameters(moduleSymbol, this, propertyParams, setMethodParams ?? getMethodParams, out isBad); //if (propEx != null || getEx != null || setEx != null || mrEx != null || isBad) //{ // _lazyUseSiteDiagnostic = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this); //} _typeCustomModifiers = CSharpCustomModifier.Convert(propertyParams[0].CustomModifiers); // CONSIDER: Can we make parameter type computation lazy? TypeSymbol originalPropertyType = propertyParams[0].Type; _propertyType = originalPropertyType; // DynamicTypeDecoder.TransformType(originalPropertyType, _typeCustomModifiers.Length, handle, moduleSymbol); //// Dynamify object type if necessary //_propertyType = _propertyType.AsDynamicIfNoPia(_containingType); // A property is bogus and must be accessed by calling its accessors directly if the // accessor signatures do not agree, both with each other and with the property, // or if it has parameters and is not an indexer or indexed property. bool callMethodsDirectly = !DoSignaturesMatch(module, metadataDecoder, propertyParams, _getMethod, getMethodParams, _setMethod, setMethodParams) || MustCallMethodsDirectlyCore(); if (!callMethodsDirectly) { //if ((object)_getMethod != null) //{ // _getMethod.SetAssociatedProperty(this, MethodKind.PropertyGet); //} //if ((object)_setMethod != null) //{ // _setMethod.SetAssociatedProperty(this, MethodKind.PropertySet); //} } if (callMethodsDirectly) { _flags |= Flags.CallMethodsDirectly; } if ((mdFlags & PropertyAttributes.SpecialName) != 0) { _flags |= Flags.IsSpecialName; } if ((mdFlags & PropertyAttributes.RTSpecialName) != 0) { _flags |= Flags.IsRuntimeSpecialName; } }
public PEParameterSymbolWithCustomModifiers( PEModuleSymbol moduleSymbol, Symbol containingSymbol, int ordinal, bool isByRef, ushort countOfCustomModifiersPrecedingByRef, TypeSymbol type, ParameterHandle handle, ImmutableArray<ModifierInfo<TypeSymbol>> customModifiers, out bool isBad) : base(moduleSymbol, containingSymbol, ordinal, isByRef, type, handle, customModifiers.Length, out isBad) { _customModifiers = CSharpCustomModifier.Convert(customModifiers); _countOfCustomModifiersPrecedingByRef = countOfCustomModifiersPrecedingByRef; Debug.Assert(_countOfCustomModifiersPrecedingByRef == 0 || isByRef); Debug.Assert(_countOfCustomModifiersPrecedingByRef <= _customModifiers.Length); }
internal PEAttributeData(PEModuleSymbol moduleSymbol, CustomAttributeHandle handle) { _decoder = new MetadataDecoder(moduleSymbol); _handle = handle; }
private PEParameterSymbol( PEModuleSymbol moduleSymbol, Symbol containingSymbol, int ordinal, bool isByRef, TypeSymbol type, ParameterHandle handle, int countOfCustomModifiers, out bool isBad) { Debug.Assert((object)moduleSymbol != null); Debug.Assert((object)containingSymbol != null); Debug.Assert(ordinal >= 0); Debug.Assert((object)type != null); isBad = false; _moduleSymbol = moduleSymbol; _containingSymbol = containingSymbol; _ordinal = (ushort)ordinal; _handle = handle; RefKind refKind = RefKind.None; if (handle.IsNil) { refKind = isByRef ? RefKind.Ref : RefKind.None; _type = type; _lazyCustomAttributes = ImmutableArray<AttributeData>.Empty; _lazyHiddenAttributes = ImmutableArray<AttributeData>.Empty; _lazyDefaultValue = ConstantValue.NotAvailable; _lazyIsParams = ThreeState.False; } else { try { moduleSymbol.Module.GetParamPropsOrThrow(handle, out _name, out _flags); } catch (BadImageFormatException) { isBad = true; } if (isByRef) { ParameterAttributes inOutFlags = _flags & (ParameterAttributes.Out | ParameterAttributes.In); refKind = (inOutFlags == ParameterAttributes.Out) ? RefKind.Out : RefKind.Ref; } // CONSIDER: Can we make parameter type computation lazy? _type = type; // DynamicTypeDecoder.TransformType(type, countOfCustomModifiers, handle, moduleSymbol, refKind); } bool hasNameInMetadata = !string.IsNullOrEmpty(_name); if (!hasNameInMetadata) { // As was done historically, if the parameter doesn't have a name, we give it the name "value". _name = "value"; } _packedFlags = new PackedFlags(refKind, attributesAreComplete: handle.IsNil, hasNameInMetadata: hasNameInMetadata); Debug.Assert(refKind == this.RefKind); Debug.Assert(hasNameInMetadata == this.HasNameInMetadata); }
internal PEAssemblySymbol(PEAssembly assembly, DocumentationProvider documentationProvider, bool isLinked, MetadataImportOptions importOptions) { Debug.Assert(assembly != null); Debug.Assert(documentationProvider != null); _assembly = assembly; _documentationProvider = documentationProvider; var modules = new ModuleSymbol[assembly.Modules.Length]; for (int i = 0; i < assembly.Modules.Length; i++) { modules[i] = new PEModuleSymbol(this, assembly.Modules[i], importOptions, i); } _modules = modules.AsImmutableOrNull(); _isLinked = isLinked; if (IsPchpCor(assembly)) { _specialAssembly = SpecialAssembly.PchpCorLibrary; // initialize CoreTypes this.PrimaryModule.GlobalNamespace.GetTypeMembers(); } else if (assembly.Identity.Name == "System.Runtime") { _specialAssembly = SpecialAssembly.CorLibrary; } else if (assembly.AssemblyReferences.Length == 0 && assembly.DeclaresTheObjectClass) { _specialAssembly = SpecialAssembly.CorLibrary; } else { // extension assembly ? //var attrs = this.GetAttributes(); } }
private static ImmutableArray<ParameterSymbol> GetParameters( PEModuleSymbol moduleSymbol, PEPropertySymbol property, ParamInfo<TypeSymbol>[] propertyParams, ParamInfo<TypeSymbol>[] accessorParams, out bool anyParameterIsBad) { anyParameterIsBad = false; // First parameter is the property type. if (propertyParams.Length < 2) { return ImmutableArray<ParameterSymbol>.Empty; } var numAccessorParams = accessorParams.Length; var parameters = new ParameterSymbol[propertyParams.Length - 1]; for (int i = 1; i < propertyParams.Length; i++) // from 1 to skip property/return type { // NOTE: this is a best guess at the Dev10 behavior. The actual behavior is // in the unmanaged helper code that Dev10 uses to load the metadata. var propertyParam = propertyParams[i]; var paramHandle = i < numAccessorParams ? accessorParams[i].Handle : propertyParam.Handle; var ordinal = i - 1; bool isBad; parameters[ordinal] = PEParameterSymbol.Create(moduleSymbol, property, ordinal, paramHandle, propertyParam, out isBad); if (isBad) { anyParameterIsBad = true; } } return parameters.AsImmutableOrNull(); }
internal PEMethodSymbol( PEModuleSymbol moduleSymbol, PENamedTypeSymbol containingType, MethodDefinitionHandle methodDef) { Debug.Assert((object)moduleSymbol != null); Debug.Assert((object)containingType != null); Debug.Assert(!methodDef.IsNil); _handle = methodDef; _containingType = containingType; MethodAttributes localflags = 0; try { int rva; MethodImplAttributes implFlags; moduleSymbol.Module.GetMethodDefPropsOrThrow(methodDef, out _name, out implFlags, out localflags, out rva); Debug.Assert((uint)implFlags <= ushort.MaxValue); _implFlags = (ushort)implFlags; } catch (BadImageFormatException) { if (_name == null) _name = string.Empty; //InitializeUseSiteDiagnostic(new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this)); } Debug.Assert((uint)localflags <= ushort.MaxValue); _flags = (ushort)localflags; }
/// <summary> /// Construct a parameter symbol for a property loaded from metadata. /// </summary> /// <param name="moduleSymbol"></param> /// <param name="containingSymbol"></param> /// <param name="ordinal"></param> /// <param name="handle">The property parameter doesn't have a name in metadata, /// so this is the handle of a corresponding accessor parameter, if there is one, /// or of the ParamInfo passed in, otherwise).</param> /// <param name="isBad" /> /// <param name="parameter"></param> internal static PEParameterSymbol Create( PEModuleSymbol moduleSymbol, PEPropertySymbol containingSymbol, int ordinal, ParameterHandle handle, ParamInfo<TypeSymbol> parameter, out bool isBad) { return Create(moduleSymbol, containingSymbol, ordinal, parameter.IsByRef, parameter.CountOfCustomModifiersPrecedingByRef, parameter.Type, handle, parameter.CustomModifiers, out isBad); }