Use correct precedence when printing contexts with class operators
authorSimon Peyton Jones <simonpj@microsoft.com>
Thu, 2 Oct 2014 16:47:21 +0000 (17:47 +0100)
committerSimon Peyton Jones <simonpj@microsoft.com>
Tue, 7 Oct 2014 07:03:31 +0000 (08:03 +0100)
Fixes Trac #9658

19 files changed:
compiler/types/TypeRep.lhs
testsuite/tests/gadt/T7558.stderr
testsuite/tests/ghci/scripts/Defer02.stderr
testsuite/tests/ghci/scripts/T9658.script [new file with mode: 0644]
testsuite/tests/ghci/scripts/T9658.stdout [new file with mode: 0644]
testsuite/tests/ghci/scripts/all.T
testsuite/tests/indexed-types/should_compile/Simple14.stderr
testsuite/tests/indexed-types/should_fail/ExtraTcsUntch.stderr
testsuite/tests/indexed-types/should_fail/SimpleFail15.stderr
testsuite/tests/indexed-types/should_fail/T2239.stderr
testsuite/tests/indexed-types/should_fail/T4093a.stderr
testsuite/tests/perf/compiler/T5837.stderr
testsuite/tests/polykinds/T7230.stderr
testsuite/tests/roles/should_compile/Roles3.stderr
testsuite/tests/typecheck/should_fail/ContextStack2.stderr
testsuite/tests/typecheck/should_fail/FrozenErrorTests.stderr
testsuite/tests/typecheck/should_fail/T5858.stderr
testsuite/tests/typecheck/should_fail/T7857.stderr
testsuite/tests/typecheck/should_fail/T8392a.stderr

index cc7202f..ef035bb 100644 (file)
@@ -537,7 +537,10 @@ pprTheta theta  = parens (sep (punctuate comma (map (ppr_type TopPrec) theta)))
 
 pprThetaArrowTy :: ThetaType -> SDoc
 pprThetaArrowTy []     = empty
-pprThetaArrowTy [pred] = ppr_type FunPrec pred <+> darrow
+pprThetaArrowTy [pred] = ppr_type TyOpPrec pred <+> darrow
+                         -- TyOpPrec:  Num a     => a -> a  does not need parens
+                         --      bug   (a :~: b) => a -> b  currently does
+                         -- Trac # 9658
 pprThetaArrowTy preds  = parens (fsep (punctuate comma (map (ppr_type TopPrec) preds)))
                             <+> darrow
     -- Notice 'fsep' here rather that 'sep', so that
index f65c743..054c41f 100644 (file)
@@ -5,7 +5,7 @@ T7558.hs:8:4:
           the type signature for f :: T a a -> Bool at T7558.hs:7:6
     Inaccessible code in
       a pattern with constructor
-        MkT :: forall a b. a ~ Maybe b => a -> Maybe b -> T a b,
+        MkT :: forall a b. (a ~ Maybe b) => a -> Maybe b -> T a b,
       in an equation for ‘f’
     Relevant bindings include
       f :: T a a -> Bool (bound at T7558.hs:8:1)
index ba2354b..746fa4e 100644 (file)
 ../../typecheck/should_run/Defer01.hs:45:6: Warning:
     Couldn't match type ‘Int’ with ‘Bool’
     Inaccessible code in
-      the type signature for k :: Int ~ Bool => Int -> Bool
-    In the ambiguity check for: Int ~ Bool => Int -> Bool
+      the type signature for k :: (Int ~ Bool) => Int -> Bool
+    In the ambiguity check for: (Int ~ Bool) => Int -> Bool
     To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
     In the type signature for ‘k’: k :: (Int ~ Bool) => Int -> Bool
 
 ../../typecheck/should_run/Defer01.hs:45:6: Warning:
     Couldn't match expected type ‘Bool’ with actual type ‘Int’
-    In the ambiguity check for: Int ~ Bool => Int -> Bool
+    In the ambiguity check for: (Int ~ Bool) => Int -> Bool
     To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
     In the type signature for ‘k’: k :: (Int ~ Bool) => Int -> Bool
 
 ../../typecheck/should_run/Defer01.hs:45:6: Warning:
     Couldn't match type ‘Int’ with ‘Bool’
     Inaccessible code in
-      the type signature for k :: Int ~ Bool => Int -> Bool
+      the type signature for k :: (Int ~ Bool) => Int -> Bool
 
 ../../typecheck/should_run/Defer01.hs:46:7: Warning:
     Couldn't match expected type ‘Bool’ with actual type ‘Int’
diff --git a/testsuite/tests/ghci/scripts/T9658.script b/testsuite/tests/ghci/scripts/T9658.script
new file mode 100644 (file)
index 0000000..0b1f67e
--- /dev/null
@@ -0,0 +1,4 @@
+:set -XTypeOperators
+:set -XMultiParamTypeClasses
+class a :-: b where op :: a -> b
+:t op
diff --git a/testsuite/tests/ghci/scripts/T9658.stdout b/testsuite/tests/ghci/scripts/T9658.stdout
new file mode 100644 (file)
index 0000000..fdde69c
--- /dev/null
@@ -0,0 +1 @@
+op :: (a :-: b) => a -> b
index f02a3c0..4b20d0b 100755 (executable)
@@ -178,3 +178,4 @@ test('T8959b', expect_broken(8959), ghci_script, ['T8959b.script'])
 test('T9181', normal, ghci_script, ['T9181.script'])
 test('T9086b', normal, ghci_script, ['T9086b.script'])
 test('T9140', combined_output, ghci_script, ['T9140.script'])
+test('T9658', normal, ghci_script, ['T9658.script'])
index e2275b4..3dbf213 100644 (file)
@@ -1,18 +1,18 @@
-\r
-Simple14.hs:17:19:\r
-    Couldn't match type ‘z0’ with ‘m’\r
-      ‘z0’ is untouchable\r
-        inside the constraints (Maybe m ~ Maybe n)\r
-        bound by a type expected by the context:\r
-                   Maybe m ~ Maybe n => EQ_ z0 z0\r
-        at Simple14.hs:17:12-33\r
-      ‘m’ is a rigid type variable bound by\r
-          the type signature for foo :: EQ_ (Maybe m) (Maybe n)\r
-          at Simple14.hs:16:15\r
-    Expected type: EQ_ z0 z0\r
-      Actual type: EQ_ m n\r
-    Relevant bindings include\r
-      foo :: EQ_ (Maybe m) (Maybe n) (bound at Simple14.hs:17:1)\r
-    In the second argument of ‘eqE’, namely ‘(eqI :: EQ_ m n)’\r
-    In the first argument of ‘ntI’, namely ‘(`eqE` (eqI :: EQ_ m n))’\r
-    In the expression: ntI (`eqE` (eqI :: EQ_ m n))\r
+
+Simple14.hs:17:19:
+    Couldn't match type ‘z0’ with ‘m’
+      ‘z0’ is untouchable
+        inside the constraints (Maybe m ~ Maybe n)
+        bound by a type expected by the context:
+                   (Maybe m ~ Maybe n) => EQ_ z0 z0
+        at Simple14.hs:17:12-33
+      ‘m’ is a rigid type variable bound by
+          the type signature for foo :: EQ_ (Maybe m) (Maybe n)
+          at Simple14.hs:16:15
+    Expected type: EQ_ z0 z0
+      Actual type: EQ_ m n
+    Relevant bindings include
+      foo :: EQ_ (Maybe m) (Maybe n) (bound at Simple14.hs:17:1)
+    In the second argument of ‘eqE’, namely ‘(eqI :: EQ_ m n)’
+    In the first argument of ‘ntI’, namely ‘(`eqE` (eqI :: EQ_ m n))’
+    In the expression: ntI (`eqE` (eqI :: EQ_ m n))
index 8ce4d38..3e34058 100644 (file)
@@ -3,7 +3,7 @@ ExtraTcsUntch.hs:24:53:
     Could not deduce (C [t] [a]) arising from a use of ‘op’
     from the context (F Int ~ [[t]])
       bound by the inferred type of
-               f :: F Int ~ [[t]] => [t] -> ((), ((), ()))
+               f :: (F Int ~ [[t]]) => [t] -> ((), ((), ()))
       at ExtraTcsUntch.hs:(21,1)-(25,29)
     In the expression: op x [y]
     In the expression: (h [[undefined]], op x [y])
index c54ba16..133eccf 100644 (file)
@@ -1,6 +1,6 @@
 
 SimpleFail15.hs:5:8:
-    Illegal polymorphic or qualified type: a ~ b => t
+    Illegal polymorphic or qualified type: (a ~ b) => t
     Perhaps you intended to use RankNTypes or Rank2Types
     In the type signature for ‘foo’:
       foo :: (a, b) -> (a ~ b => t) -> (a, b)
index 4a223ae..a5e5227 100644 (file)
@@ -16,8 +16,8 @@ T2239.hs:47:13:
 
 T2239.hs:50:13:
     Couldn't match type ‘Bool -> Bool’
-                  with ‘forall b1. b1 ~ Bool => b1 -> b1’
-    Expected type: (forall b1. b1 ~ Bool => b1 -> b1) -> b -> b
+                  with ‘forall b1. (b1 ~ Bool) => b1 -> b1’
+    Expected type: (forall b1. (b1 ~ Bool) => b1 -> b1) -> b -> b
       Actual type: (b -> b) -> b -> b
     In the expression:
         id ::
index e8b7749..90b8a59 100644 (file)
@@ -2,10 +2,10 @@
 T4093a.hs:8:8:
     Could not deduce (e ~ ())
     from the context (Foo e ~ Maybe e)
-      bound by the type signature for hang :: Foo e ~ Maybe e => Foo e
+      bound by the type signature for hang :: (Foo e ~ Maybe e) => Foo e
       at T4093a.hs:7:9-34
       ‘e’ is a rigid type variable bound by
-          the type signature for hang :: Foo e ~ Maybe e => Foo e
+          the type signature for hang :: (Foo e ~ Maybe e) => Foo e
           at T4093a.hs:7:9
     Expected type: Foo e
       Actual type: Maybe ()
index 5cee13d..56d8ec9 100644 (file)
@@ -157,5 +157,5 @@ T5837.hs:8:6:
                                                                                                                                                        (TF
                                                                                                                                                           (TF
                                                                                                                                                              a)))))))))))))))))))))))))))))))))))))))))))))))))
-    In the ambiguity check for: forall a. a ~ TF (a, Int) => Int
+    In the ambiguity check for: forall a. (a ~ TF (a, Int)) => Int
     In the type signature for ‘t’: t :: (a ~ TF (a, Int)) => Int
index 0c34249..9ec952a 100644 (file)
@@ -3,7 +3,8 @@ T7230.hs:48:32:
     Could not deduce ((x :<<= x1) ~ 'True)
     from the context (Increasing xs ~ 'True)
       bound by the type signature for
-                 crash :: Increasing xs ~ 'True => SList xs -> SBool (Increasing xs)
+                 crash :: (Increasing xs ~ 'True) =>
+                          SList xs -> SBool (Increasing xs)
       at T7230.hs:47:10-68
     or from (xs ~ (x : xs1))
       bound by a pattern with constructor
index 18c294c..5814d4d 100644 (file)
@@ -14,7 +14,7 @@ TYPE CONSTRUCTORS
   type Syn2 a = [a]
 COERCION AXIOMS
   axiom Roles3.NTCo:C1 :: C1 a = a -> a
-  axiom Roles3.NTCo:C2 :: C2 a b = a ~ b => a -> b
+  axiom Roles3.NTCo:C2 :: C2 a b = (a ~ b) => a -> b
   axiom Roles3.NTCo:C3 :: C3 a b = a -> F3 b -> F3 b
   axiom Roles3.NTCo:C4 :: C4 a b = a -> F4 b -> F4 b
 Dependent modules: []
index e99e4c4..746cf15 100644 (file)
@@ -5,5 +5,5 @@ ContextStack2.hs:8:6:
       (TF (TF (TF (TF (TF (TF (TF (TF (TF (TF (TF a)))))))))),
        TF (TF (TF (TF (TF (TF (TF (TF (TF (TF (TF Int)))))))))))
       ~ TF (TF (TF (TF (TF (TF (TF (TF (TF (TF a)))))))))
-    In the ambiguity check for: forall a. a ~ TF (a, Int) => Int
+    In the ambiguity check for: forall a. (a ~ TF (a, Int)) => Int
     In the type signature for ‘t’: t :: (a ~ TF (a, Int)) => Int
index 848920c..80ab8d8 100644 (file)
@@ -1,53 +1,53 @@
-\r
-FrozenErrorTests.hs:12:12:\r
-    Couldn't match type ‘Int’ with ‘Bool’\r
-    Inaccessible code in\r
-      a pattern with constructor\r
-        MkT3 :: forall a. a ~ Bool => T a,\r
-      in a case alternative\r
-    In the pattern: MkT3\r
-    In a case alternative: MkT3 -> ()\r
-    In the expression: case x of { MkT3 -> () }\r
-\r
-FrozenErrorTests.hs:26:9:\r
-    Occurs check: cannot construct the infinite type: a ~ [a]\r
-    Expected type: [a]\r
-      Actual type: F a Bool\r
-    Relevant bindings include\r
-      test1 :: a (bound at FrozenErrorTests.hs:26:1)\r
-    In the expression: goo1 False undefined\r
-    In an equation for ‘test1’: test1 = goo1 False undefined\r
-\r
-FrozenErrorTests.hs:29:15:\r
-    Couldn't match type ‘Int’ with ‘[Int]’\r
-    Expected type: [[Int]]\r
-      Actual type: F [Int] Bool\r
-    In the first argument of ‘goo2’, namely ‘(goo1 False undefined)’\r
-    In the expression: goo2 (goo1 False undefined)\r
-    In an equation for ‘test2’: test2 = goo2 (goo1 False undefined)\r
-\r
-FrozenErrorTests.hs:30:9:\r
-    Couldn't match type ‘[Int]’ with ‘Int’\r
-    Expected type: [[Int]]\r
-      Actual type: F [Int] Bool\r
-    In the expression: goo1 False (goo2 undefined)\r
-    In an equation for ‘test3’: test3 = goo1 False (goo2 undefined)\r
-\r
-FrozenErrorTests.hs:45:15:\r
-    Couldn't match type ‘T2 c c’ with ‘M (T2 (T2 c c) c)’\r
-    Expected type: T2 (M (T2 (T2 c c) c)) (T2 (T2 c c) c)\r
-      Actual type: F (T2 (T2 c c) c) Bool\r
-    Relevant bindings include\r
-      test4 :: T2 (T2 c c) c (bound at FrozenErrorTests.hs:45:1)\r
-    In the first argument of ‘goo4’, namely ‘(goo3 False undefined)’\r
-    In the expression: goo4 (goo3 False undefined)\r
-    In an equation for ‘test4’: test4 = goo4 (goo3 False undefined)\r
-\r
-FrozenErrorTests.hs:46:9:\r
-    Couldn't match type ‘T2 c c’ with ‘M (T2 (T2 c c) c)’\r
-    Expected type: T2 (M (T2 (T2 c c) c)) (T2 (T2 c c) c)\r
-      Actual type: F (T2 (T2 c c) c) Bool\r
-    Relevant bindings include\r
-      test5 :: T2 (T2 c c) c (bound at FrozenErrorTests.hs:46:1)\r
-    In the expression: goo3 False (goo4 undefined)\r
-    In an equation for ‘test5’: test5 = goo3 False (goo4 undefined)\r
+
+FrozenErrorTests.hs:12:12:
+    Couldn't match type ‘Int’ with ‘Bool’
+    Inaccessible code in
+      a pattern with constructor
+        MkT3 :: forall a. (a ~ Bool) => T a,
+      in a case alternative
+    In the pattern: MkT3
+    In a case alternative: MkT3 -> ()
+    In the expression: case x of { MkT3 -> () }
+
+FrozenErrorTests.hs:26:9:
+    Occurs check: cannot construct the infinite type: a ~ [a]
+    Expected type: [a]
+      Actual type: F a Bool
+    Relevant bindings include
+      test1 :: a (bound at FrozenErrorTests.hs:26:1)
+    In the expression: goo1 False undefined
+    In an equation for ‘test1’: test1 = goo1 False undefined
+
+FrozenErrorTests.hs:29:15:
+    Couldn't match type ‘Int’ with ‘[Int]’
+    Expected type: [[Int]]
+      Actual type: F [Int] Bool
+    In the first argument of ‘goo2’, namely ‘(goo1 False undefined)’
+    In the expression: goo2 (goo1 False undefined)
+    In an equation for ‘test2’: test2 = goo2 (goo1 False undefined)
+
+FrozenErrorTests.hs:30:9:
+    Couldn't match type ‘[Int]’ with ‘Int’
+    Expected type: [[Int]]
+      Actual type: F [Int] Bool
+    In the expression: goo1 False (goo2 undefined)
+    In an equation for ‘test3’: test3 = goo1 False (goo2 undefined)
+
+FrozenErrorTests.hs:45:15:
+    Couldn't match type ‘T2 c c’ with ‘M (T2 (T2 c c) c)’
+    Expected type: T2 (M (T2 (T2 c c) c)) (T2 (T2 c c) c)
+      Actual type: F (T2 (T2 c c) c) Bool
+    Relevant bindings include
+      test4 :: T2 (T2 c c) c (bound at FrozenErrorTests.hs:45:1)
+    In the first argument of ‘goo4’, namely ‘(goo3 False undefined)’
+    In the expression: goo4 (goo3 False undefined)
+    In an equation for ‘test4’: test4 = goo4 (goo3 False undefined)
+
+FrozenErrorTests.hs:46:9:
+    Couldn't match type ‘T2 c c’ with ‘M (T2 (T2 c c) c)’
+    Expected type: T2 (M (T2 (T2 c c) c)) (T2 (T2 c c) c)
+      Actual type: F (T2 (T2 c c) c) Bool
+    Relevant bindings include
+      test5 :: T2 (T2 c c) c (bound at FrozenErrorTests.hs:46:1)
+    In the expression: goo3 False (goo4 undefined)
+    In an equation for ‘test5’: test5 = goo3 False (goo4 undefined)
index 9cd1dee..1378bae 100644 (file)
@@ -4,7 +4,7 @@ T5858.hs:11:7:
       arising from a use of ‘infer’
     The type variables ‘t0’, ‘t1’ are ambiguous
     Note: there is a potential instance available:
-      instance t1 ~ String => InferOverloaded (t1, t1)
+      instance (t1 ~ String) => InferOverloaded (t1, t1)
         -- Defined at T5858.hs:8:10
     In the expression: infer ([], [])
     In an equation for ‘foo’: foo = infer ([], [])
index 3519b3f..6517b77 100644 (file)
@@ -8,7 +8,7 @@ T7857.hs:8:11:
     Note: there are several potential instances:
       instance [safe] (PrintfArg a, PrintfType r) => PrintfType (a -> r)
         -- Defined in ‘Text.Printf’
-      instance [safe] a ~ () => PrintfType (IO a)
+      instance [safe] (a ~ ()) => PrintfType (IO a)
         -- Defined in ‘Text.Printf’
       instance [safe] IsChar c => PrintfType [c]
         -- Defined in ‘Text.Printf’
index ed33600..9be12a5 100644 (file)
@@ -2,6 +2,6 @@
 T8392a.hs:6:8:
     Couldn't match type ‘Int’ with ‘Bool’
     Inaccessible code in
-      the type signature for foo :: Int ~ Bool => a -> a
-    In the ambiguity check for: forall a. Int ~ Bool => a -> a
+      the type signature for foo :: (Int ~ Bool) => a -> a
+    In the ambiguity check for: forall a. (Int ~ Bool) => a -> a
     In the type signature for ‘foo’: foo :: (Int ~ Bool) => a -> a