Replace SynSimplePat list with SynSimplePats in ImplicitCtor (#6845)

* Replace SynSimplePat list with SynSimplePats in ImplicitCtor

* Use SynSimplePats in SynTypeDefnSimpleRepr.General during type check

Author: auduchinok

src/fsharp/TypeChecker.fs

@@ -13556,7 +13556,7 @@ module MutRecBindingChecking =
                             error(Error(FSComp.SR.tcEnumerationsMayNotHaveMembers(), (trimRangeToLine m))) 
 
                         match classMemberDef, containerInfo with
-                        | SynMemberDefn.ImplicitCtor (vis, Attributes attrs, spats, thisIdOpt, m), ContainerInfo(_, Some(MemberOrValContainerInfo(tcref, _, baseValOpt, safeInitInfo, _))) ->
+                        | SynMemberDefn.ImplicitCtor (vis, Attributes attrs, SynSimplePats.SimplePats(spats, _), thisIdOpt, m), ContainerInfo(_, Some(MemberOrValContainerInfo(tcref, _, baseValOpt, safeInitInfo, _))) ->
                             if tcref.TypeOrMeasureKind = TyparKind.Measure then
                                 error(Error(FSComp.SR.tcMeasureDeclarationsRequireStaticMembers(), m))
 
@@ -15016,7 +15016,7 @@ module EstablishTypeDefinitionCores =
               match implicitCtorSynPats with
               | None -> ()
               | Some spats -> 
-                  let ctorArgNames, (_, names, _) = TcSimplePatsOfUnknownType cenv true NoCheckCxs env tpenv (SynSimplePats.SimplePats (spats, m))
+                  let ctorArgNames, (_, names, _) = TcSimplePatsOfUnknownType cenv true NoCheckCxs env tpenv spats
                   for arg in ctorArgNames do
                       let ty = names.[arg].Type
                       let m = names.[arg].Ident.idRange
@@ -15816,7 +15816,7 @@ module EstablishTypeDefinitionCores =
                               ()
                           | Some spats -> 
                               if tycon.IsFSharpStructOrEnumTycon then 
-                                  let ctorArgNames, (_, names, _) = TcSimplePatsOfUnknownType cenv true CheckCxs envinner tpenv (SynSimplePats.SimplePats (spats, m))
+                                  let ctorArgNames, (_, names, _) = TcSimplePatsOfUnknownType cenv true CheckCxs envinner tpenv spats
                                   for arg in ctorArgNames do
                                       let ty = names.[arg].Type
                                       let id = names.[arg].Ident
@@ -16621,7 +16621,7 @@ module TcDeclarations =
 
             let implicitCtorSynPats = 
                 members |> List.tryPick (function 
-                    | SynMemberDefn.ImplicitCtor (_, _, spats, _, _) -> Some spats
+                    | SynMemberDefn.ImplicitCtor (_, _, (SynSimplePats.SimplePats _ as spats), _, _) -> Some spats
                     | _ -> None)
 
             // An ugly bit of code to pre-determine if a type has a nullary constructor, prior to establishing the 
@@ -16630,7 +16630,7 @@ module TcDeclarations =
                 members |> List.exists (function 
                     | SynMemberDefn.Member(Binding(_, _, _, _, _, _, SynValData(Some memberFlags, _, _), SynPatForConstructorDecl SynPatForNullaryArgs, _, _, _, _), _) -> 
                         memberFlags.MemberKind=MemberKind.Constructor 
-                    | SynMemberDefn.ImplicitCtor (_, _, spats, _, _) -> isNil spats
+                    | SynMemberDefn.ImplicitCtor (_, _, SynSimplePats.SimplePats(spats, _), _, _) -> isNil spats
                     | _ -> false)
             let repr = SynTypeDefnSimpleRepr.General(kind, inherits, slotsigs, fields, isConcrete, isIncrClass, implicitCtorSynPats, m)
             let isAtOriginalTyconDefn = not (isAugmentationTyconDefnRepr repr)

src/fsharp/ast.fs

@@ -1310,7 +1310,7 @@ and
 
     /// An object oriented type definition. This is not a parse-tree form, but represents the core
     /// type representation which the type checker splits out from the "ObjectModel" cases of type definitions.
-    | General of SynTypeDefnKind * (SynType * range * Ident option) list * (SynValSig * MemberFlags) list * SynField list  * bool * bool * SynSimplePat list option * range: range
+    | General of SynTypeDefnKind * (SynType * range * Ident option) list * (SynValSig * MemberFlags) list * SynField list  * bool * bool * SynSimplePats option * range: range
 
     /// A type defined by using an IL assembly representation. Only used in FSharp.Core.
     ///
@@ -1525,7 +1525,7 @@ and
     | Member of memberDefn: SynBinding * range: range
 
     /// implicit ctor args as a defn line, 'as' specification
-    | ImplicitCtor of accessiblity: SynAccess option * attributes: SynAttributes * ctorArgs: SynSimplePat list * selfIdentifier: Ident option * range: range
+    | ImplicitCtor of accessiblity: SynAccess option * attributes: SynAttributes * ctorArgs: SynSimplePats * selfIdentifier: Ident option * range: range
 
     /// inherit <typ>(args...) as base
     | ImplicitInherit of inheritType: SynType * inheritArgs: SynExpr * inheritAlias: Ident option * range: range

src/fsharp/pars.fsy

@@ -2735,38 +2735,51 @@ bindingPattern:
       {  let xmlDoc = grabXmlDoc(parseState,1)
          mkSynBinding (xmlDoc,$1), rhs parseState 1 }
 
-/* sp = v | sp:typ | attrs sp */
+// Subset of patterns allowed to be used in implicit ctors.
+// For a better error recovery we could replace these rules with the actual SynPat parsing
+// and use allowed patterns only at a later analysis stage reporting errors along the way.
 simplePattern:
-  | ident 
-      { SynSimplePat.Id ($1,None,false,false,false,rhs parseState 1) }
-  | QMARK ident 
-      { SynSimplePat.Id ($2,None,false,false,true,rhs parseState 2) }
+  | ident
+      { let m = rhs parseState 1 
+        SynPat.Named(SynPat.Wild m, $1, false, None, m) }
+  | QMARK ident
+      { SynPat.OptionalVal($2, rhs parseState 2) }
   | simplePattern COLON typeWithTypeConstraints
-      { let lhsm = lhs parseState 
-        SynSimplePat.Typed($1,$3,lhsm) }
+      { SynPat.Typed($1, $3, lhs parseState) }
   | attributes simplePattern %prec paren_pat_attribs
-      { let lhsm = lhs parseState 
-        SynSimplePat.Attrib($2,$1,lhsm) }
+      { SynPat.Attrib($2, $1, lhs parseState) }
 
 simplePatternCommaList:
-  | simplePattern 
-      { [$1] }
-  | simplePattern COMMA simplePatternCommaList 
-      { $1 :: $3 }
+  | simplePattern
+      { $1 }
+  | simplePattern COMMA simplePatternCommaList
+      { match $3 with
+        | SynPat.Tuple(_, pats, _) -> SynPat.Tuple(false, $1 :: pats, rhs2 parseState 1 3)
+        | _ -> SynPat.Tuple(false, [$1; $3], rhs2 parseState 1 3) }
 
 simplePatterns:
-  | LPAREN simplePatternCommaList rparen 
-      { $2 }
-  | LPAREN rparen 
-      { [] }
-  | LPAREN simplePatternCommaList recover 
-      { reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnmatchedParen()) 
-        [] }
-  | LPAREN error rparen 
-      { (* silent recovery *) [] }
-  | LPAREN recover 
-      { reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnmatchedParen()) 
-        [] }  
+  | LPAREN simplePatternCommaList rparen
+      { let parenPat = SynPat.Paren($2, rhs2 parseState 1 3)
+        let simplePats, _ = SimplePatsOfPat parseState.SynArgNameGenerator parenPat
+        simplePats }
+  | LPAREN rparen
+      { let pat = SynPat.Const(SynConst.Unit, rhs2 parseState 1 2)
+        let simplePats, _ = SimplePatsOfPat parseState.SynArgNameGenerator pat
+        simplePats }
+  | LPAREN simplePatternCommaList recover
+      { reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnmatchedParen())
+        let parenPat = SynPat.Paren(SynPat.Tuple(false, [], rhs2 parseState 1 2), rhs2 parseState 1 2) // todo: report parsed pats anyway?
+        let simplePats, _ = SimplePatsOfPat parseState.SynArgNameGenerator parenPat
+        simplePats }
+  | LPAREN error rparen
+      { let parenPat = SynPat.Paren(SynPat.Wild(rhs parseState 2), rhs2 parseState 1 3) // silent recovery
+        let simplePats, _ = SimplePatsOfPat parseState.SynArgNameGenerator parenPat
+        simplePats }
+  | LPAREN recover
+      { reportParseErrorAt (rhs parseState 1) (FSComp.SR.parsUnmatchedParen())
+        let pat = SynPat.Wild(lhs parseState)
+        let simplePats, _ = SimplePatsOfPat parseState.SynArgNameGenerator pat
+        simplePats }
 
 
 headBindingPattern:

src/fsharp/service/ServiceAssemblyContent.fs

@@ -765,9 +765,9 @@ module ParsedInput =
         and walkMember = function
             | SynMemberDefn.AbstractSlot (valSig, _, _) -> walkValSig valSig
             | SynMemberDefn.Member (binding, _) -> walkBinding binding
-            | SynMemberDefn.ImplicitCtor (_, Attributes attrs, pats, _, _) ->
+            | SynMemberDefn.ImplicitCtor (_, Attributes attrs, SynSimplePats.SimplePats(simplePats, _), _, _) ->
                 List.iter walkAttribute attrs
-                List.iter walkSimplePat pats
+                List.iter walkSimplePat simplePats
             | SynMemberDefn.ImplicitInherit (t, e, _, _) -> walkType t; walkExpr e
             | SynMemberDefn.LetBindings (bindings, _, _, _) -> List.iter walkBinding bindings
             | SynMemberDefn.Interface (t, members, _) ->

src/fsharp/service/ServiceParseTreeWalk.fs

@@ -606,8 +606,10 @@ module public AstTraversal =
             match m with
             | SynMemberDefn.Open(_longIdent, _range) -> None
             | SynMemberDefn.Member(synBinding, _range) -> traverseSynBinding path synBinding
-            | SynMemberDefn.ImplicitCtor(_synAccessOption, _synAttributes, synSimplePatList, _identOption, _range) ->
-                visitor.VisitSimplePats(synSimplePatList)
+            | SynMemberDefn.ImplicitCtor(_synAccessOption, _synAttributes, simplePats, _identOption, _range) ->
+                match simplePats with
+                | SynSimplePats.SimplePats(simplePats, _) -> visitor.VisitSimplePats(simplePats)
+                | _ -> None
             | SynMemberDefn.ImplicitInherit(synType, synExpr, _identOption, range) -> 
                 [
                     dive () synType.Range (fun () -> 

src/fsharp/service/ServiceUntypedParse.fs

@@ -916,8 +916,8 @@ module UntypedParseImpl =
         and walkMember = function
             | SynMemberDefn.AbstractSlot (valSig, _, _) -> walkValSig valSig
             | SynMemberDefn.Member(binding, _) -> walkBinding binding
-            | SynMemberDefn.ImplicitCtor(_, Attributes attrs, pats, _, _) -> 
-                List.tryPick walkAttribute attrs |> Option.orElse (List.tryPick walkSimplePat pats)
+            | SynMemberDefn.ImplicitCtor(_, Attributes attrs, SynSimplePats.SimplePats(simplePats, _), _, _) -> 
+                List.tryPick walkAttribute attrs |> Option.orElse (List.tryPick walkSimplePat simplePats)
             | SynMemberDefn.ImplicitInherit(t, e, _, _) -> walkType t |> Option.orElse (walkExpr e)
             | SynMemberDefn.LetBindings(bindings, _, _, _) -> List.tryPick walkBinding bindings
             | SynMemberDefn.Interface(t, members, _) ->