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;
}
_lazyUseSiteDiagnostic = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this);
}
}
internal static string GetDocumentationComment(
Symbol symbol,
PEModuleSymbol containingPEModule,
CultureInfo preferredCulture,
CancellationToken cancellationToken,
ref Tuple<CultureInfo, string> lazyDocComment)
{
// Have we cached anything?
if (lazyDocComment == null)
{
Interlocked.CompareExchange(
ref lazyDocComment,
Tuple.Create(
preferredCulture,
containingPEModule.DocumentationProvider.GetDocumentationForSymbol(
symbol.GetDocumentationCommentId(), preferredCulture, cancellationToken)),
null);
}
// Does the cached version match the culture we asked for?
if (object.Equals(lazyDocComment.Item1, preferredCulture))
{
return lazyDocComment.Item2;
}
// We've already cached a different culture - create a fresh version.
return containingPEModule.DocumentationProvider.GetDocumentationForSymbol(
symbol.GetDocumentationCommentId(), preferredCulture, cancellationToken);
}
public MemberRefMetadataDecoder(
PEModuleSymbol moduleSymbol,
TypeSymbol containingType) :
base(moduleSymbol, containingType as PENamedTypeSymbol)
{
Debug.Assert((object)containingType != null);
_containingType = containingType;
}
/// <summary>
/// Get the ObsoleteAttributeData by fetching attributes and decoding ObsoleteAttributeData. This can be
/// done for Metadata symbol easily whereas trying to do this for source symbols could result in cycles.
/// </summary>
internal static ObsoleteAttributeData GetObsoleteDataFromMetadata(EntityHandle token, PEModuleSymbol containingModule)
{
ObsoleteAttributeData obsoleteAttributeData;
bool isObsolete = containingModule.Module.HasDeprecatedOrObsoleteAttribute(token, out obsoleteAttributeData);
Debug.Assert(isObsolete == (obsoleteAttributeData != null));
Debug.Assert(obsoleteAttributeData == null || !obsoleteAttributeData.IsUninitialized);
return obsoleteAttributeData;
}
/// <summary>
/// Initialize the ObsoleteAttributeData by fetching attributes and decoding ObsoleteAttributeData. This can be
/// done for Metadata symbol easily whereas trying to do this for source symbols could result in cycles.
/// </summary>
internal static void InitializeObsoleteDataFromMetadata(ref ObsoleteAttributeData data, EntityHandle token, PEModuleSymbol containingModule)
{
if (ReferenceEquals(data, ObsoleteAttributeData.Uninitialized))
{
ObsoleteAttributeData obsoleteAttributeData = GetObsoleteDataFromMetadata(token, containingModule);
Interlocked.CompareExchange(ref data, obsoleteAttributeData, ObsoleteAttributeData.Uninitialized);
}
}
internal PETypeParameterSymbol(
PEModuleSymbol moduleSymbol,
PEMethodSymbol definingMethod,
ushort ordinal,
GenericParameterHandle handle)
: this(moduleSymbol, (Symbol)definingMethod, ordinal, handle)
{
}
internal PEParameterSymbol(
PEModuleSymbol moduleSymbol,
PEMethodSymbol containingSymbol,
int ordinal,
MetadataDecoder.ParamInfo parameter,
out bool isBad)
: this(moduleSymbol, containingSymbol, ordinal, parameter.IsByRef, parameter.HasByRefBeforeCustomModifiers, parameter.Type, parameter.Handle, parameter.CustomModifiers, out isBad)
{
}
/// <summary>
/// Initialize the ObsoleteAttributeData by fetching attributes and decoding ObsoleteAttributeData. This can be
/// done for Metadata symbol easily whereas trying to do this for source symbols could result in cycles.
/// </summary>
internal static void InitializeObsoleteDataFromMetadata(ref ObsoleteAttributeData data, Handle token, PEModuleSymbol containingModule)
{
if (ReferenceEquals(data, ObsoleteAttributeData.Uninitialized))
{
ObsoleteAttributeData obsoleteAttributeData;
bool isObsolete = containingModule.Module.HasDeprecatedOrObsoleteAttribute(token, out obsoleteAttributeData);
Debug.Assert(isObsolete == (obsoleteAttributeData != null));
Debug.Assert(obsoleteAttributeData == null || !obsoleteAttributeData.IsUninitialized);
Interlocked.CompareExchange(ref data, obsoleteAttributeData, ObsoleteAttributeData.Uninitialized);
}
}
/// <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));
}
/// <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,
Symbol nullableContext,
out bool isBad)
{
return(Create(
moduleSymbol, containingSymbol, isContainingSymbolVirtual, ordinal,
parameterInfo.IsByRef, parameterInfo.RefCustomModifiers, parameterInfo.Type,
handle, nullableContext, parameterInfo.CustomModifiers, isReturn: false, out isBad));
}
private MetadataDecoder GetDecoderForConstraintTypes(PEModuleSymbol moduleSymbol)
{
MetadataDecoder tokenDecoder;
if (_containingSymbol.Kind == SymbolKind.Method)
{
tokenDecoder = new MetadataDecoder(moduleSymbol, (PEMethodSymbol)_containingSymbol);
}
else
{
tokenDecoder = new MetadataDecoder(moduleSymbol, (PENamedTypeSymbol)_containingSymbol);
}
return(tokenDecoder);
}
// https://github.com/dotnet/roslyn/issues/29821 external annotations should be removed or fully designed/productized
internal static TypeWithAnnotations TransformType(
TypeWithAnnotations 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));
}
}
// 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,
INonNullTypesContext nonNullTypesContext,
ImmutableArray <bool> extraAnnotations)
{
if (extraAnnotations.IsDefault)
{
return(NullableTypeDecoder.TransformType(metadataType, targetSymbolToken, containingModule, nonNullTypesContext));
}
else
{
return(NullableTypeDecoder.TransformType(metadataType, extraAnnotations, NonNullTypesTrueContext.Instance));
}
}
internal static PEParameterSymbol Create(
PEModuleSymbol moduleSymbol,
PEMethodSymbol containingSymbol,
bool isContainingSymbolVirtual,
int ordinal,
ParamInfo <TypeSymbol> parameterInfo,
Symbol nullableContext,
ImmutableArray <byte> extraAnnotations,
bool isReturn,
out bool isBad)
{
return(Create(
moduleSymbol, containingSymbol, isContainingSymbolVirtual, ordinal,
parameterInfo.IsByRef, parameterInfo.RefCustomModifiers, parameterInfo.Type, extraAnnotations,
parameterInfo.Handle, nullableContext, parameterInfo.CustomModifiers, isReturn, out isBad));
}
public PEPropertySymbolWithCustomModifiers(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
PropertyDefinitionHandle handle,
PEMethodSymbol getMethod,
PEMethodSymbol setMethod,
ParamInfo <TypeSymbol>[] propertyParams,
MetadataDecoder metadataDecoder)
: base(moduleSymbol, containingType, handle, getMethod, setMethod,
propertyParams,
metadataDecoder)
{
var returnInfo = propertyParams[0];
_refCustomModifiers = CSharpCustomModifier.Convert(returnInfo.RefCustomModifiers);
}
private TypeWithAnnotations GetConstraintTypeOrDefault(PEModuleSymbol moduleSymbol, MetadataReader metadataReader, MetadataDecoder tokenDecoder, GenericParameterConstraintHandle constraintHandle, ref bool hasUnmanagedModreqPattern)
{
var constraint = metadataReader.GetGenericParameterConstraint(constraintHandle);
var typeSymbol = tokenDecoder.DecodeGenericParameterConstraint(constraint.Type, out bool hasUnmanagedModreq);
if (typeSymbol.SpecialType == SpecialType.System_ValueType)
{
// recognize "(class [mscorlib]System.ValueType modreq([mscorlib]System.Runtime.InteropServices.UnmanagedType" pattern as "unmanaged"
if (hasUnmanagedModreq)
{
hasUnmanagedModreqPattern = true;
}
// Drop 'System.ValueType' constraint type if the 'valuetype' constraint was also specified.
if (((_flags & GenericParameterAttributes.NotNullableValueTypeConstraint) != 0))
{
return(default);
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;
}
internal PEAssemblySymbol(PEAssembly assembly, DocumentationProvider documentationProvider, bool isLinked, MetadataImportOptions importOptions)
{
Debug.Assert(assembly != null);
Debug.Assert(documentationProvider != null);
this.assembly = assembly;
this.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);
}
this.modules = modules.AsImmutableOrNull();
this.isLinked = isLinked;
}
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);
}
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,
TypeWithAnnotations type,
ParameterHandle handle,
Symbol nullableContext,
out bool isBad) :
base(moduleSymbol, containingSymbol, ordinal, isByRef, type, handle, nullableContext,
refCustomModifiers.NullToEmpty().Length + type.CustomModifiers.Length,
out isBad)
{
_refCustomModifiers = CSharpCustomModifier.Convert(refCustomModifiers);
Debug.Assert(_refCustomModifiers.IsEmpty || isByRef);
}
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));
}
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));
}
public static TypeSymbol DecodeTupleTypesIfApplicable(
TypeSymbol metadataType,
EntityHandle targetSymbolToken,
PEModuleSymbol containingModule)
{
ImmutableArray<string> elementNames;
var hasTupleElementNamesAttribute = containingModule
.Module
.HasTupleElementNamesAttribute(targetSymbolToken, out elementNames);
// If we have the TupleElementNamesAttribute, but no names, that's
// bad metadata
if (hasTupleElementNamesAttribute && elementNames.IsDefaultOrEmpty)
{
return new UnsupportedMetadataTypeSymbol();
}
return DecodeTupleTypesInternal(metadataType, containingModule.ContainingAssembly, elementNames, hasTupleElementNamesAttribute);
}
private TypeWithAnnotations GetConstraintTypeOrDefault(
PEModuleSymbol moduleSymbol,
MetadataReader metadataReader,
MetadataDecoder tokenDecoder,
GenericParameterConstraintHandle constraintHandle,
ref bool hasUnmanagedModreqPattern
)
{
var constraint = metadataReader.GetGenericParameterConstraint(constraintHandle);
var typeSymbol = tokenDecoder.DecodeGenericParameterConstraint(
constraint.Type,
out ImmutableArray <ModifierInfo <TypeSymbol> > modifiers
);
if (!modifiers.IsDefaultOrEmpty && modifiers.Length > 1)
{
typeSymbol = new UnsupportedMetadataTypeSymbol();
}
else if (typeSymbol.SpecialType == SpecialType.System_ValueType)
{
// recognize "(class [mscorlib]System.ValueType modreq([mscorlib]System.Runtime.InteropServices.UnmanagedType" pattern as "unmanaged"
if (!modifiers.IsDefaultOrEmpty)
{
ModifierInfo <TypeSymbol> m = modifiers.Single();
if (!m.IsOptional && m.Modifier.IsWellKnownTypeUnmanagedType())
{
hasUnmanagedModreqPattern = true;
}
else
{
// Any other modifiers, optional or not, are not allowed: http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/528856
typeSymbol = new UnsupportedMetadataTypeSymbol();
}
}
// Drop 'System.ValueType' constraint type if the 'valuetype' constraint was also specified.
if (
typeSymbol.SpecialType == SpecialType.System_ValueType &&
((_flags & GenericParameterAttributes.NotNullableValueTypeConstraint) != 0)
)
{
return(default);
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,
Symbol nullableContext,
ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers,
bool isReturn,
out bool isBad)
{
// We start without annotation (they will be decoded below)
var typeWithModifiers = TypeWithAnnotations.Create(type, customModifiers: CSharpCustomModifier.Convert(customModifiers));
PEParameterSymbol parameter = customModifiers.IsDefaultOrEmpty && refCustomModifiers.IsDefaultOrEmpty
? new PEParameterSymbol(moduleSymbol, containingSymbol, ordinal, isByRef, typeWithModifiers, extraAnnotations, handle, nullableContext, 0, out isBad)
: new PEParameterSymbolWithCustomModifiers(moduleSymbol, containingSymbol, ordinal, isByRef, refCustomModifiers, typeWithModifiers, extraAnnotations, handle, nullableContext, 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);
}
internal static TypeWithAnnotations TransformType(
TypeWithAnnotations metadataType,
EntityHandle targetSymbolToken,
PEModuleSymbol containingModule,
Symbol accessSymbol,
Symbol nullableContext
)
{
Debug.Assert(metadataType.HasType);
Debug.Assert(accessSymbol.IsDefinition);
Debug.Assert((object)accessSymbol.ContainingModule == containingModule);
#if DEBUG
// Ensure we could check accessibility at this point if we had to in ShouldDecodeNullableAttributes().
// That is, ensure the accessibility of the symbol (and containing symbols) is available.
_ = AccessCheck.IsEffectivelyPublicOrInternal(accessSymbol, out _);
#endif
byte defaultTransformFlag;
ImmutableArray <byte> nullableTransformFlags;
if (
!containingModule.Module.HasNullableAttribute(
targetSymbolToken,
out defaultTransformFlag,
out nullableTransformFlags
)
)
{
byte?value = nullableContext.GetNullableContextValue();
if (value == null)
{
return(metadataType);
}
defaultTransformFlag = value.GetValueOrDefault();
}
if (!containingModule.ShouldDecodeNullableAttributes(accessSymbol))
{
return(metadataType);
}
return(TransformType(metadataType, defaultTransformFlag, nullableTransformFlags));
}
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;
}
_lazyCachedConstraintsUseSiteInfo.Initialize(
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;
}
/// <summary>
/// Decodes the attributes applied to the given <see paramref="targetSymbol"/> from metadata and checks if <see cref="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 <see cref="System.Runtime.CompilerServices.DynamicAttribute"/> is applied or the decoded dynamic transforms attribute argument is errorneous,
/// 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,
Handle 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);
}
// No DynamicAttribute applied to the target symbol, return unchanged metadataType.
return metadataType;
}
public static TypeSymbol DecodeTupleTypesIfApplicable(
TypeSymbol metadataType,
EntityHandle targetSymbolToken,
PEModuleSymbol containingModule)
{
Debug.Assert((object)metadataType != null);
Debug.Assert((object)containingModule != null);
ImmutableArray<string> elementNames;
var hasTupleElementNamesAttribute = containingModule
.Module
.HasTupleElementNamesAttribute(targetSymbolToken, out elementNames);
// If we have the TupleElementNamesAttribute, but no names, that's
// bad metadata
if (hasTupleElementNamesAttribute && elementNames.IsDefaultOrEmpty)
{
return new UnsupportedMetadataTypeSymbol();
}
var decoder = new TupleTypeDecoder(elementNames,
containingModule.ContainingAssembly);
try
{
var decoded = decoder.DecodeType(metadataType);
// If not all of the names have been used, the metadata is bad
if (!hasTupleElementNamesAttribute ||
decoder._namesIndex == 0)
{
return decoded;
}
}
catch (InvalidOperationException)
{
// Indicates that the tuple info in the attribute didn't match
// the type. Bad metadata.
}
// Bad metadata
return new UnsupportedMetadataTypeSymbol();
}
public PEPropertySymbolWithCustomModifiers(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
PropertyDefinitionHandle handle,
PEMethodSymbol getMethod,
PEMethodSymbol setMethod,
ParamInfo <TypeSymbol>[] propertyParams,
MetadataDecoder metadataDecoder,
out bool isBad)
: base(moduleSymbol, containingType, handle, getMethod, setMethod,
propertyParams[0].CustomModifiers.NullToEmpty().Length + propertyParams[0].RefCustomModifiers.NullToEmpty().Length,
propertyParams, metadataDecoder)
{
var returnInfo = propertyParams[0];
_typeCustomModifiers = CSharpCustomModifier.Convert(returnInfo.CustomModifiers);
_refCustomModifiers = CSharpCustomModifier.Convert(returnInfo.RefCustomModifiers);
// The modreq is only accepted on RefReadOnly symbols
isBad = this.RefKind != RefKind.RefReadOnly && _refCustomModifiers.Any(modifier => !modifier.IsOptional && modifier.Modifier.IsWellKnownTypeInAttribute());
}
/// <summary>
/// Decodes the attributes applied to the given <see paramref="targetSymbol"/> from metadata and checks if <see cref="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 <see cref="System.Runtime.CompilerServices.DynamicAttribute"/> is applied or the decoded dynamic transforms attribute argument is errorneous,
/// 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,
Handle 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));
}
// No DynamicAttribute applied to the target symbol, return unchanged metadataType.
return(metadataType);
}
internal static PEPropertySymbol Create(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
PropertyDefinitionHandle handle,
PEMethodSymbol getMethod,
PEMethodSymbol setMethod)
{
Debug.Assert((object)moduleSymbol != null);
Debug.Assert((object)containingType != null);
#if !XSHARP
Debug.Assert(!handle.IsNil);
#endif
var metadataDecoder = new MetadataDecoder(moduleSymbol, containingType);
SignatureHeader callingConvention;
BadImageFormatException propEx;
#if XSHARP
var propertyParams = handle.IsNil ? metadataDecoder.GetSignatureForMethod(getMethod.Handle, out callingConvention, out propEx)
: metadataDecoder.GetSignatureForProperty(handle, out callingConvention, out propEx);
#else
var propertyParams = metadataDecoder.GetSignatureForProperty(handle, out callingConvention, out propEx);
#endif
Debug.Assert(propertyParams.Length > 0);
var returnInfo = propertyParams[0];
PEPropertySymbol result = returnInfo.CustomModifiers.IsDefaultOrEmpty && returnInfo.RefCustomModifiers.IsDefaultOrEmpty
? new PEPropertySymbol(moduleSymbol, containingType, handle, getMethod, setMethod, 0, propertyParams, metadataDecoder)
: new PEPropertySymbolWithCustomModifiers(moduleSymbol, containingType, handle, getMethod, setMethod, propertyParams, metadataDecoder);
// A property should always have this modreq, and vice versa.
var isBad = (result.RefKind == RefKind.In) != result.RefCustomModifiers.HasInAttributeModifier();
if (propEx != null || isBad)
{
result._lazyUseSiteDiagnostic = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, result);
}
return(result);
}
private static ImmutableArray <ParameterSymbol> GetParameters(
PEModuleSymbol moduleSymbol,
PEPropertySymbol property,
ParamInfo <TypeSymbol>[] propertyParams,
ParamInfo <TypeSymbol>[] accessorParams,
bool isPropertyVirtual,
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, isPropertyVirtual, ordinal, paramHandle, propertyParam, nullableContext: property, out isBad);
if (isBad)
{
anyParameterIsBad = true;
}
}
return(parameters.AsImmutableOrNull());
}
internal static PEPropertySymbol Create(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
PropertyDefinitionHandle handle,
PEMethodSymbol getMethod,
PEMethodSymbol setMethod)
{
Debug.Assert((object)moduleSymbol != null);
Debug.Assert((object)containingType != null);
Debug.Assert(!handle.IsNil);
var metadataDecoder = new MetadataDecoder(moduleSymbol, containingType);
SignatureHeader callingConvention;
BadImageFormatException propEx;
var propertyParams = metadataDecoder.GetSignatureForProperty(handle, out callingConvention, out propEx);
Debug.Assert(propertyParams.Length > 0);
var isBad = false;
var returnInfo = propertyParams[0];
PEPropertySymbol result;
if (returnInfo.CustomModifiers.IsDefaultOrEmpty && returnInfo.RefCustomModifiers.IsDefaultOrEmpty)
{
result = new PEPropertySymbol(moduleSymbol, containingType, handle, getMethod, setMethod, 0, propertyParams, metadataDecoder);
}
else
{
result = new PEPropertySymbolWithCustomModifiers(moduleSymbol, containingType, handle, getMethod, setMethod, propertyParams, metadataDecoder, out isBad);
}
if (propEx != null || isBad)
{
result._lazyUseSiteDiagnostic = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, result);
}
return(result);
}
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(this.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 static PEParameterSymbol Create(
PEModuleSymbol moduleSymbol,
Symbol containingSymbol,
bool isContainingSymbolVirtual,
int ordinal,
bool isByRef,
ImmutableArray <ModifierInfo <TypeSymbol> > refCustomModifiers,
TypeSymbol type,
ParameterHandle handle,
ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers,
bool isReturn,
out bool isBad)
{
PEParameterSymbol parameter = customModifiers.IsDefaultOrEmpty && refCustomModifiers.IsDefaultOrEmpty
? new PEParameterSymbol(moduleSymbol, containingSymbol, ordinal, isByRef, type, handle, 0, out isBad)
: new PEParameterSymbolWithCustomModifiers(moduleSymbol, containingSymbol, ordinal, isByRef, refCustomModifiers, type, handle, customModifiers, 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);
}
internal static PEPropertySymbol Create(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
PropertyDefinitionHandle handle,
PEMethodSymbol getMethod,
PEMethodSymbol setMethod)
{
Debug.Assert((object)moduleSymbol != null);
Debug.Assert((object)containingType != null);
Debug.Assert(!handle.IsNil);
var metadataDecoder = new MetadataDecoder(moduleSymbol, containingType);
SignatureHeader callingConvention;
BadImageFormatException propEx;
var propertyParams = metadataDecoder.GetSignatureForProperty(handle, out callingConvention, out propEx);
Debug.Assert(propertyParams.Length > 0);
var returnInfo = propertyParams[0];
PEPropertySymbol result;
if (returnInfo.CustomModifiers.IsDefaultOrEmpty && returnInfo.RefCustomModifiers.IsDefaultOrEmpty)
{
result = new PEPropertySymbol(moduleSymbol, containingType, handle, getMethod, setMethod, 0, propertyParams, metadataDecoder);
}
else
{
result = new PEPropertySymbolWithCustomModifiers(moduleSymbol, containingType, handle, getMethod, setMethod, propertyParams, metadataDecoder);
}
if (propEx != null)
{
result._lazyUseSiteDiagnostic = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, result);
}
return result;
}
public static TypeWithAnnotations DecodeTupleTypesIfApplicable(
TypeWithAnnotations 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(TypeWithAnnotations.Create(new UnsupportedMetadataTypeSymbol()));
}
TypeSymbol type = metadataType.Type;
TypeSymbol decoded = DecodeTupleTypesInternal(type, elementNames, hasTupleElementNamesAttribute);
return((object)decoded == (object)type ?
metadataType :
TypeWithAnnotations.Create(decoded, metadataType.NullableAnnotation, metadataType.CustomModifiers));
}
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;
}
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 = new UnsupportedMetadataTypeSymbol(mrEx);
}
}
if ((object)_eventType == null)
{
var metadataDecoder = new MetadataDecoder(moduleSymbol, containingType);
_eventType = metadataDecoder.GetTypeOfToken(eventType);
}
// IsWindowsRuntimeEvent checks the signatures, so we just have to check the accessors.
bool isWindowsRuntimeEvent = IsWindowsRuntimeEvent;
bool callMethodsDirectly = isWindowsRuntimeEvent
? !DoModifiersMatch(_addMethod, _removeMethod)
: !DoSignaturesMatch(moduleSymbol, _eventType, _addMethod, _removeMethod);
if (callMethodsDirectly)
{
_flags |= Flags.CallMethodsDirectly;
}
else
{
_addMethod.SetAssociatedEvent(this, MethodKind.EventAdd);
_removeMethod.SetAssociatedEvent(this, MethodKind.EventRemove);
PEFieldSymbol associatedField = GetAssociatedField(privateFieldNameToSymbols, isWindowsRuntimeEvent);
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;
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="underlyingAssembly">
/// The underlying AssemblySymbol, cannot be an instance of RetargetingAssemblySymbol.
/// </param>
/// <param name="isLinked">
/// Assembly is /l-ed by compilation that is using it as a reference.
/// </param>
public RetargetingAssemblySymbol(SourceAssemblySymbol underlyingAssembly, bool isLinked)
{
Debug.Assert((object)underlyingAssembly != null);
_underlyingAssembly = underlyingAssembly;
ModuleSymbol[] modules = new ModuleSymbol[underlyingAssembly.Modules.Length];
modules[0] = new RetargetingModuleSymbol(this, (SourceModuleSymbol)underlyingAssembly.Modules[0]);
for (int i = 1; i < underlyingAssembly.Modules.Length; i++)
{
PEModuleSymbol under = (PEModuleSymbol)underlyingAssembly.Modules[i];
modules[i] = new PEModuleSymbol(this, under.Module, under.ImportOptions, i);
}
_modules = modules.AsImmutableOrNull();
_isLinked = isLinked;
}
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 = GetParameters(moduleSymbol, this, propertyParams, setMethodParams ?? getMethodParams, out isBad);
if (getEx != null || setEx != null || mrEx != null || isBad)
{
_lazyUseSiteDiagnostic = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this);
}
var returnInfo = propertyParams[0];
_refKind = returnInfo.IsByRef ? RefKind.Ref : RefKind.None;
// CONSIDER: Can we make parameter type computation lazy?
TypeSymbol originalPropertyType = returnInfo.Type;
_propertyType = DynamicTypeDecoder.TransformType(originalPropertyType, countOfCustomModifiers, handle, moduleSymbol, _refKind);
// Dynamify object type if necessary
_propertyType = _propertyType.AsDynamicIfNoPia(_containingType);
_propertyType = TupleTypeDecoder.DecodeTupleTypesIfApplicable(_propertyType, handle, moduleSymbol);
// 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 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 ((object)_name == null)
{
_name = string.Empty;
}
InitializeUseSiteDiagnostic(new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this));
}
Debug.Assert((uint)localflags <= ushort.MaxValue);
_flags = (ushort)localflags;
}
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 = TupleTypeSymbol.TransformToTupleIfCompatible(type);
_type = type;
_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?
type = DynamicTypeDecoder.TransformType(type, countOfCustomModifiers, handle, moduleSymbol, refKind);
_type = TupleTypeDecoder.DecodeTupleTypesIfApplicable(type, handle, moduleSymbol);
}
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 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 = new UnsupportedMetadataTypeSymbol(mrEx);
}
}
TypeSymbol originalEventType = _eventType;
if ((object)_eventType == null)
{
var metadataDecoder = new MetadataDecoder(moduleSymbol, containingType);
originalEventType = metadataDecoder.GetTypeOfToken(eventType);
const int targetSymbolCustomModifierCount = 0;
_eventType = DynamicTypeDecoder.TransformType(originalEventType, targetSymbolCustomModifierCount, handle, moduleSymbol);
_eventType = TupleTypeDecoder.DecodeTupleTypesIfApplicable(_eventType, handle, moduleSymbol);
}
// IsWindowsRuntimeEvent checks the signatures, so we just have to check the accessors.
bool isWindowsRuntimeEvent = IsWindowsRuntimeEvent;
bool callMethodsDirectly = isWindowsRuntimeEvent
? !DoModifiersMatch(_addMethod, _removeMethod)
: !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, isWindowsRuntimeEvent);
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;
}
}
/// <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);
}
internal PEAttributeData(PEModuleSymbol moduleSymbol, CustomAttributeHandle handle)
{
_decoder = new MetadataDecoder(moduleSymbol);
_handle = handle;
}
private static Binder CreateBinderChain(
CSharpCompilation compilation,
PEModuleSymbol module,
NamespaceSymbol @namespace,
ImmutableArray<ImmutableArray<ImportRecord>> importRecordGroups)
{
var stack = ArrayBuilder<string>.GetInstance();
while ((object)@namespace != null)
{
stack.Push(@namespace.Name);
@namespace = @namespace.ContainingNamespace;
}
Binder binder = new BuckStopsHereBinder(compilation);
var hasImports = !importRecordGroups.IsDefaultOrEmpty;
var numImportStringGroups = hasImports ? importRecordGroups.Length : 0;
var currentStringGroup = numImportStringGroups - 1;
// PERF: We used to call compilation.GetCompilationNamespace on every iteration,
// but that involved walking up to the global namespace, which we have to do
// anyway. Instead, we'll inline the functionality into our own walk of the
// namespace chain.
@namespace = compilation.GlobalNamespace;
while (stack.Count > 0)
{
var namespaceName = stack.Pop();
if (namespaceName.Length > 0)
{
// We're re-getting the namespace, rather than using the one containing
// the current frame method, because we want the merged namespace.
@namespace = @namespace.GetNestedNamespace(namespaceName);
Debug.Assert((object)@namespace != null,
$"We worked backwards from symbols to names, but no symbol exists for name '{namespaceName}'");
}
else
{
Debug.Assert((object)@namespace == (object)compilation.GlobalNamespace);
}
Imports imports = null;
if (hasImports)
{
if (currentStringGroup < 0)
{
Debug.WriteLine($"No import string group for namespace '{@namespace}'");
break;
}
var importsBinder = new InContainerBinder(@namespace, binder);
imports = BuildImports(compilation, module, importRecordGroups[currentStringGroup], importsBinder);
currentStringGroup--;
}
binder = new InContainerBinder(@namespace, binder, imports);
}
stack.Free();
if (currentStringGroup >= 0)
{
// CONSIDER: We could lump these into the outermost namespace. It's probably not worthwhile since
// the usings are already for the wrong method.
Debug.WriteLine($"Found {currentStringGroup + 1} import string groups without corresponding namespaces");
}
return binder;
}
internal PEPropertySymbol(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
PropertyHandle handle,
PEMethodSymbol getMethod,
PEMethodSymbol setMethod)
{
Debug.Assert((object)moduleSymbol != null);
Debug.Assert((object)containingType != null);
Debug.Assert(!handle.IsNil);
this.containingType = containingType;
var module = moduleSymbol.Module;
PropertyAttributes mdFlags = 0;
BadImageFormatException mrEx = null;
try
{
module.GetPropertyDefPropsOrThrow(handle, out this.name, out mdFlags);
}
catch (BadImageFormatException e)
{
mrEx = e;
if ((object)this.name == null)
{
this.name = string.Empty;
}
}
this.getMethod = getMethod;
this.setMethod = setMethod;
this.handle = handle;
var metadataDecoder = new MetadataDecoder(moduleSymbol, containingType);
byte callingConvention;
BadImageFormatException propEx;
var propertyParams = metadataDecoder.GetSignatureForProperty(handle, out callingConvention, out propEx);
Debug.Assert(propertyParams.Length > 0);
byte 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;
this.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);
}
this.typeCustomModifiers = CSharpCustomModifier.Convert(propertyParams[0].CustomModifiers);
// CONSIDER: Can we make parameter type computation lazy?
TypeSymbol originalPropertyType = propertyParams[0].Type;
this.propertyType = DynamicTypeDecoder.TransformType(originalPropertyType, typeCustomModifiers.Length, handle, moduleSymbol);
// Dynamify object type if necessary
this.propertyType = this.propertyType.AsDynamicIfNoPia(this.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, this.getMethod, getMethodParams, this.setMethod, setMethodParams) ||
MustCallMethodsDirectlyCore();
if (!callMethodsDirectly)
{
if ((object)this.getMethod != null)
{
this.getMethod.SetAssociatedProperty(this, MethodKind.PropertyGet);
}
if ((object)this.setMethod != null)
{
this.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;
}
}
private static ImmutableArray<ParameterSymbol> GetParameters(
PEModuleSymbol moduleSymbol,
PEPropertySymbol property,
MetadataDecoder.ParamInfo[] propertyParams,
MetadataDecoder.ParamInfo[] 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] = new PEParameterSymbol(moduleSymbol, property, ordinal, paramHandle, propertyParam, out isBad);
if (isBad)
{
anyParameterIsBad = true;
}
}
return parameters.AsImmutableOrNull();
}
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);
}
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,
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 = TupleTypeSymbol.TransformToTupleIfCompatible(type); // temporary shallow unification
_type = type;
_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);
refKind = (inOutFlags == ParameterAttributes.Out) ? RefKind.Out : RefKind.Ref;
}
// CONSIDER: Can we make parameter type computation lazy?
type = DynamicTypeDecoder.TransformType(type, countOfCustomModifiers, handle, moduleSymbol, refKind);
_type = TupleTypeSymbol.TransformToTupleIfCompatible(type); // temporary shallow unification
}
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 static bool DoSignaturesMatch(
PEModuleSymbol moduleSymbol,
TypeSymbol eventType,
PEMethodSymbol addMethod,
PEMethodSymbol removeMethod)
{
return
(eventType.IsDelegateType() || eventType.IsErrorType()) &&
DoesSignatureMatch(moduleSymbol, eventType, addMethod) &&
DoesSignatureMatch(moduleSymbol, eventType, removeMethod) &&
DoModifiersMatch(addMethod, removeMethod);
}
private static PENamedTypeSymbol GetType(PEModuleSymbol module, TypeDefinitionHandle typeHandle)
{
var metadataDecoder = new MetadataDecoder(module);
return (PENamedTypeSymbol)metadataDecoder.GetTypeOfToken(typeHandle);
}
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);
}
private PEPropertySymbol(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
PropertyDefinitionHandle handle,
PEMethodSymbol getMethod,
PEMethodSymbol setMethod,
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);
originalPropertyType = NativeIntegerTypeDecoder.TransformType(originalPropertyType, handle, moduleSymbol);
// Dynamify object type if necessary
originalPropertyType = originalPropertyType.AsDynamicIfNoPia(_containingType);
// We start without annotation (they will be decoded below)
var propertyTypeWithAnnotations = TypeWithAnnotations.Create(originalPropertyType, customModifiers: typeCustomModifiers);
// Decode nullable before tuple types to avoid converting between
// NamedTypeSymbol and TupleTypeSymbol unnecessarily.
// The containing type is passed to NullableTypeDecoder.TransformType to determine access
// because the property does not have explicit accessibility in metadata.
propertyTypeWithAnnotations = NullableTypeDecoder.TransformType(propertyTypeWithAnnotations, handle, moduleSymbol, accessSymbol: _containingType, nullableContext: _containingType);
propertyTypeWithAnnotations = TupleTypeDecoder.DecodeTupleTypesIfApplicable(propertyTypeWithAnnotations, handle, moduleSymbol);
_propertyTypeWithAnnotations = propertyTypeWithAnnotations;
// 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;
}
}
private PEParameterSymbol(
PEModuleSymbol moduleSymbol,
Symbol containingSymbol,
int ordinal,
bool isByRef,
bool hasByRefBeforeCustomModifiers,
TypeSymbol type,
ParameterHandle handle,
ImmutableArray<MetadataDecoder.ModifierInfo> customModifiers,
out bool isBad)
{
Debug.Assert((object)moduleSymbol != null);
Debug.Assert((object)containingSymbol != null);
Debug.Assert(ordinal >= 0);
Debug.Assert((object)type != null);
isBad = false;
this.moduleSymbol = moduleSymbol;
this.containingSymbol = containingSymbol;
this.customModifiers = CSharpCustomModifier.Convert(customModifiers);
this.ordinal = (ushort)ordinal;
this.handle = handle;
RefKind refKind = RefKind.None;
if (handle.IsNil)
{
refKind = isByRef ? RefKind.Ref : RefKind.None;
this.type = type;
this.lazyCustomAttributes = ImmutableArray<CSharpAttributeData>.Empty;
this.lazyHiddenAttributes = ImmutableArray<CSharpAttributeData>.Empty;
this.lazyWellKnownAttributeData = (int)WellKnownAttributeFlags.AllCompletedNoAttributes;
this.lazyDefaultValue = ConstantValue.NotAvailable;
this.lazyIsParams = ThreeState.False;
}
else
{
try
{
moduleSymbol.Module.GetParamPropsOrThrow(handle, out this.name, out this.flags);
}
catch (BadImageFormatException)
{
isBad = true;
}
if (isByRef)
{
ParameterAttributes inOutFlags = this.flags & (ParameterAttributes.Out | ParameterAttributes.In);
refKind = (inOutFlags == ParameterAttributes.Out) ? RefKind.Out : RefKind.Ref;
}
// CONSIDER: Can we make parameter type computation lazy?
this.type = DynamicTypeDecoder.TransformType(type, this.customModifiers.Length, handle, moduleSymbol, refKind);
}
if (string.IsNullOrEmpty(this.name))
{
// As was done historically, if the parameter doesn't have a name, we give it the name "value".
this.name = "value";
}
this.packed = Pack(refKind, hasByRefBeforeCustomModifiers);
Debug.Assert(refKind == this.RefKind);
Debug.Assert(hasByRefBeforeCustomModifiers == this.HasByRefBeforeCustomModifiers);
}
private static Imports BuildImports(CSharpCompilation compilation, PEModuleSymbol module, ImmutableArray<ImportRecord> importRecords, InContainerBinder binder)
{
// We make a first pass to extract all of the extern aliases because other imports may depend on them.
var externsBuilder = ArrayBuilder<AliasAndExternAliasDirective>.GetInstance();
foreach (var importRecord in importRecords)
{
if (importRecord.TargetKind != ImportTargetKind.Assembly)
{
continue;
}
var alias = importRecord.Alias;
IdentifierNameSyntax aliasNameSyntax;
if (!TryParseIdentifierNameSyntax(alias, out aliasNameSyntax))
{
Debug.WriteLine($"Import record '{importRecord}' has syntactically invalid extern alias '{alias}'");
continue;
}
var externAliasSyntax = SyntaxFactory.ExternAliasDirective(aliasNameSyntax.Identifier);
var aliasSymbol = new AliasSymbol(binder, externAliasSyntax); // Binder is only used to access compilation.
externsBuilder.Add(new AliasAndExternAliasDirective(aliasSymbol, externAliasDirective: null)); // We have one, but we pass null for consistency.
}
var externs = externsBuilder.ToImmutableAndFree();
if (externs.Any())
{
// NB: This binder (and corresponding Imports) is only used to bind the other imports.
// We'll merge the externs into a final Imports object and return that to be used in
// the actual binder chain.
binder = new InContainerBinder(
binder.Container,
binder,
Imports.FromCustomDebugInfo(binder.Compilation, ImmutableDictionary<string, AliasAndUsingDirective>.Empty, ImmutableArray<NamespaceOrTypeAndUsingDirective>.Empty, externs));
}
var usingAliases = ImmutableDictionary.CreateBuilder<string, AliasAndUsingDirective>();
var usingsBuilder = ArrayBuilder<NamespaceOrTypeAndUsingDirective>.GetInstance();
foreach (var importRecord in importRecords)
{
switch (importRecord.TargetKind)
{
case ImportTargetKind.Type:
{
TypeSymbol typeSymbol = (TypeSymbol)importRecord.TargetType;
Debug.Assert((object)typeSymbol != null);
if (typeSymbol.IsErrorType())
{
// Type is unrecognized. The import may have been
// valid in the original source but unnecessary.
continue; // Don't add anything for this import.
}
else if (importRecord.Alias == null && !typeSymbol.IsStatic)
{
// Only static types can be directly imported.
continue;
}
if (!TryAddImport(importRecord.Alias, typeSymbol, usingsBuilder, usingAliases, binder, importRecord))
{
continue;
}
break;
}
case ImportTargetKind.Namespace:
{
var namespaceName = importRecord.TargetString;
NameSyntax targetSyntax;
if (!SyntaxHelpers.TryParseDottedName(namespaceName, out targetSyntax))
{
// DevDiv #999086: Some previous version of VS apparently generated type aliases as "UA{alias} T{alias-qualified type name}".
// Neither Roslyn nor Dev12 parses such imports. However, Roslyn discards them, rather than interpreting them as "UA{alias}"
// (which will rarely work and never be correct).
Debug.WriteLine($"Import record '{importRecord}' has syntactically invalid target '{importRecord.TargetString}'");
continue;
}
NamespaceSymbol globalNamespace;
AssemblySymbol targetAssembly = (AssemblySymbol)importRecord.TargetAssembly;
if (targetAssembly != null)
{
if (targetAssembly.IsMissing)
{
Debug.WriteLine($"Import record '{importRecord}' has invalid assembly reference '{targetAssembly.Identity}'");
continue;
}
globalNamespace = targetAssembly.GlobalNamespace;
}
else if (importRecord.TargetAssemblyAlias != null)
{
IdentifierNameSyntax externAliasSyntax = null;
if (!TryParseIdentifierNameSyntax(importRecord.TargetAssemblyAlias, out externAliasSyntax))
{
Debug.WriteLine($"Import record '{importRecord}' has syntactically invalid extern alias '{importRecord.TargetAssemblyAlias}'");
continue;
}
var unusedDiagnostics = DiagnosticBag.GetInstance();
var aliasSymbol = (AliasSymbol)binder.BindNamespaceAliasSymbol(externAliasSyntax, unusedDiagnostics);
unusedDiagnostics.Free();
if ((object)aliasSymbol == null)
{
Debug.WriteLine($"Import record '{importRecord}' requires unknown extern alias '{importRecord.TargetAssemblyAlias}'");
continue;
}
globalNamespace = (NamespaceSymbol)aliasSymbol.Target;
}
else
{
globalNamespace = compilation.GlobalNamespace;
}
var namespaceSymbol = BindNamespace(namespaceName, globalNamespace);
if ((object)namespaceSymbol == null)
{
// Namespace is unrecognized. The import may have been
// valid in the original source but unnecessary.
continue; // Don't add anything for this import.
}
if (!TryAddImport(importRecord.Alias, namespaceSymbol, usingsBuilder, usingAliases, binder, importRecord))
{
continue;
}
break;
}
case ImportTargetKind.Assembly:
{
// Handled in first pass (above).
break;
}
default:
{
throw ExceptionUtilities.UnexpectedValue(importRecord.TargetKind);
}
}
}
return Imports.FromCustomDebugInfo(binder.Compilation, usingAliases.ToImmutableDictionary(), usingsBuilder.ToImmutableAndFree(), externs);
}