// https://github.com/dotnet/roslyn/issues/29821 external annotations should be removed or fully designed/productized internal static TypeSymbolWithAnnotations TransformType( TypeSymbolWithAnnotations metadataType, EntityHandle targetSymbolToken, PEModuleSymbol containingModule, ImmutableArray <byte> extraAnnotations) { if (extraAnnotations.IsDefault) { return(NullableTypeDecoder.TransformType(metadataType, targetSymbolToken, containingModule)); } else { return(NullableTypeDecoder.TransformType(metadataType, defaultTransformFlag: 0, extraAnnotations)); } }
/// <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="parameterInfo" /> /// <param name="isBad" /> internal static PEParameterSymbol Create( PEModuleSymbol moduleSymbol, PEPropertySymbol containingSymbol, bool isContainingSymbolVirtual, int ordinal, ParameterHandle handle, ParamInfo <TypeSymbol> parameterInfo, ImmutableArray <byte> extraAnnotations, out bool isBad) { return(Create( moduleSymbol, containingSymbol, isContainingSymbolVirtual, ordinal, parameterInfo.IsByRef, parameterInfo.RefCustomModifiers, parameterInfo.Type, extraAnnotations, handle, parameterInfo.CustomModifiers, isReturn: false, out isBad)); }
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; }
private static bool DoesSignatureMatch( PEModuleSymbol moduleSymbol, TypeSymbol eventType, PEMethodSymbol method) { // CONSIDER: It would be nice if we could reuse this signature information in the PEMethodSymbol. var metadataDecoder = new MetadataDecoder(moduleSymbol, method); SignatureHeader signatureHeader; BadImageFormatException mrEx; var methodParams = metadataDecoder.GetSignatureForMethod(method.Handle, out signatureHeader, out mrEx, setParamHandles: false); if (mrEx != null) { return(false); } return(metadataDecoder.DoesSignatureMatchEvent(eventType, methodParams)); }
public PEParameterSymbolWithCustomModifiers( PEModuleSymbol moduleSymbol, Symbol containingSymbol, int ordinal, bool isByRef, ImmutableArray <ModifierInfo <TypeSymbol> > refCustomModifiers, TypeSymbolWithAnnotations type, ImmutableArray <byte> extraAnnotations, ParameterHandle handle, out bool isBad) : base(moduleSymbol, containingSymbol, ordinal, isByRef, type, extraAnnotations, handle, refCustomModifiers.NullToEmpty().Length + type.CustomModifiers.Length, out isBad) { _refCustomModifiers = CSharpCustomModifier.Convert(refCustomModifiers); Debug.Assert(_refCustomModifiers.IsEmpty || isByRef); }
public static TypeSymbol DecodeTupleTypesIfApplicable( TypeSymbol metadataType, EntityHandle targetHandle, PEModuleSymbol containingModule) { ImmutableArray <string> elementNames; var hasTupleElementNamesAttribute = containingModule .Module .HasTupleElementNamesAttribute(targetHandle, out elementNames); // If we have the TupleElementNamesAttribute, but no names, that's // bad metadata if (hasTupleElementNamesAttribute && elementNames.IsDefaultOrEmpty) { return(new UnsupportedMetadataTypeSymbol()); } return(DecodeTupleTypesInternal(metadataType, elementNames, hasTupleElementNamesAttribute)); }
private static PEParameterSymbol Create( PEModuleSymbol moduleSymbol, Symbol containingSymbol, bool isContainingSymbolVirtual, int ordinal, bool isByRef, ImmutableArray <ModifierInfo <TypeSymbol> > refCustomModifiers, TypeSymbol type, ImmutableArray <byte> extraAnnotations, ParameterHandle handle, ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers, bool isReturn, out bool isBad) { // We start without annotation (they will be decoded below) var typeWithModifiers = TypeSymbolWithAnnotations.Create(type, customModifiers: CSharpCustomModifier.Convert(customModifiers)); PEParameterSymbol parameter = customModifiers.IsDefaultOrEmpty && refCustomModifiers.IsDefaultOrEmpty ? new PEParameterSymbol(moduleSymbol, containingSymbol, ordinal, isByRef, typeWithModifiers, extraAnnotations, handle, 0, out isBad) : new PEParameterSymbolWithCustomModifiers(moduleSymbol, containingSymbol, ordinal, isByRef, refCustomModifiers, typeWithModifiers, extraAnnotations, handle, out isBad); bool hasInAttributeModifier = parameter.RefCustomModifiers.HasInAttributeModifier(); if (isReturn) { // A RefReadOnly return parameter should always have this modreq, and vice versa. isBad |= (parameter.RefKind == RefKind.RefReadOnly) != hasInAttributeModifier; } else if (parameter.RefKind == RefKind.In) { // An in parameter should not have this modreq, unless the containing symbol was virtual or abstract. isBad |= isContainingSymbolVirtual != hasInAttributeModifier; } else if (hasInAttributeModifier) { // This modreq should not exist on non-in parameters. isBad = true; } return(parameter); }
/// <summary> /// Decodes the attributes applied to the given <see paramref="targetSymbol"/> from metadata and checks if System.Runtime.CompilerServices.DynamicAttribute is applied. /// If so, it transforms the given <see paramref="metadataType"/>, using the decoded dynamic transforms attribute argument, /// by replacing each occurrence of <see cref="System.Object"/> type with dynamic type. /// If no System.Runtime.CompilerServices.DynamicAttribute is applied or the decoded dynamic transforms attribute argument is erroneous, /// returns the unchanged <see paramref="metadataType"/>. /// </summary> /// <remarks>This method is a port of TypeManager::ImportDynamicTransformType from the native compiler.</remarks> internal static TypeSymbol TransformType( TypeSymbol metadataType, int targetSymbolCustomModifierCount, EntityHandle targetSymbolToken, PEModuleSymbol containingModule, RefKind targetSymbolRefKind = RefKind.None) { Debug.Assert((object)metadataType != null); ImmutableArray <bool> dynamicTransformFlags; if (containingModule.Module.HasDynamicAttribute(targetSymbolToken, out dynamicTransformFlags)) { return(TransformTypeInternal(metadataType, containingModule.ContainingAssembly, targetSymbolCustomModifierCount, targetSymbolRefKind, dynamicTransformFlags, haveCustomModifierFlags: true, checkLength: true)); } // No DynamicAttribute applied to the target symbol, return unchanged metadataType. return(metadataType); }
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; } _lazyConstraintsUseSiteErrorInfo = 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; }
public static TypeSymbolWithAnnotations DecodeTupleTypesIfApplicable( TypeSymbolWithAnnotations metadataType, EntityHandle targetHandle, PEModuleSymbol containingModule) { ImmutableArray <string> elementNames; var hasTupleElementNamesAttribute = containingModule .Module .HasTupleElementNamesAttribute(targetHandle, out elementNames); // If we have the TupleElementNamesAttribute, but no names, that's // bad metadata if (hasTupleElementNamesAttribute && elementNames.IsDefaultOrEmpty) { return(TypeSymbolWithAnnotations.Create(new UnsupportedMetadataTypeSymbol())); } TypeSymbol type = metadataType.TypeSymbol; TypeSymbol decoded = DecodeTupleTypesInternal(type, elementNames, hasTupleElementNamesAttribute); return((object)decoded == (object)type ? metadataType : TypeSymbolWithAnnotations.Create(decoded, metadataType.NullableAnnotation, metadataType.CustomModifiers)); }
internal PEEventSymbol( PEModuleSymbol moduleSymbol, PENamedTypeSymbol containingType, EventDefinitionHandle handle, PEMethodSymbol addMethod, PEMethodSymbol removeMethod, MultiDictionary <string, PEFieldSymbol> privateFieldNameToSymbols) { Debug.Assert((object)moduleSymbol != null); Debug.Assert((object)containingType != null); Debug.Assert(!handle.IsNil); Debug.Assert((object)addMethod != null); Debug.Assert((object)removeMethod != null); _addMethod = addMethod; _removeMethod = removeMethod; _handle = handle; _containingType = containingType; EventAttributes mdFlags = 0; EntityHandle eventType = default(EntityHandle); try { var module = moduleSymbol.Module; module.GetEventDefPropsOrThrow(handle, out _name, out mdFlags, out eventType); } catch (BadImageFormatException mrEx) { if ((object)_name == null) { _name = string.Empty; } _lazyUseSiteDiagnostic = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this); if (eventType.IsNil) { _eventType = TypeSymbolWithAnnotations.Create(new UnsupportedMetadataTypeSymbol(mrEx)); } } TypeSymbol originalEventType = _eventType.TypeSymbol; if (_eventType.IsNull) { var metadataDecoder = new MetadataDecoder(moduleSymbol, containingType); originalEventType = metadataDecoder.GetTypeOfToken(eventType); var typeSymbol = originalEventType; // We start without annotation (they will be decoded below) var type = TypeSymbolWithAnnotations.Create(typeSymbol); // Decode nullable before tuple types to avoid converting between // NamedTypeSymbol and TupleTypeSymbol unnecessarily. type = NullableTypeDecoder.TransformType(type, handle, moduleSymbol); type = TupleTypeDecoder.DecodeTupleTypesIfApplicable(type, handle, moduleSymbol); _eventType = type; } bool callMethodsDirectly = !DoSignaturesMatch(moduleSymbol, originalEventType, _addMethod, _removeMethod); if (callMethodsDirectly) { _flags |= Flags.CallMethodsDirectly; } else { _addMethod.SetAssociatedEvent(this, MethodKind.EventAdd); _removeMethod.SetAssociatedEvent(this, MethodKind.EventRemove); PEFieldSymbol associatedField = GetAssociatedField(privateFieldNameToSymbols); if ((object)associatedField != null) { _associatedFieldOpt = associatedField; associatedField.SetAssociatedEvent(this); } } if ((mdFlags & EventAttributes.SpecialName) != 0) { _flags |= Flags.IsSpecialName; } if ((mdFlags & EventAttributes.RTSpecialName) != 0) { _flags |= Flags.IsRuntimeSpecialName; } }
internal PEAttributeData(PEModuleSymbol moduleSymbol, CustomAttributeHandle handle) { _decoder = new MetadataDecoder(moduleSymbol); _handle = handle; }
private PEParameterSymbol( PEModuleSymbol moduleSymbol, Symbol containingSymbol, int ordinal, bool isByRef, TypeSymbolWithAnnotations type, ImmutableArray <byte> extraAnnotations, ParameterHandle handle, int countOfCustomModifiers, out bool isBad) { Debug.Assert((object)moduleSymbol != null); Debug.Assert((object)containingSymbol != null); Debug.Assert(ordinal >= 0); Debug.Assert(!type.IsNull); 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 = TupleTypeSymbol.TryTransformToTuple(type.TypeSymbol, out TupleTypeSymbol tuple) ? TypeSymbolWithAnnotations.Create(tuple) : type; if (!extraAnnotations.IsDefault) { type = NullableTypeDecoder.TransformType(type, defaultTransformFlag: 0, extraAnnotations); } _lazyCustomAttributes = ImmutableArray <CSharpAttributeData> .Empty; _lazyHiddenAttributes = ImmutableArray <CSharpAttributeData> .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); if (inOutFlags == ParameterAttributes.Out) { refKind = RefKind.Out; } else if (moduleSymbol.Module.HasIsReadOnlyAttribute(handle)) { refKind = RefKind.In; } else { refKind = RefKind.Ref; } } // CONSIDER: Can we make parameter type computation lazy? var typeSymbol = type.TypeSymbol; type = type.WithTypeAndModifiers(typeSymbol, type.CustomModifiers); // Decode nullable before tuple types to avoid converting between // NamedTypeSymbol and TupleTypeSymbol unnecessarily. type = NullableTypeDecoder.TransformType(type, handle, moduleSymbol, extraAnnotations); type = TupleTypeDecoder.DecodeTupleTypesIfApplicable(type, handle, moduleSymbol); } _type = type; 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); }
private PEPropertySymbol( PEModuleSymbol moduleSymbol, PENamedTypeSymbol containingType, PropertyDefinitionHandle handle, PEMethodSymbol getMethod, PEMethodSymbol setMethod, int countOfCustomModifiers, ParamInfo <TypeSymbol>[] propertyParams, MetadataDecoder metadataDecoder) { _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; 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 = setMethodParams is null ? GetParameters(moduleSymbol, this, propertyParams, getMethodParams, getMethod.IsMetadataVirtual(), out isBad) : GetParameters(moduleSymbol, this, propertyParams, setMethodParams, setMethod.IsMetadataVirtual(), out isBad); if (getEx != null || setEx != null || mrEx != null || isBad) { _lazyUseSiteDiagnostic = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this); } var returnInfo = propertyParams[0]; var typeCustomModifiers = CSharpCustomModifier.Convert(returnInfo.CustomModifiers); if (returnInfo.IsByRef) { if (moduleSymbol.Module.HasIsReadOnlyAttribute(handle)) { _refKind = RefKind.RefReadOnly; } else { _refKind = RefKind.Ref; } } else { _refKind = RefKind.None; } // CONSIDER: Can we make parameter type computation lazy? TypeSymbol originalPropertyType = returnInfo.Type; originalPropertyType = DynamicTypeDecoder.TransformType(originalPropertyType, typeCustomModifiers.Length, handle, moduleSymbol, _refKind); // Dynamify object type if necessary originalPropertyType = originalPropertyType.AsDynamicIfNoPia(_containingType); // We start without annotation (they will be decoded below) var propertyType = TypeSymbolWithAnnotations.Create(originalPropertyType, customModifiers: typeCustomModifiers); // Decode nullable before tuple types to avoid converting between // NamedTypeSymbol and TupleTypeSymbol unnecessarily. propertyType = NullableTypeDecoder.TransformType(propertyType, handle, moduleSymbol); propertyType = TupleTypeDecoder.DecodeTupleTypesIfApplicable(propertyType, handle, moduleSymbol); _propertyType = propertyType; // 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; } }
internal PEGlobalNamespaceSymbol(PEModuleSymbol moduleSymbol) { Debug.Assert((object)moduleSymbol != null); _moduleSymbol = moduleSymbol; }