Compiler allows assignment to const field

[zanaptak]

Given C# code with a const (and readonly for comparison):

public class Class1
{
    public const string MyConst = "my const";
    public static readonly string MyReadonly = "my readonly";
}

F# compiler allows assignment to the const (leaving it to fail at runtime):

Class1.MyConst <- "changed" // compiler allows this
Class1.MyReadonly <- "changed" // FS0690: This field is readonly

Note that C# compiler disallows:

Class1.MyConst = "changed"; // CS0131: The left-hand side of an assignment must be a variable, property or indexer
Class1.MyReadonly = "changed"; // CS0198: A static readonly field cannot be assigned to (except in a static constructor or a variable initializer)

Repro steps

Create C# class library project with:

namespace ClassLibrary1
{
    public class Class1
    {
        public const string MyConst = "my const";
        public static readonly string MyReadonly = "my readonly";
        void Test()
        {
            // Uncomment for C# compiler errors
            // Class1.MyConst = "changed";
            // Class1.MyReadonly = "changed";
        }
    }
}

Create F# project referencing above C# project, with:

open ClassLibrary1
Class1.MyConst <- "changed" // compiler allows this
Class1.MyReadonly <- "changed" // FS0690: This field is readonly

Expected behavior

F# compiler should prevent assignment to const at compile time.

Actual behavior

F# compiler allows assignment to const at compile time.

Related information

• Operating system: Windows 10
• .NET Runtime kind (.NET Core, .NET Framework, Mono): .NET Core 3.1.302
• Editing Tools (e.g. Visual Studio Version, Visual Studio): Visual Studio 2019 16.6.5

[cartermp]

Note that if you look at the compiled IL, it's merely a public field: https://sharplab.io/#v2:C4LglgNgNAJiDUAfAAgZgATIEzoMIQEMBnIgRgFgAoAbyvXswwGMB7AOyOE1IAZ0BZAJ652ndAF50AIgC2g9Kw7ApAbjoM03AGzoATgFMCMdhHnJeAwQCVDxtqYnS5e2ycGqqAXyA===

So as far as what the F# compiler sees, it is assignable. Note that this concept is also generally not really a thing in F#: let-bound class values are private to that class (and are erased if marked with Literal attribute), and val declarations are public mutable fields. I suppose some special analysis might be possible but this is kind of by design, especially since const values in C# are evaluated at compile-time.

[abelbraaksma]

It looks like whether it's a literal is detectable from IL:

.field public static literal string MyConst = "my const"
.field public static initonly string MyReadonly

So it shouldn't be too hard to do. But a warning instead of an error might be better, in case code exists that exploits this.

[zanaptak]

Yes, it has the Literal FieldAttribute flag as shown in the above snippet which indicates it is not assignable. There seems to be precedent to respect .NET field attributes since the compiler is already respecting the InitOnly flag for the readonly field.

[cartermp]

Seems like it's probably just a gap in importing IL. Taking a look the compiler does read the value, it's probably just dropping something further up the stack:

fsharp/src/absil/il.fs

Line 1874 in d0c19d8

member x.IsLiteral = x.Attributes &&& FieldAttributes.Literal <> enum 0

Though it's worth reiterating that this is kind of odd (as is handling of initonly) because these little quirks on fields are part of the .NET object system but not F# semantics. I think we'd happily take a PR that addresses this, but realistically it might not be the highest priority for now, at least not until we incorporate more of this kind of stuff into the F# type system with initonly members (something we'll have to do for interop with C# records post-C# 9).

[baronfel]

I've got a fix for this, I'll open an MR to discuss testing and next steps.