Ticket #6104: after.txt

File after.txt, 22.6 KB (added by igloo, 2 years ago)
Line 
1Magic: Wanted 33214052,
2       got    33214052
3Version: Wanted [7, 0, 5, 2, 0, 1, 2, 0, 6, 2, 6],
4         got    [7, 0, 5, 2, 0, 1, 2, 0, 6, 2, 6]
5Way: Wanted [],
6     got    []
7interface main:CopyFile 70520120626
8  interface hash: ad6c586922e982f5872420f89c0388dd
9  ABI hash: 25d4cae43358fcfc56cccd91a771ed7b
10  export-list hash: 6279e8f29e93b2e3dfd07c27bd3ee955
11  orphan hash: 693e9af84d3dfcc71e640e005bdc5e2e
12  flag hash: b96ce2c6267ce466f0aa6b7dfb526036
13  used TH splices: False
14  where
15exports:
16  CopyFile.copyExecutableFile
17  CopyFile.copyOrdinaryFile
18  CopyFile.myCopyFile
19  CopyFile.setDirOrdinary
20  CopyFile.setFileExecutable
21  CopyFile.setFileOrdinary
22module dependencies:
23package dependencies: array-0.3.0.3 base deepseq-1.2.0.1
24                      directory-1.1.0.1 filepath-1.2.0.1 ghc-prim integer-gmp
25                      old-locale-1.0.0.4 time-1.4 unix-2.5.1.0
26orphans: base:GHC.Base base:GHC.Float
27         time-1.4:Data.Time.Calendar.Gregorian
28         time-1.4:Data.Time.Format.Parse
29         time-1.4:Data.Time.LocalTime.LocalTime
30family instance modules: base:Data.Either base:Data.Maybe
31                         ghc-prim:GHC.Generics ghc-prim:GHC.Tuple
32import  -/  base:Control.Exception 430abf92fd17d5a8cecf7ba647202542
33import  -/  base:Control.Exception.Base 133d68135135146ebd146affa1a71680
34import  -/  base:Control.Monad a483f9bbf1a0a4f27b0f8ebd7398002e
35import  -/  base:Foreign 9f24f6afc7fa466bdc7c74035c612f99
36import  -/  base:Foreign.C c86d3f98c1afd3324e4d18eb4a5444ee
37import  -/  base:Foreign.C.Error 0c5a465375f1a96e32e1e8cecd9ac8b7
38import  -/  base:Foreign.Marshal.Alloc aa6aa4ebc4d73043da5d29781b6e5e3e
39import  -/  base:GHC.Base 6f398d5d5451a02119dcc1ea281c2f9e
40import  -/  base:GHC.IO 3cad53abc28a0d337b5753d15111bc07
41import  -/  base:GHC.IO.Exception 4b6067e9ff58fe2ee3291b7390f4bee2
42import  -/  base:GHC.IO.Handle 87e03c954a4789b9bf319a88b6040865
43import  -/  base:GHC.IO.Handle.FD 7270aedf73e0245ce34ed2311a31805b
44import  -/  base:GHC.IO.Handle.Text f444c3d3d37650e0a4b11d491a484f35
45import  -/  base:GHC.IO.IOMode f807c491b1b4a3e126820693acc286e4
46import  -/  base:Prelude af70535b08c06326e6e2b6c61f387cce
47import  -/  base:System.IO bf22fd9277da44317481d51d40be749d
48import  -/  base:System.IO.Error 182a69b1c28a328a0e4c1ab16fead6af
49import  -/  base:System.Posix.Internals 5626ffebe506e17b34be62e00a6611e3
50import  -/  base:System.Posix.Types 9b6d72def20ab2ba1c106d8423a4a095
51import  -/  directory-1.1.0.1:System.Directory f489415264fa99ddcd9b974fab266f2b
52import  -/  filepath-1.2.0.1:System.FilePath 8353cce0176f435a5bb9e79437dd555d
53import  -/  filepath-1.2.0.1:System.FilePath.Posix 8526c8179c1d6fc8b56ed6a8d9052566
54import  -/  ghc-prim:GHC.Classes 128f8128c5a876811f90d77f23b234fa
55import  -/  ghc-prim:GHC.Types 73e05a52c41842d3f15b7eead9f6cd80
563b474bf8ca378bee751c5836d4017179
57  $wa :: GHC.IO.FilePath
58         -> GHC.IO.Handle.Types.Handle
59         -> GHC.Prim.State# GHC.Prim.RealWorld
60         -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
61    {- Arity: 3, Strictness: LLL,
62       Unfolding: (\ ww :: GHC.IO.FilePath
63                     ww1 :: GHC.IO.Handle.Types.Handle
64                     w :: GHC.Prim.State# GHC.Prim.RealWorld ->
65                   case GHC.Prim.catch#
66                          @ ()
67                          @ GHC.Exception.SomeException
68                          (GHC.IO.Handle.hClose1 ww1)
69                          CopyFile.copyExecutableFile11
70                          w of wild { (#,#) new_s a ->
71                   GHC.Prim.catch#
72                     @ ()
73                     @ GHC.Exception.SomeException
74                     (System.Posix.Files.removeLink1 ww)
75                     CopyFile.copyExecutableFile10
76                     new_s }) -}
77e0183f8e863c9b6887370dc4c5f04b56
78  copyExecutableFile :: GHC.IO.FilePath
79                        -> GHC.IO.FilePath
80                        -> GHC.Types.IO ()
81    {- Arity: 3, Strictness: LLL,
82       Unfolding: (CopyFile.copyExecutableFile1
83                     `cast`
84                   ((->)
85                        (Refl GHC.IO.FilePath)
86                        ((->)
87                             (Refl GHC.IO.FilePath) (Sym (GHC.Types.NTCo:IO (Refl ())))))) -}
8823223548189ddb186a688d8d440edc7d
89  copyExecutableFile1 :: GHC.IO.FilePath
90                         -> GHC.IO.FilePath
91                         -> GHC.Prim.State# GHC.Prim.RealWorld
92                         -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
93    {- Arity: 3, Strictness: LLL,
94       Unfolding: (\ src :: GHC.IO.FilePath
95                     dest :: GHC.IO.FilePath
96                     eta :: GHC.Prim.State# GHC.Prim.RealWorld ->
97                   case CopyFile.copyExecutableFile5
98                          src
99                          dest
100                          eta of wild { (#,#) new_s a ->
101                   CopyFile.copyExecutableFile3
102                     dest
103                     CopyFile.copyExecutableFile2
104                       `cast`
105                     (Sym (System.Posix.Types.NTCo:CMode))
106                     new_s }) -}
107229f1267543151e15e3115e809c6f980
108  copyExecutableFile10 :: GHC.Exception.SomeException
109                          -> GHC.Prim.State# GHC.Prim.RealWorld
110                          -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
111    {- Arity: 2, HasNoCafRefs,
112       Unfolding: (\ e :: GHC.Exception.SomeException
113                     eta :: GHC.Prim.State# GHC.Prim.RealWorld ->
114                   case e of wild { GHC.Exception.SomeException e100 $dException1 e1 ->
115                   case (GHC.Exception.$p1Exception @ e100 $dException1)
116                          `cast`
117                        (Data.Typeable.Internal.NTCo:Typeable (Refl e100))
118                          e1 of wild1 { Data.Typeable.Internal.TypeRep rb rb1 ds2 ds3 ->
119                   case GHC.Prim.eqWord# rb __word 7238999624334008818 of wild2 {
120                     GHC.Types.False
121                     -> GHC.Prim.raiseIO# @ GHC.Exception.SomeException @ () wild eta
122                     GHC.Types.True
123                     -> case GHC.Prim.eqWord# rb1 __word 10769272474234763719 of wild3 {
124                          GHC.Types.False
125                          -> GHC.Prim.raiseIO# @ GHC.Exception.SomeException @ () wild eta
126                          GHC.Types.True -> (# eta, GHC.Tuple.() #) } } } }) -}
1277dd551e4476eb49e5a5f9f914b66e6e7
128  copyExecutableFile11 :: GHC.Exception.SomeException
129                          -> GHC.Prim.State# GHC.Prim.RealWorld
130                          -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
131    {- Arity: 2, HasNoCafRefs,
132       Unfolding: (\ e :: GHC.Exception.SomeException
133                     eta :: GHC.Prim.State# GHC.Prim.RealWorld ->
134                   case e of wild { GHC.Exception.SomeException e100 $dException1 e1 ->
135                   case (GHC.Exception.$p1Exception @ e100 $dException1)
136                          `cast`
137                        (Data.Typeable.Internal.NTCo:Typeable (Refl e100))
138                          e1 of wild1 { Data.Typeable.Internal.TypeRep rb rb1 ds2 ds3 ->
139                   case GHC.Prim.eqWord# rb __word 7238999624334008818 of wild2 {
140                     GHC.Types.False
141                     -> GHC.Prim.raiseIO# @ GHC.Exception.SomeException @ () wild eta
142                     GHC.Types.True
143                     -> case GHC.Prim.eqWord# rb1 __word 10769272474234763719 of wild3 {
144                          GHC.Types.False
145                          -> GHC.Prim.raiseIO# @ GHC.Exception.SomeException @ () wild eta
146                          GHC.Types.True -> (# eta, GHC.Tuple.() #) } } } }) -}
14743f6b86714d8af1fd67f69e708fc5032
148  copyExecutableFile12 :: [GHC.Types.Char]
149    {- Unfolding: (GHC.CString.unpackCString# ".myCopyFile.tmp") -}
150455f0ee6fd1f941141b5c87b771ea421
151  copyExecutableFile2 :: GHC.Word.Word32
152    {- HasNoCafRefs, Strictness: m,
153       Unfolding: (GHC.Word.W32# __word 493) -}
1543d3d1e071cb71d1d731186e45aaaf4ab
155  copyExecutableFile3 :: GHC.IO.FilePath
156                         -> System.Posix.Types.FileMode
157                         -> GHC.Prim.State# GHC.Prim.RealWorld
158                         -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
159    {- Arity: 3, Strictness: LLL,
160       Unfolding: (\ name :: GHC.IO.FilePath
161                     m :: System.Posix.Types.FileMode
162                     eta :: GHC.Prim.State# GHC.Prim.RealWorld ->
163                   case GHC.IO.Encoding.getFileSystemEncoding1 of wild { (,) getFileSystemEncoding12 setFileSystemEncoding1 ->
164                   case getFileSystemEncoding12
165                          `cast`
166                        (GHC.Types.NTCo:IO (Refl GHC.IO.Encoding.Types.TextEncoding))
167                          eta of wild1 { (#,#) new_s a76 ->
168                   let {
169                     lvl1 :: Data.Maybe.Maybe GHC.Base.String
170                     = Data.Maybe.Just @ GHC.Base.String name
171                   } in
172                   GHC.Foreign.charIsRepresentable3
173                     @ ()
174                     a76
175                     name
176                     (\ s :: Foreign.C.String.CString
177                        s1 :: GHC.Prim.State# GHC.Prim.RealWorld ->
178                      case s `cast`
179                           (GHC.Ptr.Ptr
180                                (Foreign.C.Types.NTCo:CChar)) of ds2 { GHC.Ptr.Ptr ds3 ->
181                      case m `cast`
182                           (System.Posix.Types.NTCo:CMode) of ds4 { GHC.Word.W32# ds5 ->
183                      case {__pkg_ccall base chmod GHC.Prim.Addr#
184                                                   -> GHC.Prim.Word#
185                                                   -> GHC.Prim.State# GHC.Prim.RealWorld
186                                                   -> (# GHC.Prim.State# GHC.Prim.RealWorld,
187                                                         GHC.Prim.Int# #)}
188                             ds3
189                             ds5
190                             s1 of wild2 { (#,#) ds7 ds8 ->
191                      case GHC.Prim.narrow32Int# ds8 of wild3 {
192                        DEFAULT -> (# ds7, GHC.Tuple.() #)
193                        (-1)
194                        -> case {__pkg_ccall base __hscore_get_errno GHC.Prim.State#
195                                                                         GHC.Prim.RealWorld
196                                                                     -> (# GHC.Prim.State#
197                                                                               GHC.Prim.RealWorld,
198                                                                           GHC.Prim.Int# #)}
199                                  ds7 of wild4 { (#,#) ds ds1 ->
200                           case (GHC.IO.Exception.ioError
201                                   @ Foreign.C.Types.CInt
202                                   (Foreign.C.Error.errnoToIOError
203                                      CopyFile.copyExecutableFile4
204                                      (GHC.Int.I32# (GHC.Prim.narrow32Int# ds1))
205                                        `cast`
206                                      (Trans
207                                           (Sym (Foreign.C.Types.NTCo:CInt))
208                                           (Sym (Foreign.C.Error.NTCo:Errno)))
209                                      (Data.Maybe.Nothing @ GHC.IO.Handle.Types.Handle)
210                                      lvl1))
211                                  `cast`
212                                (GHC.Types.NTCo:IO (Refl Foreign.C.Types.CInt))
213                                  ds of wild5 { (#,#) new_s1 a1 ->
214                           (# new_s1, GHC.Tuple.() #) } } } } } })
215                       `cast`
216                     ((->)
217                          (Refl Foreign.C.String.CString)
218                          (Sym (GHC.Types.NTCo:IO (Refl ()))))
219                     new_s } }) -}
220ff297c6d061d4c0e61130b2015372b21
221  copyExecutableFile4 :: [GHC.Types.Char]
222    {- Unfolding: (GHC.CString.unpackCString# "setFileMode") -}
223cf098fec868140439e2c63e7bfff082e
224  copyExecutableFile5 :: GHC.IO.FilePath
225                         -> GHC.IO.FilePath
226                         -> GHC.Prim.State# GHC.Prim.RealWorld
227                         -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
228    {- Arity: 3, Strictness: LLL,
229       Unfolding: (\ fromFPath :: GHC.IO.FilePath
230                     toFPath :: GHC.IO.FilePath
231                     eta :: GHC.Prim.State# GHC.Prim.RealWorld ->
232                   GHC.Prim.catch#
233                     @ ()
234                     @ GHC.Exception.SomeException
235                     (let {
236                        a :: GHC.Prim.State# GHC.Prim.RealWorld
237                             -> (# GHC.Prim.State# GHC.Prim.RealWorld,
238                                   (GHC.IO.FilePath, GHC.IO.Handle.Types.Handle) #)
239                          {- Arity: 1, Strictness: L -}
240                        = \ eta1 :: GHC.Prim.State# GHC.Prim.RealWorld ->
241                          System.IO.openBinaryTempFile4
242                            System.IO.openBinaryTempFile3
243                            (System.FilePath.Posix.takeDirectory toFPath)
244                            CopyFile.copyExecutableFile12
245                            GHC.Types.True
246                            System.IO.openBinaryTempFile2
247                              `cast`
248                            (Sym (System.Posix.Types.NTCo:CMode))
249                            eta1
250                      } in
251                      Control.Exception.Base.bracket1
252                        @ GHC.IO.Handle.Types.Handle
253                        @ ()
254                        @ ()
255                        (GHC.IO.Handle.FD.openBinaryFile1 fromFPath GHC.IO.IOMode.ReadMode)
256                          `cast`
257                        (Sym (GHC.Types.NTCo:IO (Refl GHC.IO.Handle.Types.Handle)))
258                        GHC.IO.Handle.hClose1
259                          `cast`
260                        ((->)
261                             (Refl GHC.IO.Handle.Types.Handle)
262                             (Sym (GHC.Types.NTCo:IO (Refl ()))))
263                        (\ hFrom :: GHC.IO.Handle.Types.Handle ->
264                         Control.Exception.Base.bracketOnError1
265                           @ (GHC.IO.FilePath, GHC.IO.Handle.Types.Handle)
266                           @ ()
267                           @ ()
268                           a `cast`
269                           (Sym (GHC.Types.NTCo:IO
270                                     (Refl (GHC.IO.FilePath, GHC.IO.Handle.Types.Handle))))
271                           CopyFile.copyExecutableFile9
272                             `cast`
273                           ((->)
274                                (Refl (GHC.IO.FilePath, GHC.IO.Handle.Types.Handle))
275                                (Sym (GHC.Types.NTCo:IO (Refl ()))))
276                           (\ ds :: (GHC.IO.FilePath, GHC.IO.Handle.Types.Handle) ->
277                            case ds of wild { (,) tmpFPath hTmp ->
278                            (\ s :: GHC.Prim.State# GHC.Prim.RealWorld ->
279                             case GHC.Prim.newPinnedByteArray#
280                                    @ GHC.Prim.RealWorld
281                                    4096
282                                    s of wild1 { (#,#) s1 mbarr# ->
283                             case GHC.Prim.unsafeFreezeByteArray#
284                                    @ GHC.Prim.RealWorld
285                                    mbarr#
286                                    s1 of wild2 { (#,#) s2 barr# ->
287                             case CopyFile.copyExecutableFile8
288                                    @ (GHC.Prim.Any *)
289                                    hFrom
290                                    hTmp
291                                    (GHC.Ptr.Ptr
292                                       @ (GHC.Prim.Any *)
293                                       (GHC.Prim.byteArrayContents# barr#))
294                                    s2 of wild3 { (#,#) s3 r ->
295                             case GHC.Prim.touch#
296                                    @ GHC.Prim.ByteArray#
297                                    barr#
298                                    s3 of s4 { DEFAULT ->
299                             case GHC.IO.Handle.hClose1 hTmp s4 of wild4 { (#,#) new_s a1 ->
300                             System.Directory.renameFile1 tmpFPath toFPath new_s } } } } })
301                              `cast`
302                            (Sym (GHC.Types.NTCo:IO (Refl ()))) }))
303                          `cast`
304                        ((->)
305                             (Refl GHC.IO.Handle.Types.Handle)
306                             (Sym (GHC.Types.NTCo:IO (Refl ())))))
307                     CopyFile.copyExecutableFile6
308                     eta) -}
30926c362acd735c4f9d52cc12508498234
310  copyExecutableFile6 :: GHC.Exception.SomeException
311                         -> GHC.Prim.State# GHC.Prim.RealWorld
312                         -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
313    {- Arity: 1,
314       Unfolding: (\ e :: GHC.Exception.SomeException ->
315                   case e of wild { GHC.Exception.SomeException e100 $dException1 e1 ->
316                   case (GHC.Exception.$p1Exception @ e100 $dException1)
317                          `cast`
318                        (Data.Typeable.Internal.NTCo:Typeable (Refl e100))
319                          e1 of wild1 { Data.Typeable.Internal.TypeRep rb rb1 ds2 ds3 ->
320                   case GHC.Prim.eqWord# rb __word 7238999624334008818 of wild2 {
321                     GHC.Types.False
322                     -> GHC.Prim.raiseIO# @ GHC.Exception.SomeException @ () wild
323                     GHC.Types.True
324                     -> case GHC.Prim.eqWord# rb1 __word 10769272474234763719 of wild3 {
325                          GHC.Types.False
326                          -> GHC.Prim.raiseIO# @ GHC.Exception.SomeException @ () wild
327                          GHC.Types.True
328                          -> CopyFile.copyExecutableFile7
329                               e1 `cast` (Unsafe e100 GHC.IO.Exception.IOException) } } } }) -}
330dd095ec0e3d89758ed6c26867d17b67f
331  copyExecutableFile7 :: GHC.IO.Exception.IOException
332                         -> GHC.Prim.State# GHC.Prim.RealWorld
333                         -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
334    {- Arity: 2, Strictness: SLb -}
33541a6bb4d358682c64a0fb46cee87c79a
336  copyExecutableFile8 :: forall a.
337                         GHC.IO.Handle.Types.Handle
338                         -> GHC.IO.Handle.Types.Handle
339                         -> GHC.Ptr.Ptr a
340                         -> GHC.Prim.State# GHC.Prim.RealWorld
341                         -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
342    {- Arity: 4, Strictness: LLLL -}
34381c21ebb316628bed68c5e41f1c6db88
344  copyExecutableFile9 :: (GHC.IO.FilePath,
345                          GHC.IO.Handle.Types.Handle)
346                         -> GHC.Prim.State# GHC.Prim.RealWorld
347                         -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
348    {- Arity: 2, Strictness: U(LL)L, Inline: INLINE[0],
349       Unfolding: Worker(ext0: CopyFile.$wa (arity 2) -}
350f4186a20d61506b9151111691d9add95
351  copyOrdinaryFile :: GHC.IO.FilePath
352                      -> GHC.IO.FilePath
353                      -> GHC.Types.IO ()
354    {- Arity: 3, Strictness: LLL,
355       Unfolding: (CopyFile.copyOrdinaryFile1
356                     `cast`
357                   ((->)
358                        (Refl GHC.IO.FilePath)
359                        ((->)
360                             (Refl GHC.IO.FilePath) (Sym (GHC.Types.NTCo:IO (Refl ())))))) -}
361c690f2739a910df15ea5b2072374c94f
362  copyOrdinaryFile1 :: GHC.IO.FilePath
363                       -> GHC.IO.FilePath
364                       -> GHC.Prim.State# GHC.Prim.RealWorld
365                       -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
366    {- Arity: 3, Strictness: LLL,
367       Unfolding: (\ src :: GHC.IO.FilePath
368                     dest :: GHC.IO.FilePath
369                     eta :: GHC.Prim.State# GHC.Prim.RealWorld ->
370                   case CopyFile.copyExecutableFile5
371                          src
372                          dest
373                          eta of wild { (#,#) new_s a ->
374                   CopyFile.copyExecutableFile3
375                     dest
376                     CopyFile.copyOrdinaryFile2
377                       `cast`
378                     (Sym (System.Posix.Types.NTCo:CMode))
379                     new_s }) -}
380fa882f7d1b3409b6d4f657238f3881a5
381  copyOrdinaryFile2 :: GHC.Word.Word32
382    {- HasNoCafRefs, Strictness: m,
383       Unfolding: (GHC.Word.W32# __word 420) -}
38432dae6056f7514e6db2c442efc847ac4
385  myCopyFile :: GHC.IO.FilePath -> GHC.IO.FilePath -> GHC.Types.IO ()
386    {- Arity: 3, Strictness: LLL,
387       Unfolding: (CopyFile.copyExecutableFile5
388                     `cast`
389                   ((->)
390                        (Refl GHC.IO.FilePath)
391                        ((->)
392                             (Refl GHC.IO.FilePath) (Sym (GHC.Types.NTCo:IO (Refl ())))))) -}
3938088db8698fb982ea4e2e43b3a1b543a
394  setDirOrdinary :: GHC.IO.FilePath -> GHC.Types.IO ()
395    {- Arity: 2, Strictness: LL,
396       Unfolding: (CopyFile.setDirOrdinary1
397                     `cast`
398                   ((->)
399                        (Refl GHC.IO.FilePath) (Sym (GHC.Types.NTCo:IO (Refl ()))))) -}
400aeea5bffad06b642fe7c1c0f3982830f
401  setDirOrdinary1 :: GHC.IO.FilePath
402                     -> GHC.Prim.State# GHC.Prim.RealWorld
403                     -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
404    {- Arity: 2, Strictness: LL,
405       Unfolding: (\ path :: GHC.IO.FilePath
406                     eta :: GHC.Prim.State# GHC.Prim.RealWorld ->
407                   CopyFile.copyExecutableFile3
408                     path
409                     CopyFile.copyExecutableFile2
410                       `cast`
411                     (Sym (System.Posix.Types.NTCo:CMode))
412                     eta) -}
41329d341d798e98cfb3ba0c386f7475527
414  setFileExecutable :: GHC.IO.FilePath -> GHC.Types.IO ()
415    {- Arity: 2, Strictness: LL,
416       Unfolding: (CopyFile.setDirOrdinary1
417                     `cast`
418                   ((->)
419                        (Refl GHC.IO.FilePath) (Sym (GHC.Types.NTCo:IO (Refl ()))))) -}
420147880402612206c0fd7dfa8a5ea194a
421  setFileOrdinary :: GHC.IO.FilePath -> GHC.Types.IO ()
422    {- Arity: 2, Strictness: LL,
423       Unfolding: (CopyFile.setFileOrdinary1
424                     `cast`
425                   ((->)
426                        (Refl GHC.IO.FilePath) (Sym (GHC.Types.NTCo:IO (Refl ()))))) -}
427dc445f24d45a1f913af9527d921c3650
428  setFileOrdinary1 :: GHC.IO.FilePath
429                      -> GHC.Prim.State# GHC.Prim.RealWorld
430                      -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
431    {- Arity: 2, Strictness: LL,
432       Unfolding: (\ path :: GHC.IO.FilePath
433                     eta :: GHC.Prim.State# GHC.Prim.RealWorld ->
434                   CopyFile.copyExecutableFile3
435                     path
436                     CopyFile.copyOrdinaryFile2
437                       `cast`
438                     (Sym (System.Posix.Types.NTCo:CMode))
439                     eta) -}
440vectorised variables:
441vectorised tycons:
442vectorised reused tycons:
443scalar variables:
444scalar tycons:
445trusted: none
446require own pkg trusted: False
447