address PR

src/fsharp/FSComp.txt

@@ -574,7 +574,6 @@ 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/TypeChecker.fs

@@ -6049,11 +6049,11 @@ and TcExprUndelayed cenv overallTy env tpenv (synExpr: SynExpr) =
 
     // Used to implement the type-directed 'implicit yield' rule for computation expressions
     | SynExpr.SequentialOrImplicitYield (sp, synExpr1, synExpr2, otherExpr, m) ->
-        let isStmt, e1', tpenv = TryTcStmt cenv env tpenv synExpr1
+        let isStmt, expr1, tpenv = TryTcStmt cenv env tpenv synExpr1
         if isStmt then 
             let env = ShrinkContext env m synExpr2.Range
-            let e2', tpenv = TcExprThatCanBeCtorBody cenv overallTy env tpenv synExpr2 
-            Expr.Sequential(e1', e2', NormalSeq, sp, m), tpenv
+            let expr2, tpenv = TcExprThatCanBeCtorBody cenv overallTy env tpenv synExpr2 
+            Expr.Sequential(expr1, expr2, NormalSeq, sp, m), tpenv
         else
             // The first expression wasn't unit-typed, so proceed to the alternative interpretation
             // Note a copy of the first expression is embedded in 'otherExpr' and thus

tests/fsharp/typecheck/sigs/neg24.bsl

@@ -36,3 +36,9 @@ neg24.fs(312,33,312,34): typecheck error FS0020: The result of this expression h
 neg24.fs(313,38,313,39): typecheck error FS0020: The result of this expression has type 'int' and is implicitly ignored. Consider using 'ignore' to discard this value explicitly, e.g. 'expr |> ignore', or 'let' to bind the result to a name, e.g. 'let result = expr'.
 
 neg24.fs(313,47,313,48): typecheck error FS0020: The result of this expression has type 'int' and is implicitly ignored. Consider using 'ignore' to discard this value explicitly, e.g. 'expr |> ignore', or 'let' to bind the result to a name, e.g. 'let result = expr'.
+
+neg24.fs(331,24,331,25): typecheck error FS0001: The 'if' expression needs to have type 'obj' to satisfy context type requirements. It currently has type 'int'.
+
+neg24.fs(337,30,337,31): typecheck error FS0001: The 'if' expression needs to have type 'obj' to satisfy context type requirements. It currently has type 'int'.
+
+neg24.fs(337,37,337,42): typecheck warning FS0020: The result of this expression has type 'obj' and is implicitly ignored. Consider using 'ignore' to discard this value explicitly, e.g. 'expr |> ignore', or 'let' to bind the result to a name, e.g. 'let result = expr'.

tests/fsharp/typecheck/sigs/neg24.fs

@@ -159,12 +159,12 @@ module ArrayPositive2 =
         [ printfn "hello"
           if true then yield 1 else yield 2 ] 
 
-    // check subsumption is alloed when using explicit yield
+    // check subsumption is allowed when using explicit yield
     let l13 : obj list = 
         [ printfn "hello"
           if true then yield 1 else yield 2 ] 
 
-    // check subsumption is alloed when using explicit yield
+    // check subsumption is allowed when using explicit yield
     let l14 : obj list = 
         [ printfn "hello"
           if true then yield 1 ] 
@@ -231,17 +231,17 @@ module BuilderPositive2 =
           yield! empty
         }
 
-    // Note, no subsumption is permitted when using yield in computation expressions, with or eithout implicit yield
-    //let v3c : L<obj>  = 
-    //    list {
-    //      printfn "hello"
-    //      if true then 1 else obj() 
-    //    } 
-    //let v3c : L<obj>  = 
-    //    list {
-    //      printfn "hello"
-    //      if true then yield 1 else obj() 
-    //    } 
+
+
+
+
+
+
+
+
+
+
+
 
     let v3d = 
         list {
@@ -311,3 +311,29 @@ module ArrayNegative2 =
 module SeqNegative2 = 
     let s5 = seq { if true then 1 else yield 2 } // expect warning about "1" being ignored. There is a 'yield' so statements are statements.
     let s8 = seq { match 1 with 1 -> 4 | 2 -> 5 | 3 -> yield 6 | _ -> ()  } // expect warning about "4" being ignored. There is a 'yield' so statements are statements.
+
+module BuilderNegative2 = 
+    type L<'T> = { Make: (unit -> 'T list) }
+    let L f = { Make = f }
+
+    type ListBuilder() = 
+        member __.Combine(x1: L<'T>, x2: L<'T>) = L(fun () -> x1.Make() @ x2.Make())
+        member __.Delay(f: unit -> L<'T>) = L(fun () -> f().Make())
+        member __.Zero() = L(fun () -> [])
+        member __.Yield(a: 'T) = L(fun () -> [a])
+        member __.YieldFrom(x: L<'T>) = x
+
+    let list = ListBuilder()
+
+    let v3c : L<obj>  = 
+        list {
+          printfn "hello"
+          if true then 1 else obj() 
+        } 
+
+    let v3c : L<obj>  = 
+        list {
+          printfn "hello"
+          if true then yield 1 else obj() 
+        } 
+