Implement Langversion switch for implicit yields (#7166)

* Langversion tests for ImplicitYield

* tweak

* Update single-test.fs

removed some printfns

* Feedback

* One more cleanup

* Uncore une fois

* Update TypeChecker.fs

Fix bug

Author: KevinRansom

src/fsharp/FSComp.txt

@@ -574,6 +574,7 @@ tcUseWhenPatternGuard,"Character range matches have been removed in F#. Consider
 736,tcExprUndelayed,"TcExprUndelayed: delayed"
 737,tcExpressionRequiresSequence,"This expression form may only be used in sequence and computation expressions"
 738,tcInvalidObjectExpressionSyntaxForm,"Invalid object expression. Objects without overrides or interfaces should use the expression form 'new Type(args)' without braces."
+739,tcInvalidObjectSequenceOrRecordExpression,"Invalid object, sequence or record expression"
 740,tcInvalidSequenceExpressionSyntaxForm,"Invalid record, sequence or computation expression. Sequence expressions should be of the form 'seq {{ ... }}'"
 tcExpressionWithIfRequiresParenthesis,"This list or array expression includes an element of the form 'if ... then ... else'. Parenthesize this expression to indicate it is an individual element of the list or array, to disambiguate this from a list generated using a sequence expression"
 741,tcUnableToParseFormatString,"Unable to parse format string '%s'"

src/fsharp/LanguageFeatures.fs

@@ -25,6 +25,8 @@ type LanguageFeature =
     | WildCardInForLoop = 3
     | RelaxWhitespace = 4
     | NameOf = 5
+    | ImplicitYield = 6
+
 
 /// LanguageVersion management
 type LanguageVersion (specifiedVersion) =
@@ -49,6 +51,7 @@ type LanguageVersion (specifiedVersion) =
         LanguageFeature.WildCardInForLoop, previewVersion
         LanguageFeature.RelaxWhitespace, previewVersion
         LanguageFeature.NameOf, previewVersion
+        LanguageFeature.ImplicitYield, previewVersion
         |]
 
     let specified =

src/fsharp/LanguageFeatures.fsi

@@ -12,6 +12,8 @@ type LanguageFeature =
     | WildCardInForLoop = 3
     | RelaxWhitespace = 4
     | NameOf = 5
+    | ImplicitYield = 6
+
 
 /// LanguageVersion management
 type LanguageVersion =

src/fsharp/TypeChecker.fs

@@ -3518,14 +3518,84 @@ let (|ExprAsPat|_|) (f: SynExpr) =
             None
     | _ -> None
 
+/// Check if a computation or sequence expression is syntactically free of 'yield' (though not yield!)
+let YieldFree cenv expr =
+    if cenv.g.langVersion.SupportsFeature LanguageFeature.ImplicitYield then
+
+        // Implement yield free logic for F# Language including the LanguageFeature.ImplicitYield
+        let rec YieldFree expr =
+            match expr with
+            | SynExpr.Sequential (_, _, e1, e2, _) ->
+                YieldFree e1 && YieldFree e2
+
+            | SynExpr.IfThenElse (_, e2, e3opt, _, _, _, _) ->
+                YieldFree e2 && Option.forall YieldFree e3opt
+
+            | SynExpr.TryWith (e1, _, clauses, _, _, _, _) ->
+                YieldFree e1 && clauses |> List.forall (fun (Clause(_, _, e, _, _)) -> YieldFree e)
+
+            | (SynExpr.Match (_, _, clauses, _) | SynExpr.MatchBang (_, _, clauses, _)) ->
+                clauses |> List.forall (fun (Clause(_, _, e, _, _)) -> YieldFree e)
+
+            | SynExpr.For (_, _, _, _, _, body, _)
+            | SynExpr.TryFinally (body, _, _, _, _)
+            | SynExpr.LetOrUse (_, _, _, body, _)
+            | SynExpr.While (_, _, body, _)
+            | SynExpr.ForEach (_, _, _, _, _, body, _) ->
+                YieldFree body
+
+            | SynExpr.LetOrUseBang(_, _, _, _, _, body, _) ->
+                YieldFree body
+
+            | SynExpr.YieldOrReturn((true, _), _, _) -> false
+
+            | _ -> true
+
+        YieldFree expr
+    else
+        // Implement yield free logic for F# Language without the LanguageFeature.ImplicitYield
+        let rec YieldFree expr =
+            match expr with
+            | SynExpr.Sequential (_, _, e1, e2, _) ->
+                YieldFree e1 && YieldFree e2
+
+            | SynExpr.IfThenElse (_, e2, e3opt, _, _, _, _) ->
+                YieldFree e2 && Option.forall YieldFree e3opt
+
+            | SynExpr.TryWith (e1, _, clauses, _, _, _, _) ->
+                YieldFree e1 && clauses |> List.forall (fun (Clause(_, _, e, _, _)) -> YieldFree e)
+
+            | (SynExpr.Match (_, _, clauses, _) | SynExpr.MatchBang (_, _, clauses, _)) ->
+                clauses |> List.forall (fun (Clause(_, _, e, _, _)) -> YieldFree e)
+
+            | SynExpr.For (_, _, _, _, _, body, _)
+            | SynExpr.TryFinally (body, _, _, _, _)
+            | SynExpr.LetOrUse (_, _, _, body, _)
+            | SynExpr.While (_, _, body, _)
+            | SynExpr.ForEach (_, _, _, _, _, body, _) ->
+                YieldFree body
+
+            | SynExpr.LetOrUseBang _
+            | SynExpr.YieldOrReturnFrom _
+            | SynExpr.YieldOrReturn _
+            | SynExpr.ImplicitZero _
+            | SynExpr.Do _ -> false
+
+            | _ -> true
+
+        YieldFree expr
+
+
 /// Determine if a syntactic expression inside 'seq { ... }' or '[...]' counts as a "simple sequence
 /// of semicolon separated values". For example [1;2;3].
+/// 'acceptDeprecated' is true for the '[ ... ]' case, where we allow the syntax '[ if g then t else e ]' but ask it to be parenthesized
 ///
-let (|SimpleSemicolonSequence|_|) cexpr = 
+let (|SimpleSemicolonSequence|_|) cenv acceptDeprecated cexpr = 
 
     let IsSimpleSemicolonSequenceElement expr = 
-        match expr with 
-        | SynExpr.IfThenElse _ 
+        match expr with
+        | SynExpr.IfThenElse _ when acceptDeprecated && YieldFree cenv expr -> true
+        | SynExpr.IfThenElse _
         | SynExpr.TryWith _ 
         | SynExpr.Match _ 
         | SynExpr.For _ 
@@ -5734,6 +5804,13 @@ and TcExprUndelayedNoType cenv env tpenv synExpr: Expr * TType * _ =
     expr, overallTy, tpenv
 
 and TcExprUndelayed cenv overallTy env tpenv (synExpr: SynExpr) =
+
+    // LanguageFeatures.ImplicitYield do not require this validation
+    let implicitYieldEnabled = cenv.g.langVersion.SupportsFeature LanguageFeature.ImplicitYield
+    let validateObjectSequenceOrRecordExpression = not implicitYieldEnabled
+    let validateExpressionWithIfRequiresParenethesis = not implicitYieldEnabled
+    let acceptDeprecatedIfThenExpression = not implicitYieldEnabled
+
     match synExpr with 
     | SynExpr.Paren (expr2, _, _, mWholeExprIncludingParentheses) -> 
         // We invoke CallExprHasTypeSink for every construct which is atomic in the syntax, i.e. where a '.' immediately following the 
@@ -5932,6 +6009,8 @@ and TcExprUndelayed cenv overallTy env tpenv (synExpr: SynExpr) =
             match comp with 
             | SynExpr.New _ -> 
                 errorR(Error(FSComp.SR.tcInvalidObjectExpressionSyntaxForm(), m))
+            | SimpleSemicolonSequence cenv false _ when validateObjectSequenceOrRecordExpression ->
+                errorR(Error(FSComp.SR.tcInvalidObjectSequenceOrRecordExpression(), m))
             | _ -> 
                 ()
         if not !isNotNakedRefCell && not cenv.g.compilingFslib then 
@@ -5941,9 +6020,12 @@ and TcExprUndelayed cenv overallTy env tpenv (synExpr: SynExpr) =
 
     | SynExpr.ArrayOrListOfSeqExpr (isArray, comp, m) ->
         CallExprHasTypeSink cenv.tcSink (m, env.NameEnv, overallTy, env.DisplayEnv, env.eAccessRights)
-
         match comp with 
-        | SynExpr.CompExpr (_, _, SimpleSemicolonSequence elems, _) -> 
+        | SynExpr.CompExpr (_, _, (SimpleSemicolonSequence cenv acceptDeprecatedIfThenExpression elems as body), _) -> 
+            match body with
+            | SimpleSemicolonSequence cenv false _ -> ()
+            | _ when validateExpressionWithIfRequiresParenethesis -> errorR(Deprecated(FSComp.SR.tcExpressionWithIfRequiresParenthesis(), m))
+            | _ -> ()
 
             let replacementExpr = 
                 if isArray then 
@@ -7331,31 +7413,6 @@ and TcQuotationExpr cenv overallTy env tpenv (_oper, raw, ast, isFromQueryExpres
 /// Ignores an attribute
 and IgnoreAttribute _ = None
 
-/// Check if a computation or sequence expression is syntactically free of 'yield' (though not yield!)
-and YieldFree expr =
-    match expr with
-    | SynExpr.Sequential (_, _, e1, e2, _) -> YieldFree e1 && YieldFree e2
-    | SynExpr.IfThenElse (_, e2, e3opt, _, _, _, _) -> YieldFree e2 && Option.forall YieldFree e3opt
-    | SynExpr.TryWith (e1, _, clauses, _, _, _, _) -> 
-        YieldFree e1 && clauses |> List.forall (fun (Clause(_, _, e, _, _)) -> YieldFree e)
-    | (SynExpr.Match (_, _, clauses, _) | SynExpr.MatchBang (_, _, clauses, _)) ->
-        clauses |> List.forall (fun (Clause(_, _, e, _, _)) -> YieldFree e)
-    | SynExpr.For (_, _, _, _, _, body, _)
-    | SynExpr.TryFinally (body, _, _, _, _)
-    | SynExpr.LetOrUse (_, _, _, body, _)
-    | SynExpr.LetOrUseBang(_, _, _, _, _, body, _) 
-    | SynExpr.LetOrUse (_, _, _, body, _)
-    | SynExpr.While (_, _, body, _)
-    | SynExpr.ForEach (_, _, _, _, _, body, _) -> 
-        YieldFree body
-
-    // 'yield!' in expressions doesn't trigger the 'yield free' rule
-    //| SynExpr.YieldOrReturnFrom _
-    | SynExpr.YieldOrReturn((true, _), _, _) -> 
-        false
-
-    | _ -> true    
-
 /// Used for all computation expressions except sequence expressions
 and TcComputationExpression cenv env overallTy mWhole (interpExpr: Expr) builderTy tpenv (comp: SynExpr) = 
 
@@ -7814,7 +7871,9 @@ and TcComputationExpression cenv env overallTy mWhole (interpExpr: Expr) builder
     // If there are no 'yield' in the computation expression, and the builder supports 'Yield',
     // then allow the type-directed rule interpreting non-unit-typed expressions in statement
     // positions as 'yield'.  'yield!' may be present in the computation expression.
-    let enableImplicitYield = hasMethInfo "Yield" && hasMethInfo "Combine"  && hasMethInfo "Delay" && YieldFree comp
+    let enableImplicitYield =
+        cenv.g.langVersion.SupportsFeature LanguageFeature.ImplicitYield
+        && (hasMethInfo "Yield" && hasMethInfo "Combine"  && hasMethInfo "Delay" && YieldFree cenv comp)
 
     // q              - a flag indicating if custom operators are allowed. They are not allowed inside try/with, try/finally, if/then/else etc.
     // varSpace       - a lazy data structure indicating the variables bound so far in the overall computation
@@ -8200,8 +8259,7 @@ and TcComputationExpression cenv env overallTy mWhole (interpExpr: Expr) builder
                 | _ -> 
                     Some (trans true q varSpace innerComp2 (fun holeFill ->
                         let fillExpr = 
-                            if enableImplicitYield then 
-                                
+                            if enableImplicitYield then
                                 // When implicit yields are enabled, then if the 'innerComp1' checks as type
                                 // 'unit' we interpret the expression as a sequential, and when it doesn't
                                 // have type 'unit' we interpret it as a 'Yield + Combine'.
@@ -8443,7 +8501,9 @@ and TcSequenceExpression cenv env tpenv comp overallTy m =
     // If there are no 'yield' in the computation expression then allow the type-directed rule
     // interpreting non-unit-typed expressions in statement positions as 'yield'.  'yield!' may be  
     // present in the computation expression.
-    let enableImplicitYield = YieldFree comp
+    let enableImplicitYield =
+        cenv.g.langVersion.SupportsFeature LanguageFeature.ImplicitYield
+        && (YieldFree cenv comp)
 
     let mkDelayedExpr (coreExpr: Expr) = 
         let m = coreExpr.Range
@@ -8505,6 +8565,9 @@ and TcSequenceExpression cenv env tpenv comp overallTy m =
 
             Some(mkSeqFinally cenv env innerExprMark genOuterTy innerExpr unwindExpr, tpenv)
 
+        | SynExpr.Paren (_, _, _, m) when not (cenv.g.langVersion.SupportsFeature LanguageFeature.ImplicitYield)->
+            error(Error(FSComp.SR.tcConstructIsAmbiguousInSequenceExpression(), m))
+
         | SynExpr.ImplicitZero m -> 
             Some(mkSeqEmpty cenv env m genOuterTy, tpenv )
 

src/fsharp/xlf/FSComp.txt.cs.xlf

@@ -2847,6 +2847,11 @@
         <target state="translated">Neplatný objektový výraz. U objektů bez přepsání nebo rozhraní by se měl výraz formulovat pomocí notace new Type(args) bez složených závorek.</target>
         <note />
       </trans-unit>
+      <trans-unit id="tcInvalidObjectSequenceOrRecordExpression">
+        <source>Invalid object, sequence or record expression</source>
+        <target state="translated">Neplatný výraz objektu, pořadí nebo záznamu</target>
+        <note />
+      </trans-unit>
       <trans-unit id="tcInvalidSequenceExpressionSyntaxForm">
         <source>Invalid record, sequence or computation expression. Sequence expressions should be of the form 'seq {{ ... }}'</source>
         <target state="translated">Neplatný výraz záznamu, pořadí nebo výpočtu. Výrazy pořadí by měly mít notaci seq {{ ... }}.</target>

src/fsharp/xlf/FSComp.txt.de.xlf

@@ -2847,6 +2847,11 @@
         <target state="translated">Ungültiger Objektausdruck. Objekte ohne Überschreibungen oder Schnittstellen sollten das Ausdrucksformat "new Type(args)" ohne geschweifte Klammern verwenden.</target>
         <note />
       </trans-unit>
+      <trans-unit id="tcInvalidObjectSequenceOrRecordExpression">
+        <source>Invalid object, sequence or record expression</source>
+        <target state="translated">Ungültiger Objekt-, Sequenz- oder Datensatzausdruck.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="tcInvalidSequenceExpressionSyntaxForm">
         <source>Invalid record, sequence or computation expression. Sequence expressions should be of the form 'seq {{ ... }}'</source>
         <target state="translated">Ungültiger Datensatz-, Sequenz- oder Berechnungsausdruck. Sequenzausdrücke müssen das Format "seq {{ ... }}" besitzen.</target>

src/fsharp/xlf/FSComp.txt.es.xlf

@@ -2847,6 +2847,11 @@
         <target state="translated">Expresión de objeto no válida. Los objetos sin invalidaciones ni interfaces deben usar el formato de expresión 'new Type(args)' sin llaves.</target>
         <note />
       </trans-unit>
+      <trans-unit id="tcInvalidObjectSequenceOrRecordExpression">
+        <source>Invalid object, sequence or record expression</source>
+        <target state="translated">Expresión de objeto, secuencia o registro no válida.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="tcInvalidSequenceExpressionSyntaxForm">
         <source>Invalid record, sequence or computation expression. Sequence expressions should be of the form 'seq {{ ... }}'</source>
         <target state="translated">Expresión de registro, secuencia o cómputo no válida. Las expresiones de secuencia deben tener el formato 'seq {{ ... }}'.</target>

src/fsharp/xlf/FSComp.txt.fr.xlf

@@ -2847,6 +2847,11 @@
         <target state="translated">Expression d'objet non valide. Les objets sans substitutions ou interfaces doivent utiliser la forme d'expression 'new Type(args)' sans accolades.</target>
         <note />
       </trans-unit>
+      <trans-unit id="tcInvalidObjectSequenceOrRecordExpression">
+        <source>Invalid object, sequence or record expression</source>
+        <target state="translated">Expression d'objet, de séquence ou d'enregistrement non valide</target>
+        <note />
+      </trans-unit>
       <trans-unit id="tcInvalidSequenceExpressionSyntaxForm">
         <source>Invalid record, sequence or computation expression. Sequence expressions should be of the form 'seq {{ ... }}'</source>
         <target state="translated">Expression d'enregistrement, de séquence ou de calcul non valide. Les expressions de séquence doivent avoir le format 'seq {{ ... }}'</target>

src/fsharp/xlf/FSComp.txt.it.xlf

@@ -2847,6 +2847,11 @@
         <target state="translated">Espressione oggetto non valida. Gli oggetti senza override o interfacce devono usare il formato di espressione 'new Type(args)' senza parentesi graffe.</target>
         <note />
       </trans-unit>
+      <trans-unit id="tcInvalidObjectSequenceOrRecordExpression">
+        <source>Invalid object, sequence or record expression</source>
+        <target state="translated">Espressione record, sequenza o oggetto non valida</target>
+        <note />
+      </trans-unit>
       <trans-unit id="tcInvalidSequenceExpressionSyntaxForm">
         <source>Invalid record, sequence or computation expression. Sequence expressions should be of the form 'seq {{ ... }}'</source>
         <target state="translated">Espressione di calcolo, sequenza o record non valida. Il formato delle espressioni sequenza deve essere 'seq {{ ... }}'</target>

src/fsharp/xlf/FSComp.txt.ja.xlf

@@ -2847,6 +2847,11 @@
         <target state="translated">オブジェクト式が無効です。オーバーライドまたはインターフェイスがないオブジェクトには、かっこなしで 'new Type(args)' という形式の式を使用してください。</target>
         <note />
       </trans-unit>
+      <trans-unit id="tcInvalidObjectSequenceOrRecordExpression">
+        <source>Invalid object, sequence or record expression</source>
+        <target state="translated">オブジェクト式、シーケンス式、またはレコード式が無効です</target>
+        <note />
+      </trans-unit>
       <trans-unit id="tcInvalidSequenceExpressionSyntaxForm">
         <source>Invalid record, sequence or computation expression. Sequence expressions should be of the form 'seq {{ ... }}'</source>
         <target state="translated">無効なレコード、シーケンス式、またはコンピュテーション式です。シーケンス式は 'seq {{ ... }}' という形式にしてください。</target>