Remove the dead ImplicitYield language-feature flag

src/Compiler/Checking/Expressions/CheckArrayOrListComputedExpressions.fs

@@ -53,21 +53,8 @@ let TcArrayOrListComputedExpression (cenv: TcFileState) env (overallTy: OverallT
 
     | None ->
 
-        // LanguageFeatures.ImplicitYield do not require this validation
-        let implicitYieldEnabled =
-            cenv.g.langVersion.SupportsFeature LanguageFeature.ImplicitYield
-
-        let validateExpressionWithIfRequiresParenthesis = not implicitYieldEnabled
-        let acceptDeprecatedIfThenExpression = not implicitYieldEnabled
-
         match comp with
-        | SimpleSemicolonSequence cenv acceptDeprecatedIfThenExpression elems ->
-            match comp with
-            | SimpleSemicolonSequence cenv false _ -> ()
-            | _ when validateExpressionWithIfRequiresParenthesis ->
-                errorR (Deprecated(FSComp.SR.tcExpressionWithIfRequiresParenthesis (), m))
-            | _ -> ()
-
+        | SimpleSemicolonSequence false elems ->
             let replacementExpr =
                 if isArray then
                     // This are to improve parsing/processing speed for parser tables by converting to an array blob ASAP

src/Compiler/Checking/Expressions/CheckComputationExpressions.fs

@@ -3037,11 +3037,10 @@ let TcComputationExpression (cenv: TcFileState) env (overallTy: OverallTy) tpenv
     // 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 =
-        cenv.g.langVersion.SupportsFeature LanguageFeature.ImplicitYield
-        && (hasMethInfo "Yield" cenv env mBuilderVal ad builderTy
-            && hasMethInfo "Combine" cenv env mBuilderVal ad builderTy
-            && hasMethInfo "Delay" cenv env mBuilderVal ad builderTy
-            && YieldFree cenv comp)
+        hasMethInfo "Yield" cenv env mBuilderVal ad builderTy
+        && hasMethInfo "Combine" cenv env mBuilderVal ad builderTy
+        && hasMethInfo "Delay" cenv env mBuilderVal ad builderTy
+        && YieldFree comp
 
     let origComp = comp
 

src/Compiler/Checking/Expressions/CheckExpressionsOps.fs

@@ -180,69 +180,35 @@ let RewriteRangeExpr synExpr =
     | _ -> None
 
 /// Check if a computation or sequence expression is syntactically free of 'yield' (though not yield!)
-let YieldFree (cenv: TcFileState) expr =
-    if cenv.g.langVersion.SupportsFeature LanguageFeature.ImplicitYield then
+let YieldFree expr =
+    let rec YieldFree expr =
+        match expr with
+        | SynExpr.Sequential(expr1 = expr1; expr2 = expr2) -> YieldFree expr1 && YieldFree expr2
 
-        // Implement yield free logic for F# Language including the LanguageFeature.ImplicitYield
-        let rec YieldFree expr =
-            match expr with
-            | SynExpr.Sequential(expr1 = expr1; expr2 = expr2) -> YieldFree expr1 && YieldFree expr2
+        | SynExpr.IfThenElse(thenExpr = thenExpr; elseExpr = elseExprOpt) -> YieldFree thenExpr && Option.forall YieldFree elseExprOpt
 
-            | SynExpr.IfThenElse(thenExpr = thenExpr; elseExpr = elseExprOpt) -> YieldFree thenExpr && Option.forall YieldFree elseExprOpt
+        | SynExpr.TryWith(tryExpr = body; withCases = clauses) ->
+            YieldFree body
+            && clauses |> List.forall (fun (SynMatchClause(resultExpr = res)) -> YieldFree res)
 
-            | SynExpr.TryWith(tryExpr = body; withCases = clauses) ->
-                YieldFree body
-                && clauses |> List.forall (fun (SynMatchClause(resultExpr = res)) -> YieldFree res)
+        | SynExpr.Match(clauses = clauses)
+        | SynExpr.MatchBang(clauses = clauses) -> clauses |> List.forall (fun (SynMatchClause(resultExpr = res)) -> YieldFree res)
 
-            | SynExpr.Match(clauses = clauses)
-            | SynExpr.MatchBang(clauses = clauses) -> clauses |> List.forall (fun (SynMatchClause(resultExpr = res)) -> YieldFree res)
+        | SynExpr.For(doBody = body)
+        | SynExpr.TryFinally(tryExpr = body)
+        | SynExpr.LetOrUse({ Body = body })
+        | SynExpr.While(doExpr = body)
+        | SynExpr.WhileBang(doExpr = body)
+        | SynExpr.ForEach(bodyExpr = body) -> YieldFree body
+        | SynExpr.YieldOrReturn(flags = (true, _)) -> false
 
-            | SynExpr.For(doBody = body)
-            | SynExpr.TryFinally(tryExpr = body)
-            | SynExpr.LetOrUse({ Body = body })
-            | SynExpr.While(doExpr = body)
-            | SynExpr.WhileBang(doExpr = body)
-            | SynExpr.ForEach(bodyExpr = body) -> YieldFree body
-            | SynExpr.YieldOrReturn(flags = (true, _)) -> false
+        | _ -> true
 
-            | _ -> true
+    YieldFree expr
 
-        YieldFree expr
-    else
-        // Implement yield free logic for F# Language without the LanguageFeature.ImplicitYield
-        let rec YieldFree expr =
-            match expr with
-            | SynExpr.Sequential(expr1 = expr1; expr2 = expr2) -> YieldFree expr1 && YieldFree expr2
-
-            | SynExpr.IfThenElse(thenExpr = thenExpr; elseExpr = elseExprOpt) -> YieldFree thenExpr && Option.forall YieldFree elseExprOpt
-
-            | SynExpr.TryWith(tryExpr = e1; withCases = clauses) ->
-                YieldFree e1
-                && clauses |> List.forall (fun (SynMatchClause(resultExpr = res)) -> YieldFree res)
-
-            | SynExpr.Match(clauses = clauses)
-            | SynExpr.MatchBang(clauses = clauses) -> clauses |> List.forall (fun (SynMatchClause(resultExpr = res)) -> YieldFree res)
-
-            | SynExpr.For(doBody = body)
-            | SynExpr.TryFinally(tryExpr = body)
-            | SynExpr.LetOrUse({ Body = body })
-            | SynExpr.While(doExpr = body)
-            | SynExpr.WhileBang(doExpr = body)
-            | SynExpr.ForEach(bodyExpr = body) -> YieldFree body
-
-            | LetOrUse(_, true, _)
-            | SynExpr.YieldOrReturnFrom _
-            | SynExpr.YieldOrReturn _
-            | SynExpr.ImplicitZero _
-            | SynExpr.Do _ -> false
-
-            | _ -> true
-
-        YieldFree expr
-
-let inline IsSimpleSemicolonSequenceElement expr cenv acceptDeprecated =
+let inline IsSimpleSemicolonSequenceElement expr acceptDeprecated =
     match expr with
-    | SynExpr.IfThenElse _ when acceptDeprecated && YieldFree cenv expr -> true
+    | SynExpr.IfThenElse _ when acceptDeprecated && YieldFree expr -> true
     | SynExpr.IfThenElse _
     | SynExpr.TryWith _
     | SynExpr.Match _
@@ -259,15 +225,15 @@ let inline IsSimpleSemicolonSequenceElement expr cenv acceptDeprecated =
     | _ -> true
 
 [<TailCall>]
-let rec TryGetSimpleSemicolonSequenceOfComprehension expr acc cenv acceptDeprecated =
+let rec TryGetSimpleSemicolonSequenceOfComprehension expr acc acceptDeprecated =
     match expr with
     | SynExpr.Sequential(isTrueSeq = true; expr1 = e1; expr2 = e2) ->
-        if IsSimpleSemicolonSequenceElement e1 cenv acceptDeprecated then
-            TryGetSimpleSemicolonSequenceOfComprehension e2 (e1 :: acc) cenv acceptDeprecated
+        if IsSimpleSemicolonSequenceElement e1 acceptDeprecated then
+            TryGetSimpleSemicolonSequenceOfComprehension e2 (e1 :: acc) acceptDeprecated
         else
             ValueNone
     | _ ->
-        if IsSimpleSemicolonSequenceElement expr cenv acceptDeprecated then
+        if IsSimpleSemicolonSequenceElement expr acceptDeprecated then
             ValueSome(List.rev (expr :: acc))
         else
             ValueNone
@@ -276,8 +242,8 @@ let rec TryGetSimpleSemicolonSequenceOfComprehension expr acc cenv acceptDepreca
 /// 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
 [<return: Struct>]
-let (|SimpleSemicolonSequence|_|) cenv acceptDeprecated cexpr =
-    TryGetSimpleSemicolonSequenceOfComprehension cexpr [] cenv acceptDeprecated
+let (|SimpleSemicolonSequence|_|) acceptDeprecated cexpr =
+    TryGetSimpleSemicolonSequenceOfComprehension cexpr [] acceptDeprecated
 
 let elimFastIntegerForLoop (spFor, spTo, id, start: SynExpr, dir, finish: SynExpr, innerExpr, m: range) =
     let mOp = (unionRanges start.Range finish.Range).MakeSynthetic()

src/Compiler/Checking/Expressions/CheckSequenceExpressions.fs

@@ -35,9 +35,7 @@ let TcSequenceExpression (cenv: TcFileState) env tpenv comp (overallTy: OverallT
     // 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 =
-        cenv.g.langVersion.SupportsFeature LanguageFeature.ImplicitYield
-        && (YieldFree cenv comp)
+    let enableImplicitYield = YieldFree comp
 
     let mkSeqDelayedExpr m (coreExpr: Expr) =
         let overallTy = tyOfExpr cenv.g coreExpr
@@ -162,9 +160,6 @@ let TcSequenceExpression (cenv: TcFileState) env tpenv comp (overallTy: OverallT
 
             Some(mkSeqFinally cenv env mTryToLast genOuterTy innerExpr unwindExpr, tpenv)
 
-        | SynExpr.Paren(range = 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)
 
         | SynExpr.DoBang(trivia = { DoBangKeyword = m }) -> error (Error(FSComp.SR.tcDoBangIllegalInSequenceExpression (), m))
@@ -469,16 +464,6 @@ let TcSequenceExpressionEntry (cenv: TcFileState) env (overallTy: OverallTy) tpe
     match RewriteRangeExpr comp with
     | Some replacementExpr -> TcExpr cenv overallTy env tpenv replacementExpr
     | None ->
-        let implicitYieldEnabled =
-            cenv.g.langVersion.SupportsFeature LanguageFeature.ImplicitYield
-
-        let validateObjectSequenceOrRecordExpression = not implicitYieldEnabled
-
-        match comp with
-        | SimpleSemicolonSequence cenv false _ when validateObjectSequenceOrRecordExpression ->
-            errorR (Error(FSComp.SR.tcInvalidObjectSequenceOrRecordExpression (), m))
-        | _ -> ()
-
         if not hasBuilder && not cenv.g.compilingFSharpCore then
             error (Error(FSComp.SR.tcInvalidSequenceExpressionSyntaxForm (), m))
 

src/Compiler/FSComp.txt

@@ -1567,7 +1567,6 @@ featureSingleUnderscorePattern,"single underscore pattern"
 featureWildCardInForLoop,"wild card in for loop"
 featureRelaxWhitespace,"whitespace relaxation"
 featureNameOf,"nameof"
-featureImplicitYield,"implicit yield"
 featureOpenTypeDeclaration,"open type declaration"
 featureDotlessFloat32Literal,"dotless float32 literal"
 featurePackageManagement,"package management"

src/Compiler/Facilities/LanguageFeatures.fs

@@ -21,7 +21,6 @@ type LanguageFeature =
     | RelaxWhitespace
     | RelaxWhitespace2
     | NameOf
-    | ImplicitYield
     | OpenTypeDeclaration
     | DotlessFloat32Literal
     | PackageManagement
@@ -155,7 +154,6 @@ type LanguageVersion(versionText, ?disabledFeaturesArray: LanguageFeature array)
                 LanguageFeature.SingleUnderscorePattern, languageVersion47
                 LanguageFeature.WildCardInForLoop, languageVersion47
                 LanguageFeature.RelaxWhitespace, languageVersion47
-                LanguageFeature.ImplicitYield, languageVersion47
 
                 // F# 5.0
                 LanguageFeature.FixedIndexSlice3d4d, languageVersion50
@@ -369,7 +367,6 @@ type LanguageVersion(versionText, ?disabledFeaturesArray: LanguageFeature array)
         | LanguageFeature.RelaxWhitespace -> FSComp.SR.featureRelaxWhitespace ()
         | LanguageFeature.RelaxWhitespace2 -> FSComp.SR.featureRelaxWhitespace2 ()
         | LanguageFeature.NameOf -> FSComp.SR.featureNameOf ()
-        | LanguageFeature.ImplicitYield -> FSComp.SR.featureImplicitYield ()
         | LanguageFeature.OpenTypeDeclaration -> FSComp.SR.featureOpenTypeDeclaration ()
         | LanguageFeature.DotlessFloat32Literal -> FSComp.SR.featureDotlessFloat32Literal ()
         | LanguageFeature.PackageManagement -> FSComp.SR.featurePackageManagement ()

src/Compiler/Facilities/LanguageFeatures.fsi

@@ -11,7 +11,6 @@ type LanguageFeature =
     | RelaxWhitespace
     | RelaxWhitespace2
     | NameOf
-    | ImplicitYield
     | OpenTypeDeclaration
     | DotlessFloat32Literal
     | PackageManagement