internal static DeclarationModifiers CheckModifiers(
DeclarationModifiers modifiers,
DeclarationModifiers allowedModifiers,
Location errorLocation,
BindingDiagnosticBag diagnostics,
SyntaxTokenList?modifierTokens,
out bool modifierErrors
)
{
modifierErrors = false;
DeclarationModifiers errorModifiers = modifiers & ~allowedModifiers;
DeclarationModifiers result = modifiers & allowedModifiers;
while (errorModifiers != DeclarationModifiers.None)
{
DeclarationModifiers oneError = errorModifiers & ~(errorModifiers - 1);
Debug.Assert(oneError != DeclarationModifiers.None);
errorModifiers = errorModifiers & ~oneError;
switch (oneError)
{
case DeclarationModifiers.Partial:
// Provide a specialized error message in the case of partial.
ReportPartialError(errorLocation, diagnostics, modifierTokens);
break;
default:
diagnostics.Add(
ErrorCode.ERR_BadMemberFlag,
errorLocation,
ConvertSingleModifierToSyntaxText(oneError)
);
break;
}
modifierErrors = true;
}
if ((result & DeclarationModifiers.PrivateProtected) != 0)
{
modifierErrors |= !Binder.CheckFeatureAvailability(
errorLocation.SourceTree,
MessageID.IDS_FeaturePrivateProtected,
diagnostics,
errorLocation
);
}
return(result);
}
protected SourceOrdinaryMethodSymbolBase(
NamedTypeSymbol containingType,
string name,
Location location,
CSharpSyntaxNode syntax,
MethodKind methodKind,
bool isIterator,
bool isExtensionMethod,
bool isPartial,
bool hasBody,
bool isNullableAnalysisEnabled,
BindingDiagnosticBag diagnostics) :
base(containingType,
syntax.GetReference(),
location,
isIterator: isIterator)
{
Debug.Assert(diagnostics.DiagnosticBag is object);
_name = name;
// The following two values are used to compute and store the initial value of the flags
// However, these two components are placeholders; the correct value will be
// computed lazily later and then the flags will be fixed up.
const bool returnsVoid = false;
DeclarationModifiers declarationModifiers;
(declarationModifiers, HasExplicitAccessModifier) = this.MakeModifiers(methodKind, isPartial, hasBody, location, diagnostics);
var isMetadataVirtualIgnoringModifiers = methodKind == MethodKind.ExplicitInterfaceImplementation; //explicit impls must be marked metadata virtual
this.MakeFlags(methodKind, declarationModifiers, returnsVoid, isExtensionMethod: isExtensionMethod, isNullableAnalysisEnabled: isNullableAnalysisEnabled, isMetadataVirtualIgnoringModifiers: isMetadataVirtualIgnoringModifiers);
_typeParameters = MakeTypeParameters(syntax, diagnostics);
CheckFeatureAvailabilityAndRuntimeSupport(syntax, location, hasBody, diagnostics);
if (hasBody)
{
CheckModifiersForBody(location, diagnostics);
}
var info = ModifierUtils.CheckAccessibility(this.DeclarationModifiers, this, isExplicitInterfaceImplementation: methodKind == MethodKind.ExplicitInterfaceImplementation);
if (info != null)
{
diagnostics.Add(info, location);
}
}
private NamespaceSymbol ResolveExternAliasTarget(BindingDiagnosticBag diagnostics)
{
NamespaceSymbol?target;
if (!_binder.Compilation.GetExternAliasTarget(_aliasName.ValueText, out target))
{
diagnostics.Add(ErrorCode.ERR_BadExternAlias, _aliasName.GetLocation(), _aliasName.ValueText !);
}
RoslynDebug.Assert(target is object);
RoslynDebug.Assert(target.IsGlobalNamespace);
return(target);
}
protected void ReportModifiersDiagnostics(BindingDiagnosticBag diagnostics)
{
if (ContainingType.IsSealed && this.DeclaredAccessibility.HasProtected())
{
diagnostics.Add(AccessCheck.GetProtectedMemberInSealedTypeError(containingType), ErrorLocation, this);
}
else if (IsVolatile && IsReadOnly)
{
diagnostics.Add(ErrorCode.ERR_VolatileAndReadonly, ErrorLocation, this);
}
else if (containingType.IsStatic && !IsStatic)
{
diagnostics.Add(ErrorCode.ERR_InstanceMemberInStaticClass, ErrorLocation, this);
}
else if (!IsStatic && !IsReadOnly && containingType.IsReadOnly)
{
diagnostics.Add(ErrorCode.ERR_FieldsInRoStruct, ErrorLocation);
}
// TODO: Consider checking presence of core type System.Runtime.CompilerServices.IsVolatile
// if there is a volatile modifier. Perhaps an appropriate error should be reported if the
// type isn't available.
}
internal SourceCustomEventAccessorSymbol(
SourceEventSymbol @event,
AccessorDeclarationSyntax syntax,
EventSymbol explicitlyImplementedEventOpt,
string aliasQualifierOpt,
bool isNullableAnalysisEnabled,
BindingDiagnosticBag diagnostics)
: base(@event,
syntax.GetReference(),
ImmutableArray.Create(syntax.Keyword.GetLocation()), explicitlyImplementedEventOpt, aliasQualifierOpt,
isAdder: syntax.Kind() == SyntaxKind.AddAccessorDeclaration,
isIterator: SyntaxFacts.HasYieldOperations(syntax.Body),
isNullableAnalysisEnabled: isNullableAnalysisEnabled)
{
Debug.Assert(syntax != null);
Debug.Assert(syntax.Kind() == SyntaxKind.AddAccessorDeclaration || syntax.Kind() == SyntaxKind.RemoveAccessorDeclaration);
CheckFeatureAvailabilityAndRuntimeSupport(syntax, this.Location, hasBody: true, diagnostics: diagnostics);
if (syntax.Body != null || syntax.ExpressionBody != null)
{
if (IsExtern && !IsAbstract)
{
diagnostics.Add(ErrorCode.ERR_ExternHasBody, this.Location, this);
}
// Do not report error for IsAbstract && IsExtern. Dev10 reports CS0180 only
// in that case ("member cannot be both extern and abstract").
}
if (syntax.Modifiers.Count > 0)
{
diagnostics.Add(ErrorCode.ERR_NoModifiersOnAccessor, syntax.Modifiers[0].GetLocation());
}
CheckForBlockAndExpressionBody(
syntax.Body, syntax.ExpressionBody, syntax, diagnostics);
}
internal static void ReportDefaultInterfaceImplementationModifiers(
bool hasBody,
DeclarationModifiers modifiers,
DeclarationModifiers defaultInterfaceImplementationModifiers,
Location errorLocation,
BindingDiagnosticBag diagnostics)
{
if ((modifiers & defaultInterfaceImplementationModifiers) != 0)
{
LanguageVersion availableVersion = ((CSharpParseOptions)errorLocation.SourceTree.Options).LanguageVersion;
LanguageVersion requiredVersion;
if ((modifiers & defaultInterfaceImplementationModifiers & DeclarationModifiers.Static) != 0 &&
(modifiers & defaultInterfaceImplementationModifiers & (DeclarationModifiers.Sealed | DeclarationModifiers.Abstract | DeclarationModifiers.Virtual)) != 0)
{
var reportModifiers = DeclarationModifiers.Sealed | DeclarationModifiers.Abstract | DeclarationModifiers.Virtual;
if ((modifiers & defaultInterfaceImplementationModifiers & DeclarationModifiers.Sealed) != 0 &&
(modifiers & defaultInterfaceImplementationModifiers & (DeclarationModifiers.Abstract | DeclarationModifiers.Virtual)) != 0)
{
diagnostics.Add(ErrorCode.ERR_BadMemberFlag, errorLocation, ConvertSingleModifierToSyntaxText(DeclarationModifiers.Sealed));
reportModifiers &= ~DeclarationModifiers.Sealed;
}
requiredVersion = MessageID.IDS_FeatureStaticAbstractMembersInInterfaces.RequiredVersion();
if (availableVersion < requiredVersion)
{
ReportUnsupportedModifiersForLanguageVersion(modifiers, reportModifiers, errorLocation, diagnostics, availableVersion, requiredVersion);
}
return; // below we will either ask for an earlier version of the language, or will not report anything
}
if (hasBody)
{
if ((modifiers & defaultInterfaceImplementationModifiers & DeclarationModifiers.Static) != 0)
{
Binder.CheckFeatureAvailability(errorLocation.SourceTree, MessageID.IDS_DefaultInterfaceImplementation, diagnostics, errorLocation);
}
}
else
{
requiredVersion = MessageID.IDS_DefaultInterfaceImplementation.RequiredVersion();
if (availableVersion < requiredVersion)
{
ReportUnsupportedModifiersForLanguageVersion(modifiers, defaultInterfaceImplementationModifiers, errorLocation, diagnostics, availableVersion, requiredVersion);
}
}
}
}
protected static void ReportBadRefToken(
TypeSyntax returnTypeSyntax,
BindingDiagnosticBag diagnostics
)
{
if (!returnTypeSyntax.HasErrors)
{
var refKeyword = returnTypeSyntax.GetFirstToken();
diagnostics.Add(
ErrorCode.ERR_UnexpectedToken,
refKeyword.GetLocation(),
refKeyword.ToString()
);
}
}
private void CheckShiftSignature(BindingDiagnosticBag diagnostics)
{
// SPEC: A binary << or >> operator must take two parameters, the first
// SPEC: of which must have type T or T? and the second of which must
// SPEC: have type int or int?, and can return any type.
if (
!MatchesContainingType(this.GetParameterType(0).StrippedType()) ||
this.GetParameterType(1).StrippedType().SpecialType != SpecialType.System_Int32
)
{
// CS0546: The first operand of an overloaded shift operator must have the
// same type as the containing type, and the type of the second
// operand must be int
diagnostics.Add(ErrorCode.ERR_BadShiftOperatorSignature, this.Locations[0]);
}
if (this.ReturnsVoid)
{
// The Roslyn parser does not detect this error.
// CS0590: User-defined operators cannot return void
diagnostics.Add(ErrorCode.ERR_OperatorCantReturnVoid, this.Locations[0]);
}
}
internal override void GenerateMethodBody(TypeCompilationState compilationState, BindingDiagnosticBag diagnostics)
{
var F = new SyntheticBoundNodeFactory(this, this.GetNonNullSyntaxNode(), compilationState, diagnostics);
try
{
F.CurrentFunction = this;
F.CloseMethod(F.Block(F.Return(F.Typeof(ContainingType))));
}
catch (SyntheticBoundNodeFactory.MissingPredefinedMember ex)
{
diagnostics.Add(ex.Diagnostic);
F.CloseMethod(F.ThrowNull());
}
}
private static void ReportErrorOnWellKnownMember(Symbol symbol, WellKnownMember member, BindingDiagnosticBag diagnostics, ref bool hasError)
{
if ((object)symbol == null)
{
MemberDescriptor memberDescriptor = WellKnownMembers.GetDescriptor(member);
diagnostics.Add(ErrorCode.ERR_MissingPredefinedMember, NoLocation.Singleton,
memberDescriptor.DeclaringTypeMetadataName, memberDescriptor.Name);
hasError = true;
}
else
{
ReportErrorOnSymbol(symbol, diagnostics, ref hasError);
ReportErrorOnSymbol(symbol.ContainingType, diagnostics, ref hasError);
}
}
internal override ConstantValue GetConstantValue(SyntaxNode node, LocalSymbol inProgress, BindingDiagnosticBag diagnostics = null)
{
if (this.IsConst && inProgress == this)
{
if (diagnostics != null)
{
diagnostics.Add(ErrorCode.ERR_CircConstValue, node.GetLocation(), this);
}
return(Microsoft.CodeAnalysis.ConstantValue.Bad);
}
MakeConstantTuple(inProgress, boundInitValue: null);
return(_constantTuple == null ? null : _constantTuple.Value);
}
internal static void CheckUnsafeModifier(
this Symbol symbol,
DeclarationModifiers modifiers,
Location errorLocation,
BindingDiagnosticBag diagnostics
)
{
if (
((modifiers & DeclarationModifiers.Unsafe) == DeclarationModifiers.Unsafe) &&
!symbol.CompilationAllowsUnsafe()
)
{
RoslynDebug.Assert(errorLocation != null);
diagnostics.Add(ErrorCode.ERR_IllegalUnsafe, errorLocation);
}
}
internal override void GenerateMethodBody(TypeCompilationState compilationState, BindingDiagnosticBag diagnostics)
{
var F = new SyntheticBoundNodeFactory(this, ContainingType.GetNonNullSyntaxNode(), compilationState, diagnostics);
try
{
// => !(r1 == r2);
F.CloseMethod(F.Block(F.Return(F.Not(F.Call(receiver: null, ContainingType.GetMembers(WellKnownMemberNames.EqualityOperatorName).OfType <SynthesizedRecordEqualityOperator>().Single(),
F.Parameter(Parameters[0]), F.Parameter(Parameters[1]))))));
}
catch (SyntheticBoundNodeFactory.MissingPredefinedMember ex)
{
diagnostics.Add(ex.Diagnostic);
F.CloseMethod(F.ThrowNull());
}
}
/// <summary>
/// Given a SynthesizedSealedPropertyAccessor (an accessor with a reference to the accessor it overrides),
/// construct a BoundBlock body.
/// </summary>
internal override void GenerateMethodBody(TypeCompilationState compilationState, BindingDiagnosticBag diagnostics)
{
SyntheticBoundNodeFactory F = new SyntheticBoundNodeFactory(this, this.GetNonNullSyntaxNode(), compilationState, diagnostics);
F.CurrentFunction = (MethodSymbol)this.OriginalDefinition;
try
{
F.CloseMethod(MethodBodySynthesizer.ConstructSingleInvocationMethodBody(F, this.OverriddenAccessor, useBaseReference: true));
}
catch (SyntheticBoundNodeFactory.MissingPredefinedMember ex)
{
diagnostics.Add(ex.Diagnostic);
F.CloseMethod(F.ThrowNull());
}
}
internal SynthesizedSubmissionConstructor(NamedTypeSymbol containingType, BindingDiagnosticBag diagnostics)
: base(containingType)
{
Debug.Assert(containingType.TypeKind == TypeKind.Submission);
Debug.Assert(diagnostics != null);
var compilation = containingType.DeclaringCompilation;
var submissionArrayType = compilation.CreateArrayTypeSymbol(compilation.GetSpecialType(SpecialType.System_Object));
var useSiteInfo = submissionArrayType.GetUseSiteInfo();
diagnostics.Add(useSiteInfo, NoLocation.Singleton);
_parameters = ImmutableArray.Create <ParameterSymbol>(
SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(submissionArrayType), 0, RefKind.None, "submissionArray"));
}
internal override void GenerateMethodBody(
TypeCompilationState compilationState,
BindingDiagnosticBag diagnostics
)
{
var F = new SyntheticBoundNodeFactory(
this,
this.SyntaxNode,
compilationState,
diagnostics
);
try
{
var paramAccess = F.Parameter(Parameters[0]);
BoundExpression expression;
if (ContainingType.IsStructType())
{
throw ExceptionUtilities.Unreachable;
}
else
{
if (_typedRecordEquals.ReturnType.SpecialType != SpecialType.System_Boolean)
{
// There is a signature mismatch, an error was reported elsewhere
F.CloseMethod(F.ThrowNull());
return;
}
// For classes:
// return this.Equals(param as ContainingType);
expression = F.Call(
F.This(),
_typedRecordEquals,
F.As(paramAccess, ContainingType)
);
}
F.CloseMethod(F.Block(ImmutableArray.Create <BoundStatement>(F.Return(expression))));
}
catch (SyntheticBoundNodeFactory.MissingPredefinedMember ex)
{
diagnostics.Add(ex.Diagnostic);
F.CloseMethod(F.ThrowNull());
}
}
public static ImmutableArray <FunctionPointerParameterSymbol> MakeFunctionPointerParameters(
Binder binder,
FunctionPointerMethodSymbol owner,
SeparatedSyntaxList <FunctionPointerParameterSyntax> parametersList,
BindingDiagnosticBag diagnostics,
bool suppressUseSiteDiagnostics)
{
return(MakeParameters <FunctionPointerParameterSyntax, FunctionPointerParameterSymbol, FunctionPointerMethodSymbol>(
binder,
owner,
parametersList,
out _,
diagnostics,
allowRefOrOut: true,
allowThis: false,
addRefReadOnlyModifier: true,
suppressUseSiteDiagnostics,
parametersList.Count - 2,
parameterCreationFunc: (Binder binder, FunctionPointerMethodSymbol owner, TypeWithAnnotations parameterType,
FunctionPointerParameterSyntax syntax, RefKind refKind, int ordinal,
SyntaxToken paramsKeyword, SyntaxToken thisKeyword, bool addRefReadOnlyModifier,
DeclarationScope scope,
BindingDiagnosticBag diagnostics) =>
{
// Non-function pointer locations have other locations to encode in/ref readonly/outness. For function pointers,
// these modreqs are the only locations where this can be encoded. If that changes, we should update this.
Debug.Assert(addRefReadOnlyModifier, "If addReadonlyRef isn't true, we must have found a different location to encode the readonlyness of a function pointer");
ImmutableArray <CustomModifier> customModifiers = refKind switch
{
RefKind.In => CreateInModifiers(binder, diagnostics, syntax),
RefKind.Out => CreateOutModifiers(binder, diagnostics, syntax),
_ => ImmutableArray <CustomModifier> .Empty
};
if (parameterType.IsVoidType())
{
diagnostics.Add(ErrorCode.ERR_NoVoidParameter, syntax.Type.Location);
}
return new FunctionPointerParameterSymbol(
parameterType,
refKind,
ordinal,
owner,
customModifiers);
},
internal static void ReportUnsupportedModifiersForLanguageVersion(DeclarationModifiers modifiers, DeclarationModifiers unsupportedModifiers, Location errorLocation, BindingDiagnosticBag diagnostics, LanguageVersion availableVersion, LanguageVersion requiredVersion)
{
DeclarationModifiers errorModifiers = modifiers & unsupportedModifiers;
var requiredVersionArgument = new CSharpRequiredLanguageVersion(requiredVersion);
var availableVersionArgument = availableVersion.ToDisplayString();
while (errorModifiers != DeclarationModifiers.None)
{
DeclarationModifiers oneError = errorModifiers & ~(errorModifiers - 1);
Debug.Assert(oneError != DeclarationModifiers.None);
errorModifiers = errorModifiers & ~oneError;
diagnostics.Add(ErrorCode.ERR_InvalidModifierForLanguageVersion, errorLocation,
ConvertSingleModifierToSyntaxText(oneError),
availableVersionArgument,
requiredVersionArgument);
}
}
/// <summary>
/// Decodes PermissionSetAttribute applied in source to determine if it needs any fixup during codegen.
/// </summary>
/// <remarks>
/// PermissionSetAttribute needs fixup when it contains an assignment to the 'File' property as a single named attribute argument.
/// Fixup performed is ported from SecurityAttributes::FixUpPermissionSetAttribute.
/// It involves following steps:
/// 1) Verifying that the specified file name resolves to a valid path.
/// 2) Reading the contents of the file into a byte array.
/// 3) Convert each byte in the file content into two bytes containing hexadecimal characters.
/// 4) Replacing the 'File = fileName' named argument with 'Hex = hexFileContent' argument, where hexFileContent is the converted output from step 3) above.
///
/// Step 1) is performed in this method, i.e. during binding.
/// Remaining steps are performed during serialization as we want to avoid retaining the entire file contents throughout the binding/codegen pass.
/// See <see cref="Microsoft.CodeAnalysis.CodeGen.PermissionSetAttributeWithFileReference"/> for remaining fixup steps.
/// </remarks>
/// <returns>String containing the resolved file path if PermissionSetAttribute needs fixup during codegen, null otherwise.</returns>
private string?DecodePermissionSetAttribute(CSharpCompilation compilation, AttributeSyntax?nodeOpt, BindingDiagnosticBag diagnostics)
{
Debug.Assert(!this.HasErrors);
string?resolvedFilePath = null;
var namedArgs = this.CommonNamedArguments;
if (namedArgs.Length == 1)
{
var namedArg = namedArgs[0];
Debug.Assert(AttributeClass is object);
NamedTypeSymbol attrType = this.AttributeClass;
string filePropName = PermissionSetAttributeWithFileReference.FilePropertyName;
string hexPropName = PermissionSetAttributeWithFileReference.HexPropertyName;
if (namedArg.Key == filePropName &&
PermissionSetAttributeTypeHasRequiredProperty(attrType, filePropName))
{
// resolve file prop path
var fileName = (string?)namedArg.Value.ValueInternal;
var resolver = compilation.Options.XmlReferenceResolver;
resolvedFilePath = (resolver != null && fileName != null) ? resolver.ResolveReference(fileName, baseFilePath: null) : null;
if (resolvedFilePath == null)
{
// CS7053: Unable to resolve file path '{0}' specified for the named argument '{1}' for PermissionSet attribute
Location argSyntaxLocation = nodeOpt?.GetNamedArgumentSyntax(filePropName)?.Location ?? NoLocation.Singleton;
diagnostics.Add(ErrorCode.ERR_PermissionSetAttributeInvalidFile, argSyntaxLocation, fileName ?? "<null>", filePropName);
}
else if (!PermissionSetAttributeTypeHasRequiredProperty(attrType, hexPropName))
{
// PermissionSetAttribute was defined in user source, but doesn't have the required Hex property.
// Native compiler still emits the file content as named assignment to 'Hex' property, but this leads to a runtime exception.
// We instead skip the fixup and emit the file property.
// CONSIDER: We may want to consider taking a breaking change and generating an error here.
return(null);
}
}
}
return(resolvedFilePath);
}
internal void GetDeclarationDiagnostics(BindingDiagnosticBag addTo)
{
// Force complete type parameters
foreach (var typeParam in _typeParameters)
{
typeParam.ForceComplete(null, default(CancellationToken));
}
// force lazy init
ComputeParameters();
foreach (var p in _lazyParameters)
{
// Force complete parameters to retrieve all diagnostics
p.ForceComplete(null, default(CancellationToken));
}
ComputeReturnType();
GetAttributes();
GetReturnTypeAttributes();
AsyncMethodChecks(_declarationDiagnostics);
addTo.AddRange(_declarationDiagnostics, allowMismatchInDependencyAccumulation: true);
var diagnostics = BindingDiagnosticBag.GetInstance(
withDiagnostics: false,
withDependencies: addTo.AccumulatesDependencies
);
if (
IsEntryPointCandidate &&
!IsGenericMethod &&
ContainingSymbol is SynthesizedSimpleProgramEntryPointSymbol &&
DeclaringCompilation.HasEntryPointSignature(this, diagnostics).IsCandidate
)
{
addTo.Add(ErrorCode.WRN_MainIgnored, Syntax.Identifier.GetLocation(), this);
}
addTo.AddRangeAndFree(diagnostics);
}
internal string DecodeGuidAttribute(AttributeSyntax?nodeOpt, BindingDiagnosticBag diagnostics)
{
Debug.Assert(!this.HasErrors);
var guidString = (string?)this.CommonConstructorArguments[0].ValueInternal;
// Native compiler allows only a specific GUID format: "D" format (32 digits separated by hyphens)
Guid guid;
if (!Guid.TryParseExact(guidString, "D", out guid))
{
// CS0591: Invalid value for argument to '{0}' attribute
Location attributeArgumentSyntaxLocation = this.GetAttributeArgumentSyntaxLocation(0, nodeOpt);
diagnostics.Add(ErrorCode.ERR_InvalidAttributeArgument, attributeArgumentSyntaxLocation, nodeOpt != null ? nodeOpt.GetErrorDisplayName() : "");
guidString = String.Empty;
}
return(guidString !);
}
internal TypeParameterSymbol MakeSymbol(int ordinal, IList <TypeParameterBuilder> builders, BindingDiagnosticBag diagnostics)
{
var syntaxNode = (TypeParameterSyntax)_syntaxRef.GetSyntax();
var result = new SourceTypeParameterSymbol(
_owner,
syntaxNode.Identifier.ValueText,
ordinal,
syntaxNode.VarianceKeyword.VarianceKindFromToken(),
ToLocations(builders),
ToSyntaxRefs(builders));
// SPEC: A type parameter [of a type] cannot have the same name as the type itself.
if (result.Name == result.ContainingSymbol.Name)
{
diagnostics.Add(ErrorCode.ERR_TypeVariableSameAsParent, result.Locations[0], result.Name);
}
return(result);
}
private DeclarativeSecurityAction DecodeSecurityAttributeAction(Symbol targetSymbol, CSharpCompilation compilation, AttributeSyntax?nodeOpt, out bool hasErrors, BindingDiagnosticBag diagnostics)
{
Debug.Assert((object)targetSymbol != null);
Debug.Assert(targetSymbol.Kind == SymbolKind.Assembly || targetSymbol.Kind == SymbolKind.NamedType || targetSymbol.Kind == SymbolKind.Method);
Debug.Assert(this.IsSecurityAttribute(compilation));
var ctorArgs = this.CommonConstructorArguments;
if (!ctorArgs.Any())
{
// NOTE: Security custom attributes must have a valid SecurityAction as its first argument, we have none here.
// NOTE: Ideally, we should always generate 'CS7048: First argument to a security attribute must be a valid SecurityAction' for this case.
// NOTE: However, native compiler allows applying System.Security.Permissions.HostProtectionAttribute attribute without any argument and uses
// NOTE: SecurityAction.LinkDemand as the default SecurityAction in this case. We maintain compatibility with the native compiler for this case.
// BREAKING CHANGE: Even though the native compiler intends to allow only HostProtectionAttribute to be applied without any arguments,
// it doesn't quite do this correctly
// The implementation issue leads to the native compiler allowing any user defined security attribute with a parameterless constructor and a named property argument as the first
// attribute argument to have the above mentioned behavior, even though the comment clearly mentions that this behavior was intended only for the HostProtectionAttribute.
// We currently allow this case only for the HostProtectionAttribute. In future if need arises, we can exactly match native compiler's behavior.
if (this.IsTargetAttribute(targetSymbol, AttributeDescription.HostProtectionAttribute))
{
hasErrors = false;
return(DeclarativeSecurityAction.LinkDemand);
}
}
else
{
TypedConstant firstArg = ctorArgs.First();
var firstArgType = (TypeSymbol?)firstArg.TypeInternal;
if (firstArgType is object && firstArgType.Equals(compilation.GetWellKnownType(WellKnownType.System_Security_Permissions_SecurityAction)))
{
return(DecodeSecurityAction(firstArg, targetSymbol, nodeOpt, diagnostics, out hasErrors));
}
}
// CS7048: First argument to a security attribute must be a valid SecurityAction
diagnostics.Add(ErrorCode.ERR_SecurityAttributeMissingAction, nodeOpt != null ? nodeOpt.Name.Location : NoLocation.Singleton);
hasErrors = true;
return(DeclarativeSecurityAction.None);
}
/// <summary>
/// Given a SynthesizedSealedPropertyAccessor (an accessor with a reference to the accessor it overrides),
/// construct a BoundBlock body.
/// </summary>
internal override void GenerateMethodBody(
TypeCompilationState compilationState,
BindingDiagnosticBag diagnostics
)
{
SyntheticBoundNodeFactory F = new SyntheticBoundNodeFactory(
this,
this.GetNonNullSyntaxNode(),
compilationState,
diagnostics
);
F.CurrentFunction = this.OriginalDefinition;
try
{
MethodSymbol methodBeingWrapped = this.BaseMethod;
if (this.Arity > 0)
{
Debug.Assert(this.Arity == methodBeingWrapped.Arity);
methodBeingWrapped = methodBeingWrapped.ConstructedFrom.Construct(
StaticCast <TypeSymbol> .From(this.TypeParameters)
);
}
BoundBlock body = MethodBodySynthesizer.ConstructSingleInvocationMethodBody(
F,
methodBeingWrapped,
useBaseReference: true
);
if (body.Kind != BoundKind.Block)
{
body = F.Block(body);
}
F.CompilationState.AddMethodWrapper(methodBeingWrapped, this, body);
}
catch (SyntheticBoundNodeFactory.MissingPredefinedMember ex)
{
diagnostics.Add(ex.Diagnostic);
}
}
private DeclarationModifiers MakeModifiers(SyntaxTokenList modifiers, MethodKind methodKind, bool hasBody, Location location, BindingDiagnosticBag diagnostics, out bool modifierErrors)
{
var defaultAccess = (methodKind == MethodKind.StaticConstructor) ? DeclarationModifiers.None : DeclarationModifiers.Private;
// Check that the set of modifiers is allowed
const DeclarationModifiers allowedModifiers =
DeclarationModifiers.AccessibilityMask |
DeclarationModifiers.Static |
DeclarationModifiers.Extern |
DeclarationModifiers.Unsafe;
bool isInterface = ContainingType.IsInterface;
var mods = ModifierUtils.MakeAndCheckNontypeMemberModifiers(isOrdinaryMethod: false, isForInterfaceMember: isInterface, modifiers, defaultAccess, allowedModifiers, location, diagnostics, out modifierErrors);
this.CheckUnsafeModifier(mods, diagnostics);
if (methodKind == MethodKind.StaticConstructor)
{
// Don't report ERR_StaticConstructorWithAccessModifiers if the ctor symbol name doesn't match the containing type name.
// This avoids extra unnecessary errors.
// There will already be a diagnostic saying Method must have a return type.
if ((mods & DeclarationModifiers.AccessibilityMask) != 0 &&
ContainingType.Name == ((ConstructorDeclarationSyntax)this.SyntaxNode).Identifier.ValueText)
{
diagnostics.Add(ErrorCode.ERR_StaticConstructorWithAccessModifiers, location, this);
mods = mods & ~DeclarationModifiers.AccessibilityMask;
modifierErrors = true;
}
mods |= DeclarationModifiers.Private; // we mark static constructors private in the symbol table
if (isInterface)
{
ModifierUtils.ReportDefaultInterfaceImplementationModifiers(hasBody, mods,
DeclarationModifiers.Extern,
location, diagnostics);
}
}
return(mods);
}
internal void DecodeInterfaceTypeAttribute(
AttributeSyntax node,
BindingDiagnosticBag diagnostics
)
{
Debug.Assert(!this.HasErrors);
TypedConstant ctorArgument = this.CommonConstructorArguments[0];
Debug.Assert(
ctorArgument.Kind == TypedConstantKind.Enum ||
ctorArgument.Kind == TypedConstantKind.Primitive
);
ComInterfaceType interfaceType =
ctorArgument.Kind == TypedConstantKind.Enum
? ctorArgument.DecodeValue <ComInterfaceType>(SpecialType.System_Enum)
: (ComInterfaceType)ctorArgument.DecodeValue <short>(SpecialType.System_Int16);
switch (interfaceType)
{
case Cci.Constants.ComInterfaceType_InterfaceIsDual:
case Cci.Constants.ComInterfaceType_InterfaceIsIDispatch:
case ComInterfaceType.InterfaceIsIInspectable:
case ComInterfaceType.InterfaceIsIUnknown:
break;
default:
// CS0591: Invalid value for argument to '{0}' attribute
CSharpSyntaxNode attributeArgumentSyntax = this.GetAttributeArgumentSyntax(
0,
node
);
diagnostics.Add(
ErrorCode.ERR_InvalidAttributeArgument,
attributeArgumentSyntax.Location,
node.GetErrorDisplayName()
);
break;
}
}
internal override void GenerateMethodBody(TypeCompilationState compilationState, BindingDiagnosticBag diagnostics)
{
var F = new SyntheticBoundNodeFactory(this, ContainingType.GetNonNullSyntaxNode(), compilationState, diagnostics);
try
{
// => (object)left == right || ((object)left != null && left.Equals(right));
MethodSymbol?equals = null;
foreach (var member in ContainingType.GetMembers(WellKnownMemberNames.ObjectEquals))
{
if (member is MethodSymbol candidate && candidate.ParameterCount == 1 && candidate.Parameters[0].RefKind == RefKind.None &&
candidate.ReturnType.SpecialType == SpecialType.System_Boolean && !candidate.IsStatic &&
candidate.Parameters[0].Type.Equals(ContainingType, TypeCompareKind.AllIgnoreOptions))
{
equals = candidate;
break;
}
}
if (equals is null)
{
// Unable to locate expected method, an error was reported elsewhere
F.CloseMethod(F.ThrowNull());
return;
}
var left = F.Parameter(Parameters[0]);
var right = F.Parameter(Parameters[1]);
BoundExpression objectEqual = F.ObjectEqual(left, right);
BoundExpression recordEquals = F.LogicalAnd(F.ObjectNotEqual(left, F.Null(F.SpecialType(SpecialType.System_Object))),
F.Call(left, equals, right));
F.CloseMethod(F.Block(F.Return(F.LogicalOr(objectEqual, recordEquals))));
}
catch (SyntheticBoundNodeFactory.MissingPredefinedMember ex)
{
diagnostics.Add(ex.Diagnostic);
F.CloseMethod(F.ThrowNull());
}
}
/// <summary>
/// Given a SynthesizedExplicitImplementationMethod (effectively a tuple (interface method, implementing method, implementing type)),
/// construct a BoundBlock body. Consider the tuple (Interface.Goo, Base.Goo, Derived). The generated method will look like:
///
/// R Interface.Goo<T1, T2, ...>(A1 a1, A2 a2, ...)
/// {
/// //don't return the output if the return type is void
/// return this.Goo<T1, T2, ...>(a1, a2, ...);
/// }
/// </summary>
internal override void GenerateMethodBody(TypeCompilationState compilationState, BindingDiagnosticBag diagnostics)
{
SyntheticBoundNodeFactory F = new SyntheticBoundNodeFactory(this, this.GetNonNullSyntaxNode(), compilationState, diagnostics);
F.CurrentFunction = (MethodSymbol)this.OriginalDefinition;
try
{
MethodSymbol methodToInvoke =
this.IsGenericMethod ?
this.ImplementingMethod.Construct(this.TypeParameters.Cast <TypeParameterSymbol, TypeSymbol>()) :
this.ImplementingMethod;
F.CloseMethod(MethodBodySynthesizer.ConstructSingleInvocationMethodBody(F, methodToInvoke, useBaseReference: false));
}
catch (SyntheticBoundNodeFactory.MissingPredefinedMember ex)
{
diagnostics.Add(ex.Diagnostic);
F.CloseMethod(F.ThrowNull());
}
}
private void CheckForFieldTargetedAttribute(BindingDiagnosticBag diagnostics)
{
var languageVersion = this.DeclaringCompilation.LanguageVersion;
if (languageVersion.AllowAttributesOnBackingFields())
{
return;
}
foreach (var attribute in AttributeDeclarationSyntaxList)
{
if (attribute.Target?.GetAttributeLocation() == AttributeLocation.Field)
{
diagnostics.Add(
new CSDiagnosticInfo(ErrorCode.WRN_AttributesOnBackingFieldsNotAvailable,
languageVersion.ToDisplayString(),
new CSharpRequiredLanguageVersion(MessageID.IDS_FeatureAttributesOnBackingFields.RequiredVersion())),
attribute.Target.Location);
}
}
}
protected SourceEnumConstantSymbol(
SourceMemberContainerTypeSymbol containingEnum,
EnumMemberDeclarationSyntax syntax,
BindingDiagnosticBag diagnostics
)
: base(
containingEnum,
syntax.Identifier.ValueText,
syntax.GetReference(),
syntax.Identifier.GetLocation()
)
{
if (this.Name == WellKnownMemberNames.EnumBackingFieldName)
{
diagnostics.Add(
ErrorCode.ERR_ReservedEnumerator,
this.ErrorLocation,
WellKnownMemberNames.EnumBackingFieldName
);
}
}