Compiler allows setting a value of a private property on attribute

[ForNeVeR]

Compiler allows to "set" a value of a property with private setter on an attribute. This doesn't work in runtime and isn't allowed by the C# compiler, even though it has some representation in the assembly metadata.

Repro steps

1. Create a new F# project on .NET 9.0.300 SDK
2. Install package CommandLineParser v2.9.1
3. Write this:

   [<CommandLine.Verb("start", HelpText = "Start the game", IsDefault = true)>]
   type StartGame() = class end

Here's a ZIP archive with the project: ConsoleApp19.zip

Expected behavior

The code should not compile. Inspect the VerbAttribute and note that it has a constructor parameter named isDefault (starting from lowercase) that's accessible, and a property (starting from a capital letter) IsDefault that has a private setter.

See this code: https://github.com/commandlineparser/commandline/blob/1e3607b97af6141743edb3c434c06d5b492f6fb3/src/CommandLine/VerbAttribute.cs#L67-L70

public bool IsDefault { get; private set; }

A corresponding C# program doesn't compile:

using CommandLine;

Console.WriteLine("Hello, World!");

[Verb("foo", IsDefault = true)]
class Foo ;

Error CS0617 : 'IsDefault' is not a valid named attribute argument. Named attribute arguments must be fields which are not readonly, static, or const, or read-write properties which are public and not static.

Actual behavior

F# compiler happily compiles the code above, and as far as I see this assignment has no effect in runtime, even though it (surprisingly) gets compiled to some metadata.

Known workarounds

Do not use the erroneous construction in F# code. In the particular case, use the (valid) isDefault = true instead of IsDefault = true.

Related information

Provide any related information (optional):

• Operating system: Windows
• .NET Runtime kind (.NET Core, .NET Framework, Mono): .NET SDK 9.0.300
• Editing Tools (e.g. Visual Studio Version, Visual Studio): doesn't matter, happens in console compiler as well

[brianrourkeboll]

Having spent approximately two seconds looking, I see this in the compiler inside of TcAttributeEx:

fsharp/src/Compiler/Checking/Expressions/CheckExpressions.fs

Lines 11410 to 11414 in 8b7bf60

	match setterItem with
	| Item.Property (info = [pinfo]) ->
	if not pinfo.HasSetter then
	errorR(Error(FSComp.SR.tcPropertyCannotBeSet0(), m))
	id.idText, true, pinfo.GetPropertyType(cenv.amap, m)

I.e., it only checks whether the property has a setter, not whether it is accessible. But I could be misunderstanding how that code is used.

[evgTSV]

I noticed that the compiler does not allow setting properties with private setters in F# attribute arguments, this only applies to CLI attributes

fsharp/src/Compiler/Checking/AttributeChecking.fs

Lines 110 to 125 in 8b7bf60

	member x.NamedArguments =
	match x with
	| FSAttribInfo(g, Attrib(_, _, _, namedArgs, _, _, _)) ->
	namedArgs
	|> List.map (fun (AttribNamedArg(nm, _, isField, AttribExpr(origExpr, evaluatedExpr))) ->
	let ty = tyOfExpr g origExpr
	let obj = evalFSharpAttribArg g evaluatedExpr
	ty, nm, isField, obj)
	| ILAttribInfo (_g, amap, scoref, cattr, m) ->
	let _params_, namedArgs = decodeILAttribData cattr
	[ for nm, argTy, isProp, arg in namedArgs ->
	// We are skipping nullness check here because this reference is an attribute usage, nullness does not apply.
	let ty = RescopeAndImportILTypeSkipNullness scoref amap m [] argTy
	let obj = evalILAttribElem arg
	let isField = not isProp
	ty, nm, isField, obj ]

In this code, named attributes are handled in two different cases, F# and CLI