///// <summary> ///// Mark this field as the backing field of a field-like event. ///// The caller will also ensure that it is excluded from the member list of ///// the containing type (as it would be in source). ///// </summary> //internal void SetAssociatedEvent(PEEventSymbol eventSymbol) //{ // Debug.Assert((object)eventSymbol != null); // Debug.Assert(eventSymbol.ContainingType == _containingType); // // This should always be true in valid metadata - there should only // // be one event with a given name in a given type. // if ((object)_associatedEventOpt == null) // { // // No locking required since this method will only be called by the thread that created // // the field symbol (and will be called before the field symbol is added to the containing // // type members and available to other threads). // _associatedEventOpt = eventSymbol; // } //} private void EnsureSignatureIsLoaded() { if ((object)_lazyType == null) { var moduleSymbol = _containingType.ContainingPEModule; bool isVolatile; ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers; TypeSymbol type = (new MetadataDecoder(moduleSymbol, _containingType)).DecodeFieldSignature(_handle, out isVolatile, out customModifiers); ImmutableArray <CustomModifier> customModifiersArray = CSharpCustomModifier.Convert(customModifiers); //type = DynamicTypeDecoder.TransformType(type, customModifiersArray.Length, _handle, moduleSymbol); _lazyIsVolatile = isVolatile; TypeSymbol fixedElementType; int fixedSize; if (customModifiersArray.IsEmpty && IsFixedBuffer(out fixedSize, out fixedElementType)) { _lazyFixedSize = fixedSize; _lazyFixedImplementationType = type as NamedTypeSymbol; //type = new PointerTypeSymbol(fixedElementType); throw new NotImplementedException(); } ImmutableInterlocked.InterlockedCompareExchange(ref _lazyCustomModifiers, customModifiersArray, default(ImmutableArray <CustomModifier>)); Interlocked.CompareExchange(ref _lazyType, type, null); } }
internal override TypeSymbol MakePointerTypeSymbol(PEModuleSymbol moduleSymbol, TypeSymbol type, ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers) { if (type is UnsupportedMetadataTypeSymbol) { return(type); } return(new PointerTypeSymbol(type, CSharpCustomModifier.Convert(customModifiers))); }
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 }
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 override TypeSymbol SubstituteTypeParameters( PEModuleSymbol moduleSymbol, TypeSymbol genericTypeDef, ImmutableArray <KeyValuePair <TypeSymbol, ImmutableArray <ModifierInfo <TypeSymbol> > > > arguments, ImmutableArray <bool> refersToNoPiaLocalType) { if (genericTypeDef is UnsupportedMetadataTypeSymbol) { return(genericTypeDef); } // Let's return unsupported metadata type if any argument is unsupported metadata type foreach (var arg in arguments) { if (arg.Key.Kind == SymbolKind.ErrorType && arg.Key is UnsupportedMetadataTypeSymbol) { return(new UnsupportedMetadataTypeSymbol()); } } NamedTypeSymbol genericType = (NamedTypeSymbol)genericTypeDef; //// See if it is or its enclosing type is a non-interface closed over NoPia local types. //ImmutableArray<AssemblySymbol> linkedAssemblies = moduleSymbol.ContainingAssembly.GetLinkedReferencedAssemblies(); //bool noPiaIllegalGenericInstantiation = false; //if (!linkedAssemblies.IsDefaultOrEmpty || moduleSymbol.Module.ContainsNoPiaLocalTypes()) //{ // NamedTypeSymbol typeToCheck = genericType; // int argumentIndex = refersToNoPiaLocalType.Length - 1; // do // { // if (!typeToCheck.IsInterface) // { // break; // } // else // { // argumentIndex -= typeToCheck.Arity; // } // typeToCheck = typeToCheck.ContainingType; // } // while ((object)typeToCheck != null); // for (int i = argumentIndex; i >= 0; i--) // { // if (refersToNoPiaLocalType[i] || // (!linkedAssemblies.IsDefaultOrEmpty && // MetadataDecoder.IsOrClosedOverATypeFromAssemblies(arguments[i].Key, linkedAssemblies))) // { // noPiaIllegalGenericInstantiation = true; // break; // } // } //} // Collect generic parameters for the type and its containers in the order // that matches passed in arguments, i.e. sorted by the nesting. ImmutableArray <TypeParameterSymbol> typeParameters = genericType.GetAllTypeParameters(); Debug.Assert(typeParameters.Length > 0); if (typeParameters.Length != arguments.Length) { return(new UnsupportedMetadataTypeSymbol()); } TypeMap substitution = new TypeMap(typeParameters, arguments.SelectAsArray(arg => new TypeWithModifiers(arg.Key, CSharpCustomModifier.Convert(arg.Value)))); NamedTypeSymbol constructedType = substitution.SubstituteNamedType(genericType); //if (noPiaIllegalGenericInstantiation) //{ // constructedType = new NoPiaIllegalGenericInstantiationSymbol(moduleSymbol, constructedType); //} return(constructedType); }
internal override TypeSymbol GetSZArrayTypeSymbol(PEModuleSymbol moduleSymbol, TypeSymbol elementType, ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers) { if (elementType is UnsupportedMetadataTypeSymbol) { return(elementType); } return(ArrayTypeSymbol.CreateSZArray(moduleSymbol.ContainingAssembly, elementType, CSharpCustomModifier.Convert(customModifiers))); }
internal override TypeSymbol GetMDArrayTypeSymbol(PEModuleSymbol moduleSymbol, int rank, TypeSymbol elementType, ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers, ImmutableArray <int> sizes, ImmutableArray <int> lowerBounds) { if (elementType is UnsupportedMetadataTypeSymbol) { return(elementType); } return(ArrayTypeSymbol.CreateMDArray(moduleSymbol.ContainingAssembly, elementType, rank, sizes, lowerBounds, CSharpCustomModifier.Convert(customModifiers))); }
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; } }