internal override ImmutableArray <string> GetAppliedConditionalSymbols()
{
if (!_packedFlags.IsConditionalPopulated)
{
var result = _containingType.ContainingPEModule.Module.GetConditionalAttributeValues(_handle);
Debug.Assert(!result.IsDefault);
if (!result.IsEmpty)
{
result = InterlockedOperations.Initialize(ref AccessUncommonFields()._lazyConditionalAttributeSymbols, result);
}
_packedFlags.SetIsConditionalAttributePopulated();
return(result);
}
var uncommonFields = _uncommonFields;
if (uncommonFields == null)
{
return(ImmutableArray <string> .Empty);
}
else
{
var result = uncommonFields._lazyConditionalAttributeSymbols;
return(result.IsDefault
? InterlockedOperations.Initialize(ref uncommonFields._lazyConditionalAttributeSymbols, ImmutableArray <string> .Empty)
: result);
}
}
public override ImmutableArray <CSharpAttributeData> GetAttributes()
{
if (!_packedFlags.IsCustomAttributesPopulated)
{
// Compute the value
var attributeData = default(ImmutableArray <CSharpAttributeData>);
var containingPEModuleSymbol = _containingType.ContainingPEModule;
// Could this possibly be an extension method?
bool alreadySet = _packedFlags.IsExtensionMethodIsPopulated;
bool checkForExtension = alreadySet
? _packedFlags.IsExtensionMethod
: this.MethodKind == MethodKind.Ordinary &&
IsValidExtensionMethodSignature() &&
_containingType.MightContainExtensionMethods;
bool isExtensionMethod = false;
if (checkForExtension)
{
containingPEModuleSymbol.LoadCustomAttributesFilterExtensions(_handle,
ref attributeData,
out isExtensionMethod);
}
else
{
containingPEModuleSymbol.LoadCustomAttributes(_handle,
ref attributeData);
}
if (!alreadySet)
{
_packedFlags.InitializeIsExtensionMethod(isExtensionMethod);
}
// Store the result in uncommon fields only if it's not empty.
Debug.Assert(!attributeData.IsDefault);
if (!attributeData.IsEmpty)
{
attributeData = InterlockedOperations.Initialize(ref AccessUncommonFields()._lazyCustomAttributes, attributeData);
}
_packedFlags.SetIsCustomAttributesPopulated();
return(attributeData);
}
// Retrieve cached or inferred value.
var uncommonFields = _uncommonFields;
if (uncommonFields == null)
{
return(ImmutableArray <CSharpAttributeData> .Empty);
}
else
{
var attributeData = uncommonFields._lazyCustomAttributes;
return(attributeData.IsDefault
? InterlockedOperations.Initialize(ref uncommonFields._lazyCustomAttributes, ImmutableArray <CSharpAttributeData> .Empty)
: attributeData);
}
}
private SignatureData LoadSignature()
{
var moduleSymbol = _containingType.ContainingPEModule;
SignatureHeader signatureHeader;
BadImageFormatException mrEx;
ParamInfo <TypeSymbol>[] paramInfo = new MetadataDecoder(moduleSymbol, this).GetSignatureForMethod(_handle, out signatureHeader, out mrEx, allowByRefReturn: true);
bool makeBad = (mrEx != null);
// If method is not generic, let's assign empty list for type parameters
if (!signatureHeader.IsGeneric &&
_lazyTypeParameters.IsDefault)
{
ImmutableInterlocked.InterlockedInitialize(ref _lazyTypeParameters,
ImmutableArray <TypeParameterSymbol> .Empty);
}
int count = paramInfo.Length - 1;
ImmutableArray <ParameterSymbol> @params;
bool isBadParameter;
if (count > 0)
{
var builder = ImmutableArray.CreateBuilder <ParameterSymbol>(count);
for (int i = 0; i < count; i++)
{
builder.Add(PEParameterSymbol.Create(moduleSymbol, this, i, paramInfo[i + 1], out isBadParameter));
if (isBadParameter)
{
makeBad = true;
}
}
@params = builder.ToImmutable();
}
else
{
@params = ImmutableArray <ParameterSymbol> .Empty;
}
// Dynamify object type if necessary
var returnType = paramInfo[0].Type.AsDynamicIfNoPia(_containingType);
// Check for tuple type
returnType = TupleTypeDecoder.DecodeTupleTypesIfApplicable(returnType, paramInfo[0].Handle, moduleSymbol);
paramInfo[0].Type = returnType;
var returnParam = PEParameterSymbol.Create(moduleSymbol, this, 0, paramInfo[0], out isBadParameter);
if (makeBad || isBadParameter)
{
InitializeUseSiteDiagnostic(new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this));
}
var signature = new SignatureData(signatureHeader, @params, returnParam);
return(InterlockedOperations.Initialize(ref _lazySignature, signature));
}
private ImmutableArray <TypeParameterSymbol> EnsureTypeParametersAreLoaded(ref DiagnosticInfo diagnosticInfo)
{
var typeParams = _lazyTypeParameters;
if (!typeParams.IsDefault)
{
return(typeParams);
}
return(InterlockedOperations.Initialize(ref _lazyTypeParameters, LoadTypeParameters(ref diagnosticInfo)));
}
private DiagnosticInfo InitializeUseSiteDiagnostic(DiagnosticInfo diagnostic)
{
Debug.Assert(!CSDiagnosticInfo.IsEmpty(diagnostic));
if (diagnostic != null)
{
diagnostic = InterlockedOperations.Initialize(ref AccessUncommonFields()._lazyUseSiteDiagnostic, diagnostic, CSDiagnosticInfo.EmptyErrorInfo);
}
_packedFlags.SetIsUseSiteDiagnosticPopulated();
return(diagnostic);
}
GetCciAdapter()
{
#if DEBUG
if (_lazyAdapter is null)
{
return(InterlockedOperations.Initialize(ref _lazyAdapter, new EventSymbolAdapter(this)));
}
return(_lazyAdapter);
#else
return(this);
#endif
}
private EmitBaseline.MetadataSymbols GetOrCreateMetadataSymbols(EmitBaseline initialBaseline, CSharpCompilation compilation)
{
if (initialBaseline.LazyMetadataSymbols != null)
{
return(initialBaseline.LazyMetadataSymbols);
}
var originalMetadata = initialBaseline.OriginalMetadata;
// The purpose of this compilation is to provide PE symbols for original metadata.
// We need to transfer the references from the current source compilation but don't need its syntax trees.
var metadataCompilation = compilation.RemoveAllSyntaxTrees();
var metadataAssembly = metadataCompilation.GetBoundReferenceManager().CreatePEAssemblyForAssemblyMetadata(AssemblyMetadata.Create(originalMetadata), MetadataImportOptions.All);
var metadataDecoder = new MetadataDecoder(metadataAssembly.PrimaryModule);
var metadataAnonymousTypes = GetAnonymousTypeMapFromMetadata(originalMetadata.MetadataReader, metadataDecoder);
var metadataSymbols = new EmitBaseline.MetadataSymbols(metadataAnonymousTypes, metadataDecoder);
return(InterlockedOperations.Initialize(ref initialBaseline.LazyMetadataSymbols, metadataSymbols));
}
internal override DiagnosticInfo GetUseSiteDiagnostic()
{
if (!_packedFlags.IsUseSiteDiagnosticPopulated)
{
DiagnosticInfo result = null;
CalculateUseSiteDiagnostic(ref result);
EnsureTypeParametersAreLoaded(ref result);
return(InitializeUseSiteDiagnostic(result));
}
var uncommonFields = _uncommonFields;
if (uncommonFields == null)
{
return(null);
}
else
{
var result = uncommonFields._lazyUseSiteDiagnostic;
return(CSDiagnosticInfo.IsEmpty(result)
? InterlockedOperations.Initialize(ref uncommonFields._lazyUseSiteDiagnostic, null, CSDiagnosticInfo.EmptyErrorInfo)
: result);
}
}
internal override bool TryGetThisParameter(out ParameterSymbol thisParameter)
{
thisParameter = IsStatic ? null :
_uncommonFields?._lazyThisParameter ?? InterlockedOperations.Initialize(ref AccessUncommonFields()._lazyThisParameter, new ThisParameterSymbol(this));
return(true);
}
private UncommonFields AccessUncommonFields()
{
var retVal = _uncommonFields;
return(retVal ?? InterlockedOperations.Initialize(ref _uncommonFields, CreateUncommonFields()));
}
// Decrement if value > 0 private void DecrementAreaCount() => InterlockedOperations.Update(ref _importantAreaCount, i => Math.Max(i - 1, 0));
