Add built-in syntax suggestions, and refactor to allow library use
[ghc.git] / testsuite / tests / typecheck / should_compile / valid_hole_fits.stderr
1 [1 of 2] Compiling ValidHoleFits    ( ValidHoleFits.hs, ValidHoleFits.o )
2 [2 of 2] Compiling Foo              ( valid_hole_fits.hs, valid_hole_fits.o )
3
4 valid_hole_fits.hs:9:6: warning: [-Wdeferred-out-of-scope-variables (in -Wdefault)]
5     • Variable not in scope: putStrLn :: String -> IO ()
6     • Perhaps you meant one of these:
7         ‘System.IO.putStrLn’ (imported from System.IO),
8         ‘System.IO.putStr’ (imported from System.IO)
9       Perhaps you want to remove ‘putStrLn’ from the explicit hiding list
10       in the import of ‘Prelude’ (valid_hole_fits.hs:3:1-40).
11
12 valid_hole_fits.hs:17:17: warning: [-Wtyped-holes (in -Wdefault)]
13     • Found hole: _ :: Int -> IO Int
14     • In the expression: _
15       In a stmt of a 'do' block: y <- _ x
16       In the expression:
17         do x <- a 0
18            y <- _ x
19            return y
20     • Relevant bindings include
21         x :: Int (bound at valid_hole_fits.hs:16:12)
22         c :: Int -> IO Int (bound at valid_hole_fits.hs:16:1)
23       Valid hole fits include
24         c :: Int -> IO Int (bound at valid_hole_fits.hs:16:1)
25         a :: Int -> IO Int (bound at valid_hole_fits.hs:12:1)
26         b :: Int -> IO Int (bound at valid_hole_fits.hs:14:1)
27         return :: forall (m :: * -> *) a. Monad m => a -> m a
28           with return @IO @Int
29           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
30            (and originally defined in ‘GHC.Base’))
31         pure :: forall (f :: * -> *) a. Applicative f => a -> f a
32           with pure @IO @Int
33           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
34            (and originally defined in ‘GHC.Base’))
35
36 valid_hole_fits.hs:21:8: warning: [-Wtyped-holes (in -Wdefault)]
37     • Found hole: _ :: [Maybe a] -> [a]
38       Where: ‘a’ is a rigid type variable bound by
39                the type signature for:
40                  test :: forall a. [Maybe a] -> [a]
41                at valid_hole_fits.hs:20:1-24
42     • In the expression: _
43       In an equation for ‘test’: test = _
44     • Relevant bindings include
45         test :: [Maybe a] -> [a] (bound at valid_hole_fits.hs:21:1)
46       Valid hole fits include
47         test :: [Maybe a] -> [a] (bound at valid_hole_fits.hs:21:1)
48         catMaybes :: forall a. [Maybe a] -> [a]
49           with catMaybes @a
50           (imported from ‘Data.Maybe’ at valid_hole_fits.hs:5:1-17)
51         mempty :: forall a. Monoid a => a
52           with mempty @([Maybe a] -> [a])
53           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
54            (and originally defined in ‘GHC.Base’))
55
56 valid_hole_fits.hs:24:9: warning: [-Wtyped-holes (in -Wdefault)]
57     • Found hole: _ :: Integer -> ValidHoleFits.Moo
58     • In the expression: _
59       In an equation for ‘test2’: test2 = _
60     • Relevant bindings include
61         test2 :: Integer -> ValidHoleFits.Moo
62           (bound at valid_hole_fits.hs:24:1)
63       Valid hole fits include
64         test2 :: Integer -> ValidHoleFits.Moo
65           (bound at valid_hole_fits.hs:24:1)
66         ValidHoleFits.Moo :: Integer -> ValidHoleFits.Moo
67           (imported qualified from ‘ValidHoleFits’ at valid_hole_fits.hs:6:1-30
68            (and originally defined at ValidHoleFits.hs:4:12-22))
69
70 valid_hole_fits.hs:27:5: warning: [-Wtyped-holes (in -Wdefault)]
71     • Found hole: _ :: Integer -> Maybe Integer
72     • In the expression: _
73       In the expression: _ 2
74       In an equation for ‘k’: k = _ 2
75     • Relevant bindings include
76         k :: Maybe Integer (bound at valid_hole_fits.hs:27:1)
77       Valid hole fits include
78         Just :: forall a. a -> Maybe a
79           with Just @Integer
80           (imported from ‘Data.Maybe’ at valid_hole_fits.hs:5:1-17
81            (and originally defined in ‘GHC.Maybe’))
82         return :: forall (m :: * -> *) a. Monad m => a -> m a
83           with return @Maybe @Integer
84           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
85            (and originally defined in ‘GHC.Base’))
86         pure :: forall (f :: * -> *) a. Applicative f => a -> f a
87           with pure @Maybe @Integer
88           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
89            (and originally defined in ‘GHC.Base’))
90
91 valid_hole_fits.hs:30:10: warning: [-Wtyped-holes (in -Wdefault)]
92     • Found hole: _ :: a1
93       Where: ‘a1’ is an ambiguous type variable
94     • In the first argument of ‘show’, namely ‘_’
95       In the expression: show _
96       In an equation for ‘f’: f = show _
97     • Relevant bindings include
98         f :: String (bound at valid_hole_fits.hs:30:1)
99       Valid hole fits include
100         f :: String (bound at valid_hole_fits.hs:30:1)
101         k :: Maybe Integer (defined at valid_hole_fits.hs:27:1)
102         h :: String (bound at valid_hole_fits.hs:34:1)
103         otherwise :: Bool
104           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
105            (and originally defined in ‘GHC.Base’))
106         False :: Bool
107           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
108            (and originally defined in ‘GHC.Types’))
109         True :: Bool
110           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
111            (and originally defined in ‘GHC.Types’))
112         LT :: Ordering
113           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
114            (and originally defined in ‘GHC.Types’))
115         EQ :: Ordering
116           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
117            (and originally defined in ‘GHC.Types’))
118         GT :: Ordering
119           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
120            (and originally defined in ‘GHC.Types’))
121         () :: () (bound at <wired into compiler>)
122         pi :: forall a. Floating a => a
123           with pi @Double
124           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
125            (and originally defined in ‘GHC.Float’))
126
127 valid_hole_fits.hs:34:11: warning: [-Wtyped-holes (in -Wdefault)]
128     • Found hole: _ :: Bool -> a0
129       Where: ‘a0’ is an ambiguous type variable
130     • In the expression: _
131       In the first argument of ‘show’, namely ‘(_ (_ :: Bool))’
132       In the expression: show (_ (_ :: Bool))
133     • Relevant bindings include
134         h :: String (bound at valid_hole_fits.hs:34:1)
135       Valid hole fits include
136         not :: Bool -> Bool
137           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
138            (and originally defined in ‘GHC.Classes’))
139         enumFrom :: forall a. Enum a => a -> [a]
140           with enumFrom @Bool
141           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
142            (and originally defined in ‘GHC.Enum’))
143         Just :: forall a. a -> Maybe a
144           with Just @Bool
145           (imported from ‘Data.Maybe’ at valid_hole_fits.hs:5:1-17
146            (and originally defined in ‘GHC.Maybe’))
147         id :: forall a. a -> a
148           with id @Bool
149           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
150            (and originally defined in ‘GHC.Base’))
151         repeat :: forall a. a -> [a]
152           with repeat @Bool
153           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
154            (and originally defined in ‘GHC.List’))
155         fromEnum :: forall a. Enum a => a -> Int
156           with fromEnum @Bool
157           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
158            (and originally defined in ‘GHC.Enum’))
159         pred :: forall a. Enum a => a -> a
160           with pred @Bool
161           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
162            (and originally defined in ‘GHC.Enum’))
163         succ :: forall a. Enum a => a -> a
164           with succ @Bool
165           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
166            (and originally defined in ‘GHC.Enum’))
167         show :: forall a. Show a => a -> String
168           with show @Bool
169           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
170            (and originally defined in ‘GHC.Show’))
171
172 valid_hole_fits.hs:34:14: warning: [-Wtyped-holes (in -Wdefault)]
173     • Found hole: _ :: Bool
174     • In the first argument of ‘_’, namely ‘(_ :: Bool)’
175       In the first argument of ‘show’, namely ‘(_ (_ :: Bool))’
176       In the expression: show (_ (_ :: Bool))
177     • Relevant bindings include
178         h :: String (bound at valid_hole_fits.hs:34:1)
179       Valid hole fits include
180         otherwise :: Bool
181           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
182            (and originally defined in ‘GHC.Base’))
183         False :: Bool
184           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
185            (and originally defined in ‘GHC.Types’))
186         True :: Bool
187           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
188            (and originally defined in ‘GHC.Types’))
189         maxBound :: forall a. Bounded a => a
190           with maxBound @Bool
191           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
192            (and originally defined in ‘GHC.Enum’))
193         minBound :: forall a. Bounded a => a
194           with minBound @Bool
195           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
196            (and originally defined in ‘GHC.Enum’))
197
198 valid_hole_fits.hs:38:10: warning: [-Wtyped-holes (in -Wdefault)]
199     • Found hole: _ :: a -> [a] -> [a]
200       Where: ‘a’ is a rigid type variable bound by
201                the type signature for:
202                  myCons :: forall a. a -> [a] -> [a]
203                at valid_hole_fits.hs:37:1-25
204     • In the expression: _
205       In an equation for ‘myCons’: myCons = _
206     • Relevant bindings include
207         myCons :: a -> [a] -> [a] (bound at valid_hole_fits.hs:38:1)
208       Valid hole fits include
209         myCons :: a -> [a] -> [a] (bound at valid_hole_fits.hs:38:1)
210         (:) :: forall a. a -> [a] -> [a]
211           with (:) @a
212           (bound at <wired into compiler>)
213         (<$) :: forall (f :: * -> *) a b. Functor f => a -> f b -> f a
214           with (<$) @[] @a @a
215           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
216            (and originally defined in ‘GHC.Base’))
217         seq :: forall a b. a -> b -> b
218           with seq @a @[a]
219           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
220            (and originally defined in ‘GHC.Prim’))
221         mempty :: forall a. Monoid a => a
222           with mempty @(a -> [a] -> [a])
223           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
224            (and originally defined in ‘GHC.Base’))
225
226 valid_hole_fits.hs:41:8: warning: [-Wtyped-holes (in -Wdefault)]
227     • Found hole: _ :: [Char] -> IO ()
228     • In the expression: _
229       In the expression: _ "hello, world"
230       In an equation for ‘main’: main = _ "hello, world"
231     • Relevant bindings include
232         main :: IO () (bound at valid_hole_fits.hs:41:1)
233       Valid hole fits include
234         ps :: String -> IO () (defined at valid_hole_fits.hs:9:1)
235         System.IO.putStr :: String -> IO ()
236           (imported qualified from ‘System.IO’ at valid_hole_fits.hs:4:29-34)
237         System.IO.putStrLn :: String -> IO ()
238           (imported qualified from ‘System.IO’ at valid_hole_fits.hs:4:37-44)
239         readIO :: forall a. Read a => String -> IO a
240           with readIO @()
241           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
242            (and originally defined in ‘System.IO’))
243         print :: forall a. Show a => a -> IO ()
244           with print @[Char]
245           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
246            (and originally defined in ‘System.IO’))
247         fail :: forall (m :: * -> *) a. Monad m => String -> m a
248           with fail @IO @()
249           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
250            (and originally defined in ‘GHC.Base’))
251         mempty :: forall a. Monoid a => a
252           with mempty @([Char] -> IO ())
253           (imported from ‘Prelude’ at valid_hole_fits.hs:3:1-40
254            (and originally defined in ‘GHC.Base’))