Join points
[ghc.git] / testsuite / tests / simplCore / should_compile / spec-inline.stderr
index 8690176..dda28c8 100644 (file)
 
 ==================== Tidy Core ====================
-Result size of Tidy Core = {terms: 162, types: 61, coercions: 0}
+Result size of Tidy Core
+  = {terms: 178, types: 68, coercions: 0, joins: 0/2}
 
-Roman.foo3 :: GHC.Types.Int
-[GblId, Str=DmdType b]
+-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
+Roman.$trModule4 :: GHC.Prim.Addr#
+[GblId,
+ Caf=NoCafRefs,
+ Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
+         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 20 0}]
+Roman.$trModule4 = "main"#
+
+-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
+Roman.$trModule3 :: GHC.Types.TrName
+[GblId,
+ Caf=NoCafRefs,
+ Str=m1,
+ Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
+         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
+Roman.$trModule3 = GHC.Types.TrNameS Roman.$trModule4
+
+-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
+Roman.$trModule2 :: GHC.Prim.Addr#
+[GblId,
+ Caf=NoCafRefs,
+ Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
+         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 30 0}]
+Roman.$trModule2 = "Roman"#
+
+-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
+Roman.$trModule1 :: GHC.Types.TrName
+[GblId,
+ Caf=NoCafRefs,
+ Str=m1,
+ Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
+         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
+Roman.$trModule1 = GHC.Types.TrNameS Roman.$trModule2
+
+-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0}
+Roman.$trModule :: GHC.Types.Module
+[GblId,
+ Caf=NoCafRefs,
+ Str=m,
+ Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
+         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 30}]
+Roman.$trModule =
+  GHC.Types.Module Roman.$trModule3 Roman.$trModule1
+
+-- RHS size: {terms: 1, types: 0, coercions: 0, joins: 0/0}
+lvl :: GHC.Prim.Addr#
+[GblId, Caf=NoCafRefs]
+lvl = "spec-inline.hs:(19,5)-(29,25)|function go"#
+
+-- RHS size: {terms: 2, types: 2, coercions: 0, joins: 0/0}
+Roman.foo3 :: Int
+[GblId, Str=x]
 Roman.foo3 =
-  Control.Exception.Base.patError
-    @ GHC.Types.Int "spec-inline.hs:(19,5)-(29,25)|function go"#
+  Control.Exception.Base.patError @ 'GHC.Types.LiftedRep @ Int lvl
 
 Rec {
+-- RHS size: {terms: 55, types: 9, coercions: 0, joins: 0/1}
 Roman.foo_$s$wgo [Occ=LoopBreaker]
   :: GHC.Prim.Int# -> GHC.Prim.Int# -> GHC.Prim.Int#
-[GblId, Arity=2, Caf=NoCafRefs, Str=DmdType <L,U><L,U>]
+[GblId, Arity=2, Caf=NoCafRefs, Str=<S,U><S,U>]
 Roman.foo_$s$wgo =
   \ (sc :: GHC.Prim.Int#) (sc1 :: GHC.Prim.Int#) ->
     let {
-      a :: GHC.Prim.Int#
-      [LclId, Str=DmdType]
-      a =
+      m :: GHC.Prim.Int#
+      [LclId]
+      m =
         GHC.Prim.+#
           (GHC.Prim.+#
              (GHC.Prim.+#
-                (GHC.Prim.+# (GHC.Prim.+# (GHC.Prim.+# sc1 sc1) sc1) sc1) sc1)
-             sc1)
-          sc1 } in
-    case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<=# sc 0)
-    of _ [Occ=Dead] {
-      GHC.Types.False ->
-        case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<# sc 100)
-        of _ [Occ=Dead] {
-          GHC.Types.False ->
-            case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<# sc 500)
-            of _ [Occ=Dead] {
-              GHC.Types.False ->
-                Roman.foo_$s$wgo (GHC.Prim.-# sc 1) (GHC.Prim.+# a a);
-              GHC.Types.True -> Roman.foo_$s$wgo (GHC.Prim.-# sc 3) a
+                (GHC.Prim.+# (GHC.Prim.+# (GHC.Prim.+# sc sc) sc) sc) sc)
+             sc)
+          sc } in
+    case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<=# sc1 0#) of {
+      False ->
+        case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# sc1 100#) of {
+          False ->
+            case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# sc1 500#) of {
+              False -> Roman.foo_$s$wgo (GHC.Prim.+# m m) (GHC.Prim.-# sc1 1#);
+              True -> Roman.foo_$s$wgo m (GHC.Prim.-# sc1 3#)
             };
-          GHC.Types.True -> Roman.foo_$s$wgo (GHC.Prim.-# sc 2) sc1
+          True -> Roman.foo_$s$wgo sc (GHC.Prim.-# sc1 2#)
         };
-      GHC.Types.True -> 0
+      True -> 0#
     }
 end Rec }
 
-Roman.$wgo
-  :: Data.Maybe.Maybe GHC.Types.Int
-     -> Data.Maybe.Maybe GHC.Types.Int -> GHC.Prim.Int#
+-- RHS size: {terms: 74, types: 22, coercions: 0, joins: 0/1}
+Roman.$wgo [InlPrag=[0]] :: Maybe Int -> Maybe Int -> GHC.Prim.Int#
 [GblId,
  Arity=2,
- Str=DmdType <S,1*U><S,1*U>,
- Unf=Unf{Src=<vanilla>, TopLvl=True, Arity=2, Value=True,
-         ConLike=True, WorkFree=True, Expandable=True,
-         Guidance=IF_ARGS [60 30] 256 0}]
+ Str=<S,1*U><S,1*U>,
+ Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
+         WorkFree=True, Expandable=True, Guidance=IF_ARGS [60 30] 256 0}]
 Roman.$wgo =
-  \ (w :: Data.Maybe.Maybe GHC.Types.Int)
-    (w1 :: Data.Maybe.Maybe GHC.Types.Int) ->
-    case w1 of _ [Occ=Dead] {
-      Data.Maybe.Nothing -> case Roman.foo3 of wild1 { };
-      Data.Maybe.Just x ->
-        case x of _ [Occ=Dead] { GHC.Types.I# ipv ->
+  \ (w :: Maybe Int) (w1 :: Maybe Int) ->
+    case w1 of {
+      Nothing -> case Roman.foo3 of wild1 { };
+      Just x ->
+        case x of { GHC.Types.I# ipv ->
         let {
-          a :: GHC.Prim.Int#
-          [LclId, Str=DmdType]
-          a =
+          m :: GHC.Prim.Int#
+          [LclId]
+          m =
             GHC.Prim.+#
               (GHC.Prim.+#
                  (GHC.Prim.+#
                     (GHC.Prim.+# (GHC.Prim.+# (GHC.Prim.+# ipv ipv) ipv) ipv) ipv)
                  ipv)
               ipv } in
-        case w of _ [Occ=Dead] {
-          Data.Maybe.Nothing -> Roman.foo_$s$wgo 10 a;
-          Data.Maybe.Just n ->
-            case n of _ [Occ=Dead] { GHC.Types.I# x2 ->
-            case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<=# x2 0)
-            of _ [Occ=Dead] {
-              GHC.Types.False ->
-                case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<# x2 100)
-                of _ [Occ=Dead] {
-                  GHC.Types.False ->
-                    case GHC.Prim.tagToEnum# @ GHC.Types.Bool (GHC.Prim.<# x2 500)
-                    of _ [Occ=Dead] {
-                      GHC.Types.False ->
-                        Roman.foo_$s$wgo (GHC.Prim.-# x2 1) (GHC.Prim.+# a a);
-                      GHC.Types.True -> Roman.foo_$s$wgo (GHC.Prim.-# x2 3) a
+        case w of {
+          Nothing -> Roman.foo_$s$wgo m 10#;
+          Just n ->
+            case n of { GHC.Types.I# x2 ->
+            case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<=# x2 0#) of {
+              False ->
+                case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# x2 100#) of {
+                  False ->
+                    case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# x2 500#) of {
+                      False -> Roman.foo_$s$wgo (GHC.Prim.+# m m) (GHC.Prim.-# x2 1#);
+                      True -> Roman.foo_$s$wgo m (GHC.Prim.-# x2 3#)
                     };
-                  GHC.Types.True -> Roman.foo_$s$wgo (GHC.Prim.-# x2 2) ipv
+                  True -> Roman.foo_$s$wgo ipv (GHC.Prim.-# x2 2#)
                 };
-              GHC.Types.True -> 0
+              True -> 0#
             }
             }
         }
         }
     }
 
-Roman.foo_go [InlPrag=INLINE[0]]
-  :: Data.Maybe.Maybe GHC.Types.Int
-     -> Data.Maybe.Maybe GHC.Types.Int -> GHC.Types.Int
+-- RHS size: {terms: 9, types: 5, coercions: 0, joins: 0/0}
+Roman.foo_go [InlPrag=INLINE[0]] :: Maybe Int -> Maybe Int -> Int
 [GblId,
  Arity=2,
- Str=DmdType <S,1*U><S,1*U>m,
- Unf=Unf{Src=InlineStable, TopLvl=True, Arity=2, Value=True,
-         ConLike=True, WorkFree=True, Expandable=True,
-         Guidance=ALWAYS_IF(unsat_ok=True,boring_ok=False)
-         Tmpl= \ (w [Occ=Once] :: Data.Maybe.Maybe GHC.Types.Int)
-                 (w1 [Occ=Once] :: Data.Maybe.Maybe GHC.Types.Int) ->
+ Str=<S,1*U><S,1*U>m,
+ Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
+         WorkFree=True, Expandable=True,
+         Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
+         Tmpl= \ (w [Occ=Once] :: Maybe Int) (w1 [Occ=Once] :: Maybe Int) ->
                  case Roman.$wgo w w1 of ww { __DEFAULT -> GHC.Types.I# ww }}]
 Roman.foo_go =
-  \ (w :: Data.Maybe.Maybe GHC.Types.Int)
-    (w1 :: Data.Maybe.Maybe GHC.Types.Int) ->
+  \ (w :: Maybe Int) (w1 :: Maybe Int) ->
     case Roman.$wgo w w1 of ww { __DEFAULT -> GHC.Types.I# ww }
 
-Roman.foo2 :: GHC.Types.Int
+-- RHS size: {terms: 2, types: 0, coercions: 0, joins: 0/0}
+Roman.foo2 :: Int
 [GblId,
  Caf=NoCafRefs,
- Str=DmdType m,
- Unf=Unf{Src=<vanilla>, TopLvl=True, Arity=0, Value=True,
-         ConLike=True, WorkFree=True, Expandable=True,
-         Guidance=IF_ARGS [] 10 20}]
-Roman.foo2 = GHC.Types.I# 6
+ Str=m,
+ Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
+         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
+Roman.foo2 = GHC.Types.I# 6#
 
-Roman.foo1 :: Data.Maybe.Maybe GHC.Types.Int
+-- RHS size: {terms: 2, types: 1, coercions: 0, joins: 0/0}
+Roman.foo1 :: Maybe Int
 [GblId,
  Caf=NoCafRefs,
- Str=DmdType m2,
- Unf=Unf{Src=<vanilla>, TopLvl=True, Arity=0, Value=True,
-         ConLike=True, WorkFree=True, Expandable=True,
-         Guidance=IF_ARGS [] 10 20}]
-Roman.foo1 = Data.Maybe.Just @ GHC.Types.Int Roman.foo2
+ Str=m2,
+ Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
+         WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 20}]
+Roman.foo1 = GHC.Base.Just @ Int Roman.foo2
 
-Roman.foo :: GHC.Types.Int -> GHC.Types.Int
+-- RHS size: {terms: 11, types: 4, coercions: 0, joins: 0/0}
+foo :: Int -> Int
 [GblId,
  Arity=1,
  Caf=NoCafRefs,
- Str=DmdType <S,1*U>m,
- Unf=Unf{Src=InlineStable, TopLvl=True, Arity=1, Value=True,
-         ConLike=True, WorkFree=True, Expandable=True,
-         Guidance=ALWAYS_IF(unsat_ok=True,boring_ok=False)
-         Tmpl= \ (n [Occ=Once!] :: GHC.Types.Int) ->
+ Str=<S(S),1*U(U)>m,
+ Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
+         WorkFree=True, Expandable=True,
+         Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
+         Tmpl= \ (n [Occ=Once!] :: Int) ->
                  case n of n1 { GHC.Types.I# _ [Occ=Dead] ->
-                 Roman.foo_go (Data.Maybe.Just @ GHC.Types.Int n1) Roman.foo1
+                 Roman.foo_go (GHC.Base.Just @ Int n1) Roman.foo1
                  }}]
-Roman.foo =
-  \ (n :: GHC.Types.Int) ->
-    case n of _ [Occ=Dead] { GHC.Types.I# ipv ->
-    case Roman.foo_$s$wgo ipv 6 of ww { __DEFAULT -> GHC.Types.I# ww }
+foo =
+  \ (n :: Int) ->
+    case n of { GHC.Types.I# ipv ->
+    case Roman.foo_$s$wgo 6# ipv of ww { __DEFAULT -> GHC.Types.I# ww }
     }
 
 
 ------ Local rules for imported ids --------
-"SC:$wgo0" [ALWAYS]
+"SC:$wgo0" [0]
     forall (sc :: GHC.Prim.Int#) (sc1 :: GHC.Prim.Int#).
-      Roman.$wgo (Data.Maybe.Just @ GHC.Types.Int (GHC.Types.I# sc))
-                 (Data.Maybe.Just @ GHC.Types.Int (GHC.Types.I# sc1))
+      Roman.$wgo (GHC.Base.Just @ Int (GHC.Types.I# sc1))
+                 (GHC.Base.Just @ Int (GHC.Types.I# sc))
       = Roman.foo_$s$wgo sc sc1