Accept output

9 files changed, 154 insertions, 136 deletions

diff --git a/testsuite/tests/ghc-regress/ghci.debugger/scripts/break001.stderr b/testsuite/tests/ghc-regress/ghci.debugger/scripts/break001.stderr
index 5740d9f65e..cb0cc93ac7 100644
--- a/testsuite/tests/ghc-regress/ghci.debugger/scripts/break001.stderr
+++ b/testsuite/tests/ghc-regress/ghci.debugger/scripts/break001.stderr
@@ -1,6 +1,7 @@
 
 <interactive>:1:1:
     Ambiguous type variable `t' in the constraint:
-      `Show t' arising from a use of `print' at <interactive>:1:1
+      (Show t) arising from a use of `print'
     Cannot resolve unknown runtime types: t
     Use :print or :force to determine these types
+    In a stmt of an interactive GHCi command: print it
diff --git a/testsuite/tests/ghc-regress/ghci.debugger/scripts/break003.stderr b/testsuite/tests/ghc-regress/ghci.debugger/scripts/break003.stderr
index d9be247b8d..f640cb0fab 100644
--- a/testsuite/tests/ghc-regress/ghci.debugger/scripts/break003.stderr
+++ b/testsuite/tests/ghc-regress/ghci.debugger/scripts/break003.stderr
@@ -1,6 +1,6 @@
 
 <interactive>:1:1:
     No instance for (Show (t -> a))
-      arising from a use of `print' at <interactive>:1:1
+      arising from a use of `print'
     Possible fix: add an instance declaration for (Show (t -> a))
     In a stmt of an interactive GHCi command: print it
diff --git a/testsuite/tests/ghc-regress/ghci.debugger/scripts/break006.stderr b/testsuite/tests/ghc-regress/ghci.debugger/scripts/break006.stderr
index 291d3614db..31c3f94f1b 100644
--- a/testsuite/tests/ghc-regress/ghci.debugger/scripts/break006.stderr
+++ b/testsuite/tests/ghc-regress/ghci.debugger/scripts/break006.stderr
@@ -1,12 +1,14 @@
 
 <interactive>:1:1:
     Ambiguous type variable `a' in the constraint:
-      `Show a' arising from a use of `print' at <interactive>:1:1-3
+      (Show a) arising from a use of `print'
     Cannot resolve unknown runtime types: a
     Use :print or :force to determine these types
+    In a stmt of an interactive GHCi command: print it
 
 <interactive>:1:1:
     Ambiguous type variable `a' in the constraint:
-      `Show a' arising from a use of `print' at <interactive>:1:1
+      (Show a) arising from a use of `print'
     Cannot resolve unknown runtime types: a
     Use :print or :force to determine these types
+    In a stmt of an interactive GHCi command: print it
diff --git a/testsuite/tests/ghc-regress/ghci.debugger/scripts/print019.stderr b/testsuite/tests/ghc-regress/ghci.debugger/scripts/print019.stderr
index 00c002df4b..ba28b78f34 100644
--- a/testsuite/tests/ghc-regress/ghci.debugger/scripts/print019.stderr
+++ b/testsuite/tests/ghc-regress/ghci.debugger/scripts/print019.stderr
@@ -1,6 +1,7 @@
 
 <interactive>:1:1:
     Ambiguous type variable `t1' in the constraint:
-      `Show t1' arising from a use of `print' at <interactive>:1:1-3
+      (Show t1) arising from a use of `print'
     Cannot resolve unknown runtime types: t1
     Use :print or :force to determine these types
+    In a stmt of an interactive GHCi command: print it
diff --git a/testsuite/tests/ghc-regress/ghci/scripts/ghci012.stdout b/testsuite/tests/ghc-regress/ghci/scripts/ghci012.stdout
index 3947b1be65..ed37e56ada 100644
--- a/testsuite/tests/ghc-regress/ghci/scripts/ghci012.stdout
+++ b/testsuite/tests/ghc-regress/ghci/scripts/ghci012.stdout
@@ -1,2 +1 @@
-($$$) :: [b -> b1] -> [b] -> [b1]
-  	-- Defined at <interactive>:1:8-10
+($$$) :: [a -> b] -> [a] -> [b] 	-- Defined at <interactive>:1:8-10
diff --git a/testsuite/tests/ghc-regress/ghci/scripts/ghci025.stdout b/testsuite/tests/ghc-regress/ghci/scripts/ghci025.stdout
index 1712263b61..3f548c7af6 100644
--- a/testsuite/tests/ghc-regress/ghci/scripts/ghci025.stdout
+++ b/testsuite/tests/ghc-regress/ghci/scripts/ghci025.stdout
@@ -1,111 +1,111 @@
--- test :browse! functionality

-:browse! *T

--- defined locally

-T.length :: T.Integer

-class N a

-class S a

-class C a b where

-  c1 :: N b => a -> b

-  c2 :: (N b, S b) => a -> b

-  c3 :: a1 -> b

-  c4 :: a1 -> b

-c1 :: (C a b, N b) => a -> b

-c2 :: (C a b, N b, S b) => a -> b

-c3 :: C a b => a1 -> b

-c4 :: C a b => a1 -> b

--- imported via Control.Monad

-class Monad m => MonadPlus m where

-  mzero :: m a

-  mplus :: m a -> m a -> m a

-mplus :: MonadPlus m => m a -> m a -> m a

-mzero :: MonadPlus m => m a

--- imported via Control.Monad, Prelude

-(>>) :: Monad m => m a -> m b -> m b

-(>>=) :: Monad m => m a -> (a -> m b) -> m b

-fail :: Monad m => GHC.Base.String -> m a

-return :: Monad m => a -> m a

--- imported via Control.Monad, Prelude, T

-class Monad m where

-  (>>=) :: m a -> (a -> m b) -> m b

-  (>>) :: m a -> m b -> m b

-  return :: a -> m a

-  fail :: GHC.Base.String -> m a

--- imported via Data.Maybe

-catMaybes :: [Maybe a] -> [a]

-fromJust :: Maybe a -> a

-fromMaybe :: a -> Maybe a -> a

-isJust :: Maybe a -> GHC.Bool.Bool

-isNothing :: Maybe a -> GHC.Bool.Bool

-listToMaybe :: [a] -> Maybe a

-mapMaybe :: (a -> Maybe b) -> [a] -> [b]

-maybe :: b -> (a -> b) -> Maybe a -> b

-maybeToList :: Maybe a -> [a]

--- imported via Data.Maybe, Prelude

-Just :: a -> Maybe a

-data Maybe a = Nothing | Just a

-Nothing :: Maybe a

--- imported via Prelude

-(+) :: GHC.Num.Num a => a -> a -> a

-(=<<) :: Monad m => (a -> m b) -> m a -> m b

-class Eq a where

-  (GHC.Classes.==) :: a -> a -> GHC.Bool.Bool

-  (GHC.Classes./=) :: a -> a -> GHC.Bool.Bool

--- imported via Prelude, T

-Prelude.length :: [a] -> GHC.Types.Int

--- imported via T

-data T.Integer

-  = integer-gmp:GHC.Integer.Type.S# GHC.Prim.Int#

-  | integer-gmp:GHC.Integer.Type.J# GHC.Prim.Int# GHC.Prim.ByteArray#

-T.length :: Data.ByteString.Internal.ByteString -> GHC.Types.Int

-:browse! T

--- defined locally

-T.length :: T.Integer

-class N a

-class S a

-class C a b where

-  c1 :: N b => a -> b

-  c2 :: (N b, S b) => a -> b

-  c3 :: a1 -> b

-  c4 :: a1 -> b

-c1 :: (C a b, N b) => a -> b

-c2 :: (C a b, N b, S b) => a -> b

-c3 :: C a b => a1 -> b

-c4 :: C a b => a1 -> b

-:browse! T -- with -fglasgow-exts

--- defined locally

-T.length :: T.Integer

-class N a

-class S a

-class C a b where

-  c1 :: N b => a -> b

-  c2 :: (N b, S b) => a -> b

-  c3 :: forall a1. a1 -> b

-  c4 :: forall a1. a1 -> b

-c1 :: forall a b. (C a b, N b) => a -> b

-c2 :: forall a b. (C a b, N b, S b) => a -> b

-c3 :: forall a b. C a b => forall a1. a1 -> b

-c4 :: forall a b. C a b => forall a1. a1 -> b

--- test :browse! <target> relative to different contexts

-:browse! C -- from *C>

--- defined locally

-g :: forall a. Num a => a -> a

-h :: forall a. Integral a => a -> a

--- imported via D

-f :: forall a. Num a => a -> a

-:browse! C -- from *B>, after :add B

--- imported via C

-g :: forall a. Num a => a -> a

-h :: forall a. Integral a => a -> a

-f :: forall a. Num a => a -> a

-:browse! C -- from *C>, after :m *C

--- defined locally

-g :: forall a. Num a => a -> a

-h :: forall a. Integral a => a -> a

--- imported via D

-f :: forall a. Num a => a -> a

-:browse! C -- from *D>, after :m *D

--- not currently imported

-C.g :: forall a. Num a => a -> a

-C.h :: forall a. Integral a => a -> a

--- defined locally

-f :: forall a. Num a => a -> a

+-- test :browse! functionality
+:browse! *T
+-- defined locally
+T.length :: T.Integer
+class N a
+class S a
+class C a b where
+  c1 :: N b => a -> b
+  c2 :: (N b, S b) => a -> b
+  c3 :: a1 -> b
+  c4 :: a1 -> b
+c1 :: (C a b, N b) => a -> b
+c2 :: (C a b, N b, S b) => a -> b
+c3 :: C a b => forall a1. a1 -> b
+c4 :: C a b => forall a1. a1 -> b
+-- imported via Control.Monad
+class Monad m => MonadPlus m where
+  mzero :: m a
+  mplus :: m a -> m a -> m a
+mplus :: MonadPlus m => forall a. m a -> m a -> m a
+mzero :: MonadPlus m => forall a. m a
+-- imported via Control.Monad, Prelude
+(>>) :: Monad m => forall a b. m a -> m b -> m b
+(>>=) :: Monad m => forall a b. m a -> (a -> m b) -> m b
+fail :: Monad m => forall a. GHC.Base.String -> m a
+return :: Monad m => forall a. a -> m a
+-- imported via Control.Monad, Prelude, T
+class Monad m where
+  (>>=) :: m a -> (a -> m b) -> m b
+  (>>) :: m a -> m b -> m b
+  return :: a -> m a
+  fail :: GHC.Base.String -> m a
+-- imported via Data.Maybe
+catMaybes :: [Maybe a] -> [a]
+fromJust :: Maybe a -> a
+fromMaybe :: a -> Maybe a -> a
+isJust :: Maybe a -> GHC.Bool.Bool
+isNothing :: Maybe a -> GHC.Bool.Bool
+listToMaybe :: [a] -> Maybe a
+mapMaybe :: (a -> Maybe b) -> [a] -> [b]
+maybe :: b -> (a -> b) -> Maybe a -> b
+maybeToList :: Maybe a -> [a]
+-- imported via Data.Maybe, Prelude
+Just :: a -> Maybe a
+data Maybe a = Nothing | Just a
+Nothing :: Maybe a
+-- imported via Prelude
+(+) :: GHC.Num.Num a => a -> a -> a
+(=<<) :: Monad m => (a -> m b) -> m a -> m b
+class Eq a where
+  (GHC.Classes.==) :: a -> a -> GHC.Bool.Bool
+  (GHC.Classes./=) :: a -> a -> GHC.Bool.Bool
+-- imported via Prelude, T
+Prelude.length :: [a] -> GHC.Types.Int
+-- imported via T
+data T.Integer
+  = integer-gmp:GHC.Integer.Type.S# GHC.Prim.Int#
+  | integer-gmp:GHC.Integer.Type.J# GHC.Prim.Int# GHC.Prim.ByteArray#
+T.length :: Data.ByteString.Internal.ByteString -> GHC.Types.Int
+:browse! T
+-- defined locally
+T.length :: T.Integer
+class N a
+class S a
+class C a b where
+  c1 :: N b => a -> b
+  c2 :: (N b, S b) => a -> b
+  c3 :: a1 -> b
+  c4 :: a1 -> b
+c1 :: (C a b, N b) => a -> b
+c2 :: (C a b, N b, S b) => a -> b
+c3 :: C a b => forall a1. a1 -> b
+c4 :: C a b => forall a1. a1 -> b
+:browse! T -- with -fglasgow-exts
+-- defined locally
+T.length :: T.Integer
+class N a
+class S a
+class C a b where
+  c1 :: N b => a -> b
+  c2 :: (N b, S b) => a -> b
+  c3 :: forall a1. a1 -> b
+  c4 :: forall a1. a1 -> b
+c1 :: forall a b. (C a b, N b) => a -> b
+c2 :: forall a b. (C a b, N b, S b) => a -> b
+c3 :: forall a b. C a b => forall a1. a1 -> b
+c4 :: forall a b. C a b => forall a1. a1 -> b
+-- test :browse! <target> relative to different contexts
+:browse! C -- from *C>
+-- defined locally
+g :: forall a. Num a => a -> a
+h :: forall a. Integral a => a -> a
+-- imported via D
+f :: forall a. Num a => a -> a
+:browse! C -- from *B>, after :add B
+-- imported via C
+g :: forall a. Num a => a -> a
+h :: forall a. Integral a => a -> a
+f :: forall a. Num a => a -> a
+:browse! C -- from *C>, after :m *C
+-- defined locally
+g :: forall a. Num a => a -> a
+h :: forall a. Integral a => a -> a
+-- imported via D
+f :: forall a. Num a => a -> a
+:browse! C -- from *D>, after :m *D
+-- not currently imported
+C.g :: forall a. Num a => a -> a
+C.h :: forall a. Integral a => a -> a
+-- defined locally
+f :: forall a. Num a => a -> a
diff --git a/testsuite/tests/ghc-regress/simplCore/should_compile/T3772.stdout b/testsuite/tests/ghc-regress/simplCore/should_compile/T3772.stdout
index ec25298de3..2783cb90c2 100644
--- a/testsuite/tests/ghc-regress/simplCore/should_compile/T3772.stdout
+++ b/testsuite/tests/ghc-regress/simplCore/should_compile/T3772.stdout
@@ -1,25 +1,43 @@
 
 ==================== Tidy Core ====================
 Rec {
-xs :: GHC.Prim.Int# -> ()
+T3772.foo_xs [Occ=LoopBreaker] :: GHC.Prim.Int# -> ()
 [GblId, Arity=1, Caf=NoCafRefs, Str=DmdType L]
-xs =
+T3772.foo_xs =
   \ (m :: GHC.Prim.Int#) ->
     case GHC.Prim.<=# m 1 of _ {
-      GHC.Bool.False -> xs (GHC.Prim.-# m 1);
+      GHC.Bool.False -> T3772.foo_xs (GHC.Prim.-# m 1);
       GHC.Bool.True -> GHC.Unit.()
     }
 end Rec }
 
-T3772.foo [InlPrag=NOINLINE (sat-args=1)] :: GHC.Types.Int -> ()
-[GblId, Arity=1, Caf=NoCafRefs, Str=DmdType U(L)]
-T3772.foo =
-  \ (n :: GHC.Types.Int) ->
-    case n of _ { GHC.Types.I# n# ->
-    case GHC.Prim.<=# n# 0 of _ {
-      GHC.Bool.False -> xs n#; GHC.Bool.True -> GHC.Unit.()
-    }
+T3772.$wfoo :: GHC.Prim.Int# -> ()
+[GblId,
+ Arity=1,
+ Caf=NoCafRefs,
+ Str=DmdType L,
+ Unf=Unf{Src=<vanilla>, TopLvl=True, Arity=1, Value=True,
+         ConLike=True, Cheap=True, Expandable=True,
+         Guidance=IF_ARGS [0] 5 1}]
+T3772.$wfoo =
+  \ (ww :: GHC.Prim.Int#) ->
+    case GHC.Prim.<=# ww 0 of _ {
+      GHC.Bool.False -> T3772.foo_xs ww; GHC.Bool.True -> GHC.Unit.()
     }
 
+T3772.foo [InlPrag=INLINE[0]] :: GHC.Types.Int -> ()
+[GblId,
+ Arity=1,
+ Caf=NoCafRefs,
+ Str=DmdType U(L),
+ Unf=Unf{Src=Worker=T3772.$wfoo, TopLvl=True, Arity=1, Value=True,
+         ConLike=True, Cheap=True, Expandable=True,
+         Guidance=ALWAYS_IF(unsat_ok=True,boring_ok=False)
+         Tmpl= \ (w [Occ=Once!] :: GHC.Types.Int) ->
+                 case w of _ { GHC.Types.I# ww [Occ=Once] -> T3772.$wfoo ww }}]
+T3772.foo =
+  \ (w :: GHC.Types.Int) ->
+    case w of _ { GHC.Types.I# ww -> T3772.$wfoo ww }
+
 
 
diff --git a/testsuite/tests/ghc-regress/simplCore/should_compile/rule2.stderr b/testsuite/tests/ghc-regress/simplCore/should_compile/rule2.stderr
index 6853bcc339..50b7a32467 100644
--- a/testsuite/tests/ghc-regress/simplCore/should_compile/rule2.stderr
+++ b/testsuite/tests/ghc-regress/simplCore/should_compile/rule2.stderr
@@ -23,10 +23,10 @@ Total ticks:     11
     1 f
     1 m
     1 a
+    1 b
     1 m
-    1 a
-    1 a
     1 m
+    1 a
 8 SimplifierDone
     8
 
diff --git a/testsuite/tests/ghc-regress/th/T3899.stderr b/testsuite/tests/ghc-regress/th/T3899.stderr
index e0d643f42c..2b4a76a4e5 100644
--- a/testsuite/tests/ghc-regress/th/T3899.stderr
+++ b/testsuite/tests/ghc-regress/th/T3899.stderr
@@ -1,5 +1,2 @@
-T3899.hs:6:7:
-    T3899.hs:6:7-19: Splicing expression
-        nestedTuple 3 ======> \ (Cons x (Cons x (Cons x Nil))) -> (x, x, x)
-    In the expression: $(nestedTuple 3)
-    In an equation for `f': f = $(nestedTuple 3)
+T3899.hs:6:7-19: Splicing expression
+    nestedTuple 3 ======> \ (Cons x (Cons x (Cons x Nil))) -> (x, x, x)