Raise an error if we try to have interfaces with auto properties on constructor-less types

docs/release-notes/FSharp.Compiler.Service/8.0.200.md

@@ -2,3 +2,4 @@
 - Parens: Keep parentheses around non-struct tuples in `&` patterns - https://github.com/dotnet/fsharp/pull/16391
 - Parens analysis: fix some parenthesization corner-cases in record expressions - https://github.com/dotnet/fsharp/pull/16370
 - Fixes #16359 - correctly handle imports with 0 length public key tokens - https://github.com/dotnet/fsharp/pull/16363
+- Raise a new error when interfaces with auto properties are implemented on constructor-less types - https://github.com/dotnet/fsharp/pull/16352

src/Compiler/Checking/CheckDeclarations.fs

@@ -4232,9 +4232,6 @@ module TcDeclarations =
             | SynMemberDefn.LetBindings (range=m) :: _ -> errorR(Error(FSComp.SR.tcTypeDefinitionsWithImplicitConstructionMustHaveLocalBindingsBeforeMembers(), m))
             | _ -> ()
 
-
-
-
     /// Split auto-properties into 'let' and 'member' bindings
     let private SplitAutoProps members =
         let membersIncludingAutoProps, vals_Inherits_Abstractslots = 
@@ -4353,6 +4350,16 @@ module TcDeclarations =
         match trepr with
         | SynTypeDefnRepr.ObjectModel(kind, members, m) ->
             let members = desugarGetSetMembers members
+            let implementedAutoProperties =
+                members
+                |> List.choose (
+                    fun mem ->
+                        match mem with
+                        | SynMemberDefn.Interface (members= Some defs) ->
+                            let autoProps = defs |> List.filter(isAutoProperty)
+                            Some autoProps
+                        | _ -> None)
+                |> List.concat
 
             CheckMembersForm members
 
@@ -4394,6 +4401,13 @@ module TcDeclarations =
                 members |> List.tryPick (function 
                     | SynMemberDefn.ImplicitCtor (ctorArgs = SynSimplePats.SimplePats _ as spats) -> Some spats
                     | _ -> None)
+
+            // Raise a new error if we try to have an interface implementation with auto properties on constructor-less types,
+            for mem in implementedAutoProperties do
+                match mem with
+                | SynMemberDefn.AutoProperty( isStatic = false; range = m) when implicitCtorSynPats.IsNone ->
+                    errorR(Error(FSComp.SR.tcAutoPropertyRequiresImplicitConstructionSequence(), m))
+                | _ -> ()
 
             // An ugly bit of code to pre-determine if a type has a nullary constructor, prior to establishing the 
             // members of the type

tests/FSharp.Compiler.ComponentTests/Diagnostics/Records.fs

@@ -92,4 +92,23 @@ let t3 (x: RecTy) (a: AnotherNestedRecTy) = { x with D.C.c = { a with A = 3; B =
     |> withDiagnostics [
         (Warning 3560, Line 9, Col 26, Line 9, Col 65, "This copy-and-update record expression changes all fields of record type 'Test.NestdRecTy'. Consider using the record construction syntax instead.")
         (Warning 3560, Line 15, Col 62, Line 15, Col 85, "This copy-and-update record expression changes all fields of record type 'Test.AnotherNestedRecTy'. Consider using the record construction syntax instead.")
-    ]
+    ]
+
+[<Fact>]
+let ``Error when implementing interface with auto property in record type``() =
+    FSharp """
+type Foo =
+  abstract member X : string with get, set
+  abstract GetValue: unit -> string
+
+type FooImpl = 
+  { name: string }
+  interface Foo with
+    member val X = "" with get, set
+    member x.GetValue() = x.name
+    """
+    |> withLangVersion80
+    |> asExe
+    |> compile
+    |> shouldFail
+    |> withSingleDiagnostic (Error 912, Line 9, Col 5, Line 9, Col 36, "This declaration element is not permitted in an augmentation")

tests/FSharp.Compiler.ComponentTests/ErrorMessages/ClassesTests.fs

@@ -704,4 +704,63 @@ type X =
         abstract member Bar<'T> : string -> unit
             """
         |> typecheck
+        |> shouldSucceed
+
+    [<Fact>]
+    let ``Error if we try to have auto properties on constructor-less types`` () =
+         Fsx """
+type Foo =
+    abstract member X : string with get, set
+    abstract member Y : string with get, set
+    abstract member Z : string with get, set
+
+type FooImpl =
+    interface Foo with
+        member val X = "" with get, set
+        member val Y = "" with get, set
+        member this.Z
+            with get() = ""
+            and set(value) = ()
+            """
+        |> asExe
+        |> compile
+        |> shouldFail
+        |> withDiagnostics [
+            (Error 3133, Line 9, Col 9, Line 9, Col 40, "'member val' definitions are only permitted in types with a primary constructor. Consider adding arguments to your type definition, e.g. 'type X(args) = ...'.");
+            (Error 3133, Line 10, Col 9, Line 10, Col 40, "'member val' definitions are only permitted in types with a primary constructor. Consider adding arguments to your type definition, e.g. 'type X(args) = ...'.")
+        ]
+
+    [<Fact>]
+    let ``No error if we try to have auto properties on types with primary constructor`` () =
+         Fsx """
+type Foo =
+    abstract member X : string with get, set
+    abstract member Y : string with get, set
+    abstract member Z : string with get, set
+
+type FooImpl() =
+    interface Foo with
+        member val X = "" with get, set
+        member val Y = "" with get, set
+        member this.Z
+            with get() = ""
+            and set(value) = ()
+            """
+        |> typecheck
+        |> shouldSucceed        
+
+    [<Fact>]
+    let ``No error if we try to have static autoprop on a type without constructor`` () =
+         Fsx """
+#nowarn "3535" //We accept that static abstracts are an advanced feature
+[<Interface>]
+type Foo =
+    static abstract member X : string with get, set
+
+[<Class>]
+type FooImpl =
+    interface Foo with
+        static member val X = "" with get, set     
+            """
+        |> typecheck
         |> shouldSucceed