Allow top-level string literals in Core (#8472)
[ghc.git] / testsuite / tests / simplCore / should_compile / spec-inline.stderr
1
2 ==================== Tidy Core ====================
3 Result size of Tidy Core = {terms: 178, types: 68, coercions: 0}
4
5 -- RHS size: {terms: 1, types: 0, coercions: 0}
6 Roman.$trModule4 :: GHC.Prim.Addr#
7 [GblId,
8  Caf=NoCafRefs,
9  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
10          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 20 0}]
11 Roman.$trModule4 = "main"#
12
13 -- RHS size: {terms: 2, types: 0, coercions: 0}
14 Roman.$trModule3 :: GHC.Types.TrName
15 [GblId,
16  Caf=NoCafRefs,
17  Str=m1,
18  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
19          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
20 Roman.$trModule3 = GHC.Types.TrNameS Roman.$trModule4
21
22 -- RHS size: {terms: 1, types: 0, coercions: 0}
23 Roman.$trModule2 :: GHC.Prim.Addr#
24 [GblId,
25  Caf=NoCafRefs,
26  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
27          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 30 0}]
28 Roman.$trModule2 = "Roman"#
29
30 -- RHS size: {terms: 2, types: 0, coercions: 0}
31 Roman.$trModule1 :: GHC.Types.TrName
32 [GblId,
33  Caf=NoCafRefs,
34  Str=m1,
35  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
36          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
37 Roman.$trModule1 = GHC.Types.TrNameS Roman.$trModule2
38
39 -- RHS size: {terms: 3, types: 0, coercions: 0}
40 Roman.$trModule :: GHC.Types.Module
41 [GblId,
42  Caf=NoCafRefs,
43  Str=m,
44  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
45          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 30}]
46 Roman.$trModule =
47   GHC.Types.Module Roman.$trModule3 Roman.$trModule1
48
49 -- RHS size: {terms: 1, types: 0, coercions: 0}
50 lvl :: GHC.Prim.Addr#
51 [GblId, Caf=NoCafRefs]
52 lvl = "spec-inline.hs:(19,5)-(29,25)|function go"#
53
54 -- RHS size: {terms: 2, types: 2, coercions: 0}
55 Roman.foo3 :: Int
56 [GblId, Str=x]
57 Roman.foo3 =
58   Control.Exception.Base.patError @ 'GHC.Types.LiftedRep @ Int lvl
59
60 Rec {
61 -- RHS size: {terms: 55, types: 9, coercions: 0}
62 Roman.foo_$s$wgo [Occ=LoopBreaker]
63   :: GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.Prim.Int#
64 [GblId, Arity=2, Caf=NoCafRefs, Str=<S,U><S,U>]
65 Roman.foo_$s$wgo =
66   \ (sc :: GHC.Prim.Int#) (sc1 :: GHC.Prim.Int#) ->
67     let {
68       m :: GHC.Prim.Int#
69       [LclId]
70       m =
71         GHC.Prim.+#
72           (GHC.Prim.+#
73              (GHC.Prim.+#
74                 (GHC.Prim.+# (GHC.Prim.+# (GHC.Prim.+# sc sc) sc) sc) sc)
75              sc)
76           sc } in
77     case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<=# sc1 0#) of {
78       False ->
79         case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# sc1 100#) of {
80           False ->
81             case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# sc1 500#) of {
82               False -> Roman.foo_$s$wgo (GHC.Prim.+# m m) (GHC.Prim.-# sc1 1#);
83               True -> Roman.foo_$s$wgo m (GHC.Prim.-# sc1 3#)
84             };
85           True -> Roman.foo_$s$wgo sc (GHC.Prim.-# sc1 2#)
86         };
87       True -> 0#
88     }
89 end Rec }
90
91 -- RHS size: {terms: 74, types: 22, coercions: 0}
92 Roman.$wgo [InlPrag=[0]] :: Maybe Int -> Maybe Int -> GHC.Prim.Int#
93 [GblId,
94  Arity=2,
95  Str=<S,1*U><S,1*U>,
96  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
97          WorkFree=True, Expandable=True, Guidance=IF_ARGS [60 30] 256 0}]
98 Roman.$wgo =
99   \ (w :: Maybe Int) (w1 :: Maybe Int) ->
100     case w1 of {
101       Nothing -> case Roman.foo3 of wild1 { };
102       Just x ->
103         case x of { GHC.Types.I# ipv ->
104         let {
105           m :: GHC.Prim.Int#
106           [LclId]
107           m =
108             GHC.Prim.+#
109               (GHC.Prim.+#
110                  (GHC.Prim.+#
111                     (GHC.Prim.+# (GHC.Prim.+# (GHC.Prim.+# ipv ipv) ipv) ipv) ipv)
112                  ipv)
113               ipv } in
114         case w of {
115           Nothing -> Roman.foo_$s$wgo m 10#;
116           Just n ->
117             case n of { GHC.Types.I# x2 ->
118             case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<=# x2 0#) of {
119               False ->
120                 case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# x2 100#) of {
121                   False ->
122                     case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# x2 500#) of {
123                       False -> Roman.foo_$s$wgo (GHC.Prim.+# m m) (GHC.Prim.-# x2 1#);
124                       True -> Roman.foo_$s$wgo m (GHC.Prim.-# x2 3#)
125                     };
126                   True -> Roman.foo_$s$wgo ipv (GHC.Prim.-# x2 2#)
127                 };
128               True -> 0#
129             }
130             }
131         }
132         }
133     }
134
135 -- RHS size: {terms: 9, types: 5, coercions: 0}
136 Roman.foo_go [InlPrag=INLINE[0]] :: Maybe Int -> Maybe Int -> Int
137 [GblId,
138  Arity=2,
139  Str=<S,1*U><S,1*U>m,
140  Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
141          WorkFree=True, Expandable=True,
142          Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
143          Tmpl= \ (w [Occ=Once] :: Maybe Int) (w1 [Occ=Once] :: Maybe Int) ->
144                  case Roman.$wgo w w1 of ww { __DEFAULT -> GHC.Types.I# ww }}]
145 Roman.foo_go =
146   \ (w :: Maybe Int) (w1 :: Maybe Int) ->
147     case Roman.$wgo w w1 of ww { __DEFAULT -> GHC.Types.I# ww }
148
149 -- RHS size: {terms: 2, types: 0, coercions: 0}
150 Roman.foo2 :: Int
151 [GblId,
152  Caf=NoCafRefs,
153  Str=m,
154  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
155          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
156 Roman.foo2 = GHC.Types.I# 6#
157
158 -- RHS size: {terms: 2, types: 1, coercions: 0}
159 Roman.foo1 :: Maybe Int
160 [GblId,
161  Caf=NoCafRefs,
162  Str=m2,
163  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
164          WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
165 Roman.foo1 = GHC.Base.Just @ Int Roman.foo2
166
167 -- RHS size: {terms: 11, types: 4, coercions: 0}
168 foo :: Int -> Int
169 [GblId,
170  Arity=1,
171  Caf=NoCafRefs,
172  Str=<S(S),1*U(U)>m,
173  Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
174          WorkFree=True, Expandable=True,
175          Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
176          Tmpl= \ (n [Occ=Once!] :: Int) ->
177                  case n of n1 { GHC.Types.I# _ [Occ=Dead] ->
178                  Roman.foo_go (GHC.Base.Just @ Int n1) Roman.foo1
179                  }}]
180 foo =
181   \ (n :: Int) ->
182     case n of { GHC.Types.I# ipv ->
183     case Roman.foo_$s$wgo 6# ipv of ww { __DEFAULT -> GHC.Types.I# ww }
184     }
185
186
187 ------ Local rules for imported ids --------
188 "SC:$wgo0" [0]
189     forall (sc :: GHC.Prim.Int#) (sc1 :: GHC.Prim.Int#).
190       Roman.$wgo (GHC.Base.Just @ Int (GHC.Types.I# sc1))
191                  (GHC.Base.Just @ Int (GHC.Types.I# sc))
192       = Roman.foo_$s$wgo sc sc1
193
194