Readonly primary constructor backing fields

[thinkbeforecoding]

I noticed that in C#, primary constructor's parameters are mutable. To make them readonly, they have to be stored in a readonly fiels, in which case, the primary constructor's parameters backing field disapear:

class C(int x) { 
  public int X => x;
}

compiles as:

class C {
   private int <x>P;
   
   public C(int x) {
      <x>P = x;
   }
   
   public X { get { return <x>P; }
}

while

class C(int x) { 
 private readonly int _x;
 public int X => _x;
 }

compiles as:

class C {
   private int _x;
   
   public C(int x) {
      _x = x;
   }
   public X { get { return _x }
}

Since parameters are readonly (immutable) in F#, I expected them to be stored in a readonly field:

type C(x: int) =
    member _.X = x

but this is not the case:

public class C {
        internal int x;

        public C(int x) {
            this.x = x;
        }

        public int X { get { return x; } }
}

Why is the field mutable ? Would it be a breaking change to make it readonly ?

(readonly fields can help the JIT to do better optimizations...)

[T-Gro]

The mechanism around IL's initonly are there and I can see that discriminated unions are making use of it, so do parts of static initialization logic.

The F# record's field was on the IL level internal and never private - which means there could (but should not!) be code parts that are making use of it within an optimization - but I assume this is not the case.

= Right now, I do not see why not

[T-Gro]

One important concern comes to mind:
Binary compatibility and reflection usage.

Especially if this would cause a popular library to crash on F# records, that itself might be a reason for not doing it.