Merge master to release/dev16.8

src/fsharp/NicePrint.fs

@@ -892,7 +892,7 @@ module private PrintTypes =
                 | tys -> bracketL (layoutTypesWithInfoAndPrec denv env 2 (wordL (tagKeyword "or")) tys)
             tysL ^^ wordL (tagPunctuation ":") ---
                 bracketL (stat ++ wordL (tagMember nm) ^^ wordL (tagPunctuation ":") ---
-                        ((layoutTypesWithInfoAndPrec denv env 2 (wordL (tagPunctuation "*")) argtys --- wordL (tagPunctuation "->")) --- (layoutTypeWithInfo denv env rty)))
+                        ((layoutTypesWithInfoAndPrec denv env 2 (wordL (tagPunctuation "*")) argtys --- wordL (tagPunctuation "->")) --- (layoutReturnType denv env rty)))
 
 
     /// Layout a unit expression 
@@ -995,6 +995,8 @@ module private PrintTypes =
     and private layoutTypesWithInfoAndPrec denv env prec sep typl = 
         sepListL sep (List.map (layoutTypeWithInfoAndPrec denv env prec) typl)
 
+    and private layoutReturnType denv env rty = layoutTypeWithInfoAndPrec denv env 4 rty
+
     /// Layout a single type, taking TypeSimplificationInfo into account 
     and private layoutTypeWithInfo denv env ty = 
         layoutTypeWithInfoAndPrec denv env 5 ty
@@ -1032,8 +1034,6 @@ module private PrintTypes =
             |> List.map (sepListL (wordL (tagPunctuation "*")))
         allArgsL
 
-    let layoutReturnType denv env rty = layoutTypeWithInfoAndPrec denv env 4 rty
-
     let layoutGenericParameterTypes denv env = 
       function
       | [] -> emptyL

tests/fsharp/tests.fs

@@ -2740,6 +2740,9 @@ module TypecheckTests =
     [<Test>]
     let ``type check neg111`` () = singleNegTest (testConfig' "typecheck/sigs") "neg111"
 
+    [<Test>] 
+    let ``type check neg112`` () = singleNegTest (testConfig' "typecheck/sigs") "neg112"
+
     [<Test>]
     let ``type check neg113`` () = singleNegTest (testConfig' "typecheck/sigs") "neg113"
 

tests/fsharp/typecheck/overloads/neg_known_return_type_and_known_type_arguments.bsl

@@ -8,7 +8,7 @@ Known type parameters: < MonoidSample , Zero >
 Available overloads:
  - static member Zero.Zero :  ^t * Default1 ->  ^t when  ^t : (static member get_Zero : ->  ^t) // Argument at index 1 doesn't match
  - static member Zero.Zero :  ^t * Default1 -> ('a1 -> 'a1) when  ^t : null and  ^t : struct // Argument at index 1 doesn't match
- - static member Zero.Zero :  ^t * Default2 ->  ^t when (FromInt32 or  ^t) : (static member FromInt32 :  ^t * FromInt32 -> int32 ->  ^t) // Argument at index 1 doesn't match
+ - static member Zero.Zero :  ^t * Default2 ->  ^t when (FromInt32 or  ^t) : (static member FromInt32 :  ^t * FromInt32 -> (int32 ->  ^t)) // Argument at index 1 doesn't match
  - static member Zero.Zero :  ^t * Default2 -> ('a1 -> 'a1) when  ^t : null and  ^t : struct // Argument at index 1 doesn't match
  - static member Zero.Zero :  ^t * Default3 ->  ^t when  ^t : (static member get_Empty : ->  ^t) // Argument at index 1 doesn't match
  - static member Zero.Zero : 'a array * Zero -> 'a array // Argument at index 1 doesn't match

tests/fsharp/typecheck/sigs/neg112.bsl

@@ -0,0 +1,6 @@
+
+neg112.fs(20,49,20,62): typecheck error FS0001: A type parameter is missing a constraint 'when (Tuple or  ^options) : (static member TupleMap :  ^options * Tuple -> (('item ->  ^value) ->  ^values))'
+
+neg112.fs(20,31,20,39): typecheck error FS0043: A type parameter is missing a constraint 'when (Tuple or  ^options) : (static member TupleMap :  ^options * Tuple -> (('item ->  ^value) ->  ^values))'
+
+neg112.fs(20,31,20,39): typecheck error FS0043: A type parameter is missing a constraint 'when (Tuple or  ^options) : (static member TupleMap :  ^options * Tuple -> (('item ->  ^value) ->  ^values))'

tests/fsharp/typecheck/sigs/neg112.fs

@@ -0,0 +1,22 @@
+module Something
+type Tuple =
+    static member inline TupleMap ((a, b),          _ : Tuple) = fun f -> (f a, f b)
+    static member inline TupleMap ((a, b, c),       _ : Tuple) = fun f -> (f a, f b, f c)
+    static member inline TupleMap ((a, b, c, d),    _ : Tuple) = fun f -> (f a, f b, f c, f d)
+
+    static member inline Map f (x: 'Tin) : 'Tout =
+        let inline call_2 (a: ^a, b : ^b) = ((^a or ^b) : (static member TupleMap : ^b * _ -> ^t) (b, a))
+        call_2 (Unchecked.defaultof<Tuple>, x) f
+
+type IOption<'T> =
+    abstract member Value : 'T
+
+let inline tupleMap f x = Tuple.Map f x
+
+let inline addOptionValues< ^value, ^options, ^values, 'item when 
+                              'item :> IOption< ^value>>
+                              (addUp : ^values -> ^value, sourceOptions : ^options) =
+    let getValue (i : 'item) = i.Value
+    let allValues : ^values = tupleMap getValue sourceOptions
+    let result : ^value = addUp allValues
+    result

tests/fsharp/typecheck/sigs/neg117.bsl

@@ -6,5 +6,5 @@ Known return type: ('a -> Neg117.TargetA.M1 Microsoft.FSharp.Core.[])
 Known type parameters: < Neg117.TargetA.M1 Microsoft.FSharp.Core.[] , Microsoft.FSharp.Core.obj , Neg117.Superpower.Transformer >
 
 Available overloads:
- - static member Neg117.Superpower.Transformer.Transform :  ^f * Neg117.TargetB.TargetB * Neg117.Superpower.Transformer -> (Neg117.TargetB.TransformerKind ->  ^f) when (Neg117.TargetB.TargetB or  ^f) : (static member Transform :  ^f * Neg117.TargetB.TargetB -> Neg117.TargetB.TransformerKind ->  ^f) // Argument at index 1 doesn't match
- - static member Neg117.Superpower.Transformer.Transform :  ^r * Neg117.TargetA.TargetA * Neg117.Superpower.Transformer -> (Neg117.TargetA.TransformerKind ->  ^r) when (Neg117.TargetA.TargetA or  ^r) : (static member Transform :  ^r * Neg117.TargetA.TargetA -> Neg117.TargetA.TransformerKind ->  ^r) // Argument at index 1 doesn't match
+ - static member Neg117.Superpower.Transformer.Transform :  ^f * Neg117.TargetB.TargetB * Neg117.Superpower.Transformer -> (Neg117.TargetB.TransformerKind ->  ^f) when (Neg117.TargetB.TargetB or  ^f) : (static member Transform :  ^f * Neg117.TargetB.TargetB -> (Neg117.TargetB.TransformerKind ->  ^f)) // Argument at index 1 doesn't match
+ - static member Neg117.Superpower.Transformer.Transform :  ^r * Neg117.TargetA.TargetA * Neg117.Superpower.Transformer -> (Neg117.TargetA.TransformerKind ->  ^r) when (Neg117.TargetA.TargetA or  ^r) : (static member Transform :  ^r * Neg117.TargetA.TargetA -> (Neg117.TargetA.TransformerKind ->  ^r)) // Argument at index 1 doesn't match