Narrow scope of special-case for unqualified printing of names in core libraries

Commit 547c597112954353cef7157cb0a389bc4f6303eb modifies the
pretty-printer to render names from a set of core packages (`base`,
`ghc-prim`, `template-haskell`) as unqualified. The idea here was that
many of these names typically are not in scope but are well-known by the
user and therefore qualification merely introduces noise.

This, however, is a very large hammer and potentially breaks any
consumer who relies on parsing GHC output (hence #11208). This commit
partially reverts this change, now only printing `Constraint` (which
appears quite often in errors) as unqualified.

Fixes #11208.

Updates tests in `array` submodule.

Test Plan: validate

Reviewers: hvr, thomie, austin

Subscribers: thomie

Differential Revision: https://phabricator.haskell.org/D1619

GHC Trac Issues: #11208

1 files changed, 63 insertions, 63 deletions

diff --git a/testsuite/tests/rebindable/rebindable6.stderr b/testsuite/tests/rebindable/rebindable6.stderr
index 2f1331db86..0497c9fc61 100644
--- a/testsuite/tests/rebindable/rebindable6.stderr
+++ b/testsuite/tests/rebindable/rebindable6.stderr
@@ -1,69 +1,69 @@
 
 rebindable6.hs:109:17: error:
-    Ambiguous type variable ‘t0’ arising from a do statement
-    prevents the constraint ‘(HasSeq
-                                (IO a -> t0 -> IO b))’ from being solved.
-      (maybe you haven't applied a function to enough arguments?)
-    Relevant bindings include
-      g :: IO (Maybe b) (bound at rebindable6.hs:107:19)
-      f :: IO a (bound at rebindable6.hs:107:17)
-      test_do :: IO a -> IO (Maybe b) -> IO b
-        (bound at rebindable6.hs:107:9)
-    Probable fix: use a type annotation to specify what ‘t0’ should be.
-    These potential instance exist:
-      instance HasSeq (IO a -> IO b -> IO b)
-        -- Defined at rebindable6.hs:55:18
-    In a stmt of a 'do' block: f
-    In the expression:
-      do { f;
-           Just (b :: b) <- g;
-           return b }
-    In an equation for ‘test_do’:
-        test_do f g
-          = do { f;
-                 Just (b :: b) <- g;
-                 return b }
+    • Ambiguous type variable ‘t0’ arising from a do statement
+      prevents the constraint ‘(HasSeq
+                                  (IO a -> t0 -> IO b))’ from being solved.
+        (maybe you haven't applied a function to enough arguments?)
+      Relevant bindings include
+        g :: IO (Maybe b) (bound at rebindable6.hs:107:19)
+        f :: IO a (bound at rebindable6.hs:107:17)
+        test_do :: IO a -> IO (Maybe b) -> IO b
+          (bound at rebindable6.hs:107:9)
+      Probable fix: use a type annotation to specify what ‘t0’ should be.
+      These potential instance exist:
+        instance HasSeq (IO a -> IO b -> IO b)
+          -- Defined at rebindable6.hs:55:18
+    • In a stmt of a 'do' block: f
+      In the expression:
+        do { f;
+             Just (b :: b) <- g;
+             return b }
+      In an equation for ‘test_do’:
+          test_do f g
+            = do { f;
+                   Just (b :: b) <- g;
+                   return b }
 
 rebindable6.hs:110:17: error:
-    Ambiguous type variable ‘t1’ arising from a do statement
-                                 with the failable pattern ‘Just (b :: b)’
-    prevents the constraint ‘(HasFail
-                                ([Char] -> t1))’ from being solved.
-      (maybe you haven't applied a function to enough arguments?)
-    Probable fix: use a type annotation to specify what ‘t1’ should be.
-    These potential instance exist:
-      instance HasFail (String -> IO a)
-        -- Defined at rebindable6.hs:60:18
-    In a stmt of a 'do' block: Just (b :: b) <- g
-    In the expression:
-      do { f;
-           Just (b :: b) <- g;
-           return b }
-    In an equation for ‘test_do’:
-        test_do f g
-          = do { f;
-                 Just (b :: b) <- g;
-                 return b }
+    • Ambiguous type variable ‘t1’ arising from a do statement
+                                   with the failable pattern ‘Just (b :: b)’
+      prevents the constraint ‘(HasFail
+                                  ([Prelude.Char] -> t1))’ from being solved.
+        (maybe you haven't applied a function to enough arguments?)
+      Probable fix: use a type annotation to specify what ‘t1’ should be.
+      These potential instance exist:
+        instance HasFail (String -> IO a)
+          -- Defined at rebindable6.hs:60:18
+    • In a stmt of a 'do' block: Just (b :: b) <- g
+      In the expression:
+        do { f;
+             Just (b :: b) <- g;
+             return b }
+      In an equation for ‘test_do’:
+          test_do f g
+            = do { f;
+                   Just (b :: b) <- g;
+                   return b }
 
 rebindable6.hs:111:17: error:
-    Ambiguous type variable ‘t1’ arising from a use of ‘return’
-    prevents the constraint ‘(HasReturn (b -> t1))’ from being solved.
-      (maybe you haven't applied a function to enough arguments?)
-    Relevant bindings include
-      b :: b (bound at rebindable6.hs:110:23)
-      g :: IO (Maybe b) (bound at rebindable6.hs:107:19)
-      test_do :: IO a -> IO (Maybe b) -> IO b
-        (bound at rebindable6.hs:107:9)
-    Probable fix: use a type annotation to specify what ‘t1’ should be.
-    These potential instance exist:
-      instance HasReturn (a -> IO a) -- Defined at rebindable6.hs:45:18
-    In a stmt of a 'do' block: return b
-    In the expression:
-      do { f;
-           Just (b :: b) <- g;
-           return b }
-    In an equation for ‘test_do’:
-        test_do f g
-          = do { f;
-                 Just (b :: b) <- g;
-                 return b }
+    • Ambiguous type variable ‘t1’ arising from a use of ‘return’
+      prevents the constraint ‘(HasReturn (b -> t1))’ from being solved.
+        (maybe you haven't applied a function to enough arguments?)
+      Relevant bindings include
+        b :: b (bound at rebindable6.hs:110:23)
+        g :: IO (Maybe b) (bound at rebindable6.hs:107:19)
+        test_do :: IO a -> IO (Maybe b) -> IO b
+          (bound at rebindable6.hs:107:9)
+      Probable fix: use a type annotation to specify what ‘t1’ should be.
+      These potential instance exist:
+        instance HasReturn (a -> IO a) -- Defined at rebindable6.hs:45:18
+    • In a stmt of a 'do' block: return b
+      In the expression:
+        do { f;
+             Just (b :: b) <- g;
+             return b }
+      In an equation for ‘test_do’:
+          test_do f g
+            = do { f;
+                   Just (b :: b) <- g;
+                   return b }