revert isStruct

Author: edgarfgp

src/Compiler/Checking/CheckPatterns.fs

@@ -138,7 +138,7 @@ and ValidateOptArgOrder (synSimplePats: SynSimplePats) =
 
     let rec getPats synSimplePats =
         match synSimplePats with
-        | SynSimplePats.SimplePats(p, _, _, m) -> p, m
+        | SynSimplePats.SimplePats(p, _, m) -> p, m
 
     let rec isOptArg pat =
         match pat with
@@ -163,7 +163,7 @@ and TcSimplePats (cenv: cenv) optionalArgsOK checkConstraints ty env patEnv synS
     ValidateOptArgOrder synSimplePats
 
     match synSimplePats with
-    | SynSimplePats.SimplePats ([],_, _, m) ->
+    | SynSimplePats.SimplePats ([],_, m) ->
         // Unit "()" patterns in argument position become SynSimplePats.SimplePats([], _) in the
         // syntactic translation when building bindings. This is done because the
         // use of "()" has special significance for arity analysis and argument counting.
@@ -179,12 +179,12 @@ and TcSimplePats (cenv: cenv) optionalArgsOK checkConstraints ty env patEnv synS
         let patEnvR = TcPatLinearEnv(tpenv, namesR, takenNamesR)
         [id.idText], patEnvR
 
-    | SynSimplePats.SimplePats (pats = [synSimplePat]; isStruct = _isStruct) ->
+    | SynSimplePats.SimplePats (pats = [synSimplePat]) ->
         let v, patEnv = TcSimplePat optionalArgsOK checkConstraints cenv ty env patEnv synSimplePat []
         [v], patEnv
 
-    | SynSimplePats.SimplePats (ps, isStruct, _, m) ->
-        let _, ptys = UnifyTupleTypeAndInferCharacteristics env.eContextInfo cenv env.DisplayEnv m ty isStruct ps
+    | SynSimplePats.SimplePats (ps, _, m) ->
+        let _, ptys = UnifyTupleTypeAndInferCharacteristics env.eContextInfo cenv env.DisplayEnv m ty true ps
         let ps', patEnvR = (patEnv, List.zip ptys ps) ||> List.mapFold (fun patEnv (ty, pat) -> TcSimplePat optionalArgsOK checkConstraints cenv ty env patEnv pat [])
         ps', patEnvR
 

src/Compiler/Checking/Expressions/CheckComputationExpressions.fs

@@ -122,7 +122,7 @@ let mkSimplePatForVarSpace m (patvs: Val list) =
         | [ v ] -> [ mkSynSimplePatVar false v.Id ]
         | vs -> vs |> List.map (fun v -> mkSynSimplePatVar false v.Id)
 
-    SynSimplePats.SimplePats(spats, false, [], m)
+    SynSimplePats.SimplePats(spats, [], m)
 
 let mkPatForVarSpace m (patvs: Val list) =
     match patvs with
@@ -3110,7 +3110,7 @@ let TcComputationExpression (cenv: TcFileState) env (overallTy: OverallTy) tpenv
         SynExpr.Lambda(
             false,
             false,
-            SynSimplePats.SimplePats([ mkSynSimplePatVar false (mkSynId mBuilderVal builderValName) ], false, [], mBuilderVal),
+            SynSimplePats.SimplePats([ mkSynSimplePatVar false (mkSynId mBuilderVal builderValName) ], [], mBuilderVal),
             runExpr,
             None,
             mBuilderVal,

src/Compiler/Checking/Expressions/CheckExpressions.fs

@@ -5795,7 +5795,7 @@ and TcExprUndelayed (cenv: cenv) (overallTy: OverallTy) env tpenv (synExpr: SynE
         let unaryArg = mkSynId trivia.UnderscoreRange (cenv.synArgNameGenerator.New())
         let svar = mkSynCompGenSimplePatVar unaryArg
         let pushedExpr = pushUnaryArg synExpr unaryArg
-        let lambda = SynExpr.Lambda(false, false, SynSimplePats.SimplePats([ svar ], false, [], svar.Range), pushedExpr, None, m, SynExprLambdaTrivia.Zero)
+        let lambda = SynExpr.Lambda(false, false, SynSimplePats.SimplePats([ svar ], [], svar.Range), pushedExpr, None, m, SynExprLambdaTrivia.Zero)
         TcIteratedLambdas cenv true env overallTy Set.empty tpenv lambda
     | SynExpr.Lambda _ ->
         TcIteratedLambdas cenv true env overallTy Set.empty tpenv synExpr

src/Compiler/SyntaxTree/SyntaxTree.fs

@@ -927,7 +927,7 @@ type SynStaticOptimizationConstraint =
 
 [<NoEquality; NoComparison; RequireQualifiedAccess>]
 type SynSimplePats =
-    | SimplePats of pats: SynSimplePat list * isStruct: bool * commaRanges: range list * range: range
+    | SimplePats of pats: SynSimplePat list * commaRanges: range list * range: range
 
     member x.Range =
         match x with

src/Compiler/SyntaxTree/SyntaxTree.fsi

@@ -1062,7 +1062,7 @@ type SynStaticOptimizationConstraint =
 /// "fun v -> match v with ..."
 [<NoEquality; NoComparison; RequireQualifiedAccess>]
 type SynSimplePats =
-    | SimplePats of pats: SynSimplePat list * isStruct: bool * commaRanges: range list * range: range
+    | SimplePats of pats: SynSimplePat list * commaRanges: range list * range: range
 
     member Range: range
 

src/Compiler/SyntaxTree/SyntaxTreeOps.fs

@@ -380,16 +380,16 @@ let rec SimplePatsOfPat synArgNameGenerator p =
         let ps2, laterF =
             List.foldBack (fun (p', rhsf) (ps', rhsf') -> p' :: ps', (composeFunOpt rhsf rhsf')) sps ([], None)
 
-        SynSimplePats.SimplePats(ps2, isStruct, commas, m), laterF
+        SynSimplePats.SimplePats(ps2, commas, m), laterF
 
     | SynPat.Paren(SynPat.Const(SynConst.Unit, m), _)
 
-    | SynPat.Const(SynConst.Unit, m) -> SynSimplePats.SimplePats([], false, [], m), None
+    | SynPat.Const(SynConst.Unit, m) -> SynSimplePats.SimplePats([], [], m), None
 
     | _ ->
         let m = p.Range
         let sp, laterF = SimplePatOfPat synArgNameGenerator p
-        SynSimplePats.SimplePats([ sp ], false, [], m), laterF
+        SynSimplePats.SimplePats([ sp ], [], m), laterF
 
 let PushPatternToExpr synArgNameGenerator isMember pat (rhs: SynExpr) =
     let nowPats, laterF = SimplePatsOfPat synArgNameGenerator pat
@@ -513,7 +513,7 @@ let mkSynUnitPat m = SynPat.Const(SynConst.Unit, m)
 
 let mkSynDelay m e =
     let svar = mkSynCompGenSimplePatVar (mkSynId m "unitVar")
-    SynExpr.Lambda(false, false, SynSimplePats.SimplePats([ svar ], false, [], m), e, None, m, SynExprLambdaTrivia.Zero)
+    SynExpr.Lambda(false, false, SynSimplePats.SimplePats([ svar ], [], m), e, None, m, SynExprLambdaTrivia.Zero)
 
 let mkSynAssign (l: SynExpr) (r: SynExpr) =
     let m = unionRanges l.Range r.Range

tests/FSharp.Compiler.ComponentTests/Language/TupleTests.fs

@@ -35,16 +35,16 @@ for x, y in [1, 2] do ()
      |> typecheck
      |> shouldSucceed     
 
-    [<Fact>]
-    let ``Simple reference tuple destructuring in a lambda`` () =
-        FSharp """
-type Class() =
-    member _.Method(x:(int*int)[]) =
-        x |> Array.iter (fun (a, b) -> ())
-    """
-     |> ignoreWarnings
-     |> typecheck
-     |> shouldSucceed
+//     [<Fact>]
+//     let ``Simple reference tuple destructuring in a lambda`` () =
+//         FSharp """
+// type Class() =
+//     member _.Method(x:(int*int)[]) =
+//         x |> Array.iter (fun (a, b) -> ())
+//     """
+//      |> ignoreWarnings
+//      |> typecheck
+//      |> shouldSucceed
 
     [<Fact>]
     let ``Function - Simple tuple destructuring in a lambda`` () =
@@ -190,15 +190,15 @@ let f (a: struct (int * int)) =
      |> typecheck
      |> shouldSucceed
 
-    [<Fact>]
-    let ``Function - Simple struct tuple destructuring in a lambda`` () =
-        FSharp """
-let f (a: struct (int * int) list) =
-    a |> List.map fst
-    """
-     |> ignoreWarnings
-     |> typecheck
-     |> shouldSucceed
+//     [<Fact>]
+//     let ``Function - Simple struct tuple destructuring in a lambda`` () =
+//         FSharp """
+// let f (a: struct (int * int) list) =
+//     a |> List.map fst
+//     """
+//      |> ignoreWarnings
+//      |> typecheck
+//      |> shouldSucceed
 
     [<Fact>]
     let ``Function - Simple struct tuple destructuring in a match lambda AppExpr`` () =