[project @ 2000-04-11 11:34:40 by simonmar]

update expected output

diff --git a/ghc/tests/typecheck/should_fail/tcfail032.stderr b/ghc/tests/typecheck/should_fail/tcfail032.stderr
index 0586efe..1ce9ae7 100644 (file)
--- a/ghc/tests/typecheck/should_fail/tcfail032.stderr
+++ b/ghc/tests/typecheck/should_fail/tcfail032.stderr
@@ -4,9 +4,10 @@ tcfail032.hs:14:
        Quantified type variable `a' escapes
        It is mentioned in the environment
        The following variables in the environment mention `a'
-           x :: a -> Int
-    In an expression with expected type:
-       forall a1. (Eq a1) => a1 -> Int
+         x :: a -> Int
+    Signature type:     forall a. (Eq a) => a -> Int
+    Type to generalise: a -> Int
+    When checking an expression type signature
     In an expression with a type signature:
          x :: forall a. (Eq a) => a -> Int
 

diff --git a/ghc/tests/typecheck/should_fail/tcfail065.stderr b/ghc/tests/typecheck/should_fail/tcfail065.stderr
index 41d80bd..d4518a3 100644 (file)
--- a/ghc/tests/typecheck/should_fail/tcfail065.stderr
+++ b/ghc/tests/typecheck/should_fail/tcfail065.stderr
@@ -2,10 +2,11 @@
 tcfail065.hs:28:
     Inferred type is less polymorphic than expected
        Quantified type variable `x' escapes
-       It unifies with `x1', which is mentioned in the environment
-       The following variables in the environment mention `x1'
-    When checking the type signature
-       setX :: forall x2. x2 -> X x1 -> X x1
+       It is reachable from the type variable(s) `x1'
+         which is free in the signature
+    Signature type:     forall x. x -> X x1 -> X x1
+    Type to generalise: x1 -> X x1 -> X x1
+    When checking the type signature for `setX'
     In the definition for method `setX'
 
 Compilation had errors

diff --git a/ghc/tests/typecheck/should_fail/tcfail068.stderr b/ghc/tests/typecheck/should_fail/tcfail068.stderr
index 3204432..caf7ad1 100644 (file)
--- a/ghc/tests/typecheck/should_fail/tcfail068.stderr
+++ b/ghc/tests/typecheck/should_fail/tcfail068.stderr
@@ -1,56 +1,65 @@
 
-tcfail068.hs:13:
+tcfail068.hs:12:
     Inferred type is less polymorphic than expected
        Quantified type variable `s' escapes
-       It unifies with `s1', which is mentioned in the environment
-       The following variables in the environment mention `s1'
-    In an expression with expected type: forall s2. ST s2 a
-    In the first argument of `runST', namely `(newArray ((1, 1), n) x)'
+       It is reachable from the type variable(s) `a'
+         which is free in the signature
+    Signature type:     forall s. ST s a
+    Type to generalise: ST s1 (STArray s1 (Int, Int) a1)
+    When checking an expression type signature
+    In the first argument of `runST', namely
+       `(newSTArray ((1, 1), n) x)'
     In the right-hand side of an equation for `itgen':
-       runST (newArray ((1, 1), n) x)
+       runST (newSTArray ((1, 1), n) x)
 
-tcfail068.hs:18:
+tcfail068.hs:17:
     Inferred type is less polymorphic than expected
        Quantified type variable `s' escapes
        It unifies with `s1', which is mentioned in the environment
        The following variables in the environment mention `s1'
-           arr :: IndTree s1 a
-    In an expression with expected type: forall s2. ST s2 a1
+         arr :: IndTree s1 a
+    Signature type:     forall s. ST s a1
+    Type to generalise: ST s1 (STArray s1 (Int, Int) a)
+    When checking an expression type signature
     In the first argument of `runST', namely
-       `((readArray arr i)
-         >>= (\ val -> (writeArray arr i (f val)) >> (return arr)))'
+       `((readSTArray arr i)
+         >>= (\ val -> (writeSTArray arr i (f val)) >> (return arr)))'
     In the right-hand side of an equation for `itiap':
-       runST ((readArray arr i)
-              >>= (\ val -> (writeArray arr i (f val)) >> (return arr)))
+       runST ((readSTArray arr i)
+              >>= (\ val -> (writeSTArray arr i (f val)) >> (return arr)))
 
-tcfail068.hs:24:
+tcfail068.hs:23:
     Inferred type is less polymorphic than expected
        Quantified type variable `s' escapes
        It unifies with `s1', which is mentioned in the environment
        The following variables in the environment mention `s1'
-           arr :: IndTree s1 a
-           itrapsnd :: Int -> Int -> ST s1 (MutableArray s1 (Int, Int) a)
-           itrap' :: Int -> Int -> ST s1 (MutableArray s1 (Int, Int) a)
-    In an expression with expected type: forall s2. ST s2 a1
+         itrap' :: Int -> Int -> ST s1 (STArray s1 (Int, Int) a)
+         itrapsnd :: Int -> Int -> ST s1 (STArray s1 (Int, Int) a)
+         arr :: IndTree s1 a
+    Signature type:     forall s. ST s a1
+    Type to generalise: ST s1 (STArray s1 (Int, Int) a)
+    When checking an expression type signature
     In the first argument of `runST', namely `(itrap' i k)'
     In the right-hand side of an equation for `itrap':
        runST (itrap' i k)
 
-tcfail068.hs:36:
+tcfail068.hs:35:
     Inferred type is less polymorphic than expected
        Quantified type variable `s' escapes
        It unifies with `s1', which is mentioned in the environment
        The following variables in the environment mention `s1'
-           arr :: IndTree s1 b
-           itrapstatesnd :: Int
-                            -> Int
-                            -> c
-                            -> ST s1 (c, MutableArray s1 (Int, Int) b)
-           itrapstate' :: Int
+         itrapstate' :: Int
+                        -> Int
+                        -> c
+                        -> ST s1 (c, STArray s1 (Int, Int) b)
+         itrapstatesnd :: Int
                           -> Int
                           -> c
-                          -> ST s1 (c, MutableArray s1 (Int, Int) b)
-    In an expression with expected type: forall s2. ST s2 a
+                          -> ST s1 (c, STArray s1 (Int, Int) b)
+         arr :: IndTree s1 b
+    Signature type:     forall s. ST s a
+    Type to generalise: ST s1 (c, IndTree s1 b)
+    When checking an expression type signature
     In the first argument of `runST', namely `(itrapstate' i k s)'
     In the right-hand side of an equation for `itrapstate':
        runST (itrapstate' i k s)

diff --git a/ghc/tests/typecheck/should_fail/tcfail076.stderr b/ghc/tests/typecheck/should_fail/tcfail076.stderr
index fa1ea95..d3bf9a7 100644 (file)
--- a/ghc/tests/typecheck/should_fail/tcfail076.stderr
+++ b/ghc/tests/typecheck/should_fail/tcfail076.stderr
@@ -4,9 +4,10 @@ tcfail076.hs:18:
        Quantified type variable `res' escapes
        It is mentioned in the environment
        The following variables in the environment mention `res'
-           cont :: a -> m res
-    In an expression with expected type:
-       forall res1. (a1 -> m1 res1) -> m1 res1
+         cont :: a -> m res
+    Signature type:     forall res. (a1 -> m1 res) -> m1 res
+    Type to generalise: (b -> m res) -> m res
+    When checking an expression type signature
     In the first argument of `KContT', namely `(\ cont' -> cont a)'
     In the right-hand side of a lambda abstraction:
        KContT (\ cont' -> cont a)