From 972aa3a8650f7c176f67a4277a8c551ae16c9106 Mon Sep 17 00:00:00 2001 From: simonm Date: Thu, 4 Sep 1997 12:54:49 +0000 Subject: [PATCH] [project @ 1997-09-04 12:54:24 by simonm] Make the deriving tests work. Cvs: ---------------------------------------------------------------------- --- ghc/tests/deriving/Makefile | 7 + ghc/tests/deriving/should_compile/Makefile | 7 +- ghc/tests/deriving/should_compile/drv001.stderr | 782 +++++++------------- ghc/tests/deriving/should_compile/drv002.stderr | 453 ++++-------- ghc/tests/deriving/should_compile/drv003.stderr | 291 +++----- ghc/tests/deriving/should_compile/drv004.hs | 7 +- ghc/tests/deriving/should_compile/drv004.stderr | 208 +++++- ghc/tests/deriving/should_compile/drv005.stderr | 273 +++---- ghc/tests/deriving/should_compile/drv006.stderr | 602 ++++++--------- ghc/tests/deriving/should_compile/drv007.stderr | 13 - ghc/tests/deriving/should_fail/Makefile | 14 + ghc/tests/deriving/should_fail/drvfail004.hs | 8 + ghc/tests/deriving/should_fail/drvfail004.stderr | 7 + .../drv007.hs => should_fail/drvfail007.hs} | 2 +- ghc/tests/deriving/should_fail/drvfail007.stderr | 10 + ghc/tests/deriving/should_run/Makefile | 19 + ghc/tests/deriving/should_run/drvrun001.hs | 5 + 17 files changed, 1139 insertions(+), 1569 deletions(-) create mode 100644 ghc/tests/deriving/Makefile delete mode 100644 ghc/tests/deriving/should_compile/drv007.stderr create mode 100644 ghc/tests/deriving/should_fail/Makefile create mode 100644 ghc/tests/deriving/should_fail/drvfail004.hs create mode 100644 ghc/tests/deriving/should_fail/drvfail004.stderr rename ghc/tests/deriving/{should_compile/drv007.hs => should_fail/drvfail007.hs} (80%) create mode 100644 ghc/tests/deriving/should_fail/drvfail007.stderr create mode 100644 ghc/tests/deriving/should_run/Makefile diff --git a/ghc/tests/deriving/Makefile b/ghc/tests/deriving/Makefile new file mode 100644 index 0000000..8712974 --- /dev/null +++ b/ghc/tests/deriving/Makefile @@ -0,0 +1,7 @@ +TOP = .. +include $(TOP)/mk/boilerplate.mk + +SUBDIRS = should_fail should_compile should_run + +include $(TOP)/mk/target.mk + diff --git a/ghc/tests/deriving/should_compile/Makefile b/ghc/tests/deriving/should_compile/Makefile index e64a923..a6cfba3 100644 --- a/ghc/tests/deriving/should_compile/Makefile +++ b/ghc/tests/deriving/should_compile/Makefile @@ -4,12 +4,7 @@ include $(TOP)/mk/boilerplate.mk HS_SRCS = $(wildcard *.hs) SRC_RUNTEST_OPTS += -o1 $*.stdout -o2 $*.stderr -x 0 -HC_OPTS += -noC -ddump-tc -dcore-lint -hi - -drv004_RUNTEST_OPTS = -x 1 -drv007_RUNTEST_OPTS = -x 1 - -%.o : %.hs +HC_OPTS += -noC -dcore-lint -hi -ddump-tc %.o : %.hs $(RUNTEST) $(HC) $(RUNTEST_OPTS) $(HC_OPTS) -c $< -o $@ -osuf $(subst .,,$(suffix $@)) diff --git a/ghc/tests/deriving/should_compile/drv001.stderr b/ghc/tests/deriving/should_compile/drv001.stderr index e1e3a0e..98dbd15 100644 --- a/ghc/tests/deriving/should_compile/drv001.stderr +++ b/ghc/tests/deriving/should_compile/drv001.stderr @@ -2,513 +2,291 @@ ================================================================================ Typechecked: -{- nonrec -} -{- nonrec -} -E1{-r3K,x-}{i} = - _/\_ a{-r3A-} -> - E1{-r3K,x-}{i} - {_@_ a{-r3A-}} -{- nonrec -} -D1{-r6,x-}{i} = - _/\_ b{-r3C-} -> - D1{-r6,x-}{i} - {_@_ b{-r3C-}} -D2{-r5,x-}{i} = - _/\_ b{-r3C-} -> \ tpl_B1 -> - D2{-r5,x-}{i} - {_@_ b{-r3C-} tpl_B1} -{- nonrec -} -C1{-rb,x-}{i} = - _/\_ a{-r3H-} b{-r3I-} -> \ tpl_B1 -> - C1{-rb,x-}{i} - {_@_ a{-r3H-} _@_ b{-r3I-} tpl_B1} -C2{-ra,x-}{i} = - _/\_ a{-r3H-} b{-r3I-} -> \ tpl_B1 -> - C2{-ra,x-}{i} - {_@_ a{-r3H-} _@_ b{-r3I-} tpl_B1} -C3{-rd,x-}{i} = - _/\_ a{-r3H-} b{-r3I-} -> \ tpl_B1 -> - C3{-rd,x-}{i} - {_@_ a{-r3H-} _@_ b{-r3I-} tpl_B1} -{- rec -} -AbsBinds [a{-a1fw-}] [] [([a{-a1fw-}], $d3{-r1fM,x-}, d.Eval_a15O)] - d.Eval_a15O = - ({-dict-} [] []) -{- rec -} -AbsBinds [b{-a1fx-}] [] [([b{-a1fx-}], $d4{-r1ge,x-}, d.Eval_a15U)] - d.Eval_a15U = - ({-dict-} [] []) -{- rec -} +E1{-r3N,x-}{i} = _/\_ a_tr3A -> E1{-r3N,x-}{i} {_@_ a_tr3A} +D1{-rd,x-}{i} = _/\_ b_tr3C -> D1{-rd,x-}{i} {_@_ b_tr3C} +D2{-rc,x-}{i} = + _/\_ b_tr3C -> \ tpl_B1 -> D2{-rc,x-}{i} {_@_ b_tr3C tpl_B1} +C1{-r9,x-}{i} = + _/\_ a_tr3H b_tr3I -> \ tpl_B1 -> + C1{-r9,x-}{i} {_@_ a_tr3H _@_ b_tr3I tpl_B1} +C2{-r8,x-}{i} = + _/\_ a_tr3H b_tr3I -> \ tpl_B1 -> + C2{-r8,x-}{i} {_@_ a_tr3H _@_ b_tr3I tpl_B1} +C3{-rb,x-}{i} = + _/\_ a_tr3H b_tr3I -> \ tpl_B1 -> + C3{-rb,x-}{i} {_@_ a_tr3H _@_ b_tr3I tpl_B1} +AbsBinds [ta18z] [] [([ta18z], $d3{-r18X,x-}, d.Eval_aZt)] + d.Eval_aZt = ({-dict-} [] []) +AbsBinds [ta18A] [] [([ta18A], $d4{-r18Y,x-}, d.Eval_aZz)] + d.Eval_aZz = ({-dict-} [] []) AbsBinds -[a{-a1fy-}, b{-a1fz-}] +[ta18B, ta18C] [] -[([a{-a1fy-}, b{-a1fz-}], $d5{-r1gf,x-}, d.Eval_a161)] - d.Eval_a161 = - ({-dict-} [] []) -{- rec -} +[([ta18B, ta18C], $d5{-r18Z,x-}, d.Eval_aZG)] + d.Eval_aZG = ({-dict-} [] []) +AbsBinds [ta100] [d.Eq_a11o] [([ta100], $d6{-r190,x-}, d.Read_aZM)] + d.Eq_a11G = PrelBase.$d8{-rbj,p-} + d.Eq_a11H = d.Eq_a11o + d.Read_a11E = + $d7{-r191,x-} [PrelBase.Int{-3g,W-}, ta100] [d.Eq_a11G, d.Eq_a11H] + readsPrec_a19o = + PrelRead.readsPrec{-rkH,p-} (X{-r3M,x-} PrelBase.Int{-3g,W-} ta100) + d.Read_a11E + readsPrec_a19p = readsPrec_a19q + AbsBinds [] [] [([], readsPrec_a19q, readsPrec_aZQ)] + ==_a19s = ==_a197 + >>=_a19t = >>=_a198 + return_a19u = return_a199 + zero_a19v = zero_a19a + readsPrec_aZQ a_rX0 b_rX1 + = ++_a196 (Y{-r3L,x-} ta100, PrelBase.String{-rfZ,p-}) + (PrelRead.readParen{-rkX,p-} + (Y{-r3L,x-} ta100) PrelBase.False{-58,w-}{i} + \ c_rX3 + -> [(D1{-rd,x-}{i} ta100, d_rX5) | + ("D1", d_rX5) <- PrelRead.lex{-rkK,p-} c_rX3] + b_rX1) + (PrelRead.readParen{-rkX,p-} (Y{-r3L,x-} ta100) a_rX0 + >_a19b lit_a19c + \ c_rX7 + -> [(D2{-rc,x-}{i} + ta100 a1_rXb, + b1_rXc) | + ("D2", d_rX9) <- PrelRead.lex{-rkK,p-} c_rX7, (a1_rXb, b1_rXc) <- readsPrec_a19o PrelBase.I#{-5b,w-}{i} 10# + d_rX9] + b_rX1) + AbsBinds [] [] [([], readList_a19r, readList_a11j)] + readList_a11j = PrelRead.readList__{-rhB,p-} + (Y{-r3L,x-} ta100) readsPrec_a19p PrelBase.I#{-5b,w-}{i} 0# + d.Read_aZM = ({-dict-} [] [readsPrec_a19q, readList_a19r]) AbsBinds -[b{-a178-}] -[d.Eq_a17C] -[([b{-a178-}], $d6{-r1gg,x-}, d.Read_a167)] - d.Eq_a17Y = - PrelBase.$d7{-rc5,p-} - d.Eq_a17Z = - d.Eq_a17C - d.Read_a17W = - $d7{-r1gl,x-} - [PrelBase.Int{-3g,p-}, b{-a178-}] - [d.Eq_a17Y, d.Eq_a17Z] - readsPrec_a1gk = - PrelRead.readsPrec{-rlS,p-} - (X{-r3N,x-} PrelBase.Int{-3g,p-} b{-a178-}) - d.Read_a17W - readsPrec_a1gj = - readsPrec_a1gi - AbsBinds [] [] [([], readsPrec_a1gi, readsPrec_a16a)] - ==_a1gp = - ==_a1gc - >>=_a1go = - >>=_a1gb - return_a1gn = - return_a1ga - zero_a1gm = - zero_a1g9 - readsPrec_a16a - a_r12Z b_r131 - = ++_a1gd - (Y{-r3M,x-} b{-a178-}, PrelBase.String{-rdl,p-}) - (PrelRead.readParen{-rmu,p-} - (Y{-r3M,x-} b{-a178-}) - PrelBase.False{-58,p-}{i} - \ c_r133 -> [ (D1{-r6,x-}{i} - b{-a178-}, - d_r135) | - ("D1", d_r135) <- PrelRead.lex{-rmh,p-} - c_r133 - ] - b_r131) - (PrelRead.readParen{-rmu,p-} - (Y{-r3M,x-} b{-a178-}) - a_r12Z >_a1g8 lit_a1g6 - \ c_r137 -> [ (D2{-r5,x-}{i} - b{-a178-} - a1_r13b, - b1_r13c) | - ("D2", d_r139) <- PrelRead.lex{-rmh,p-} - c_r137, (a1_r13b, b1_r13c) <- readsPrec_a1gk - lit_a1g4 - d_r139 - ] - b_r131) - AbsBinds [] [] [([], readList_a1gh, readList_a17x)] - readList_a17x - = PrelRead.readList__{-rjw,p-} - (Y{-r3M,x-} b{-a178-}) - readsPrec_a1gj - lit_a1g2 - d.Read_a167 = - ({-dict-} [] [readsPrec_a1gi, readList_a1gh]) -{- rec -} +[ta124, ta125] +[d.Eq_a14x, d.Eq_a14y] +[([ta124, ta125], $d7{-r191,x-}, d.Read_a11Q)] + d.Eq_a14K = d.Eq_a14x + d.Read_a14I = $d1{-r194,x-} ta124 d.Eq_a14K + readsPrec_a19w = + PrelRead.readsPrec{-rkH,p-} (T{-r3K,x-} ta124) d.Read_a14I + d.Eq_a14U = d.Eq_a14y + d.Read_a14S = $d6{-r190,x-} ta125 d.Eq_a14U + readsPrec_a19x = + PrelRead.readsPrec{-rkH,p-} (Y{-r3L,x-} ta125) d.Read_a14S + d.Eq_a14Y = d.Eq_a14y + d.Eq_a14Z = d.Eq_a14x + d.Read_a14W = $d7{-r191,x-} [ta125, ta124] [d.Eq_a14Y, d.Eq_a14Z] + readsPrec_a19y = + PrelRead.readsPrec{-rkH,p-} (X{-r3M,x-} ta125 ta124) d.Read_a14W + readsPrec_a19z = readsPrec_a19A + AbsBinds [] [] [([], readsPrec_a19A, readsPrec_a11U)] + ++_a19C = ++_a19d + >_a19D = >_a19e + lit_a19E = lit_a19f + ==_a19F = ==_a19g + >>=_a19G = >>=_a19h + return_a19H = return_a19i + zero_a19I = zero_a19j + >_a19J = >_a19e + lit_a19K = lit_a19f + ==_a19L = ==_a19g + >>=_a19M = >>=_a19h + return_a19N = return_a19i + zero_a19O = zero_a19j + readsPrec_a11U a_rXk b_rXl + = ++_a19d (X{-r3M,x-} ta124 ta125, PrelBase.String{-rfZ,p-}) + (PrelRead.readParen{-rkX,p-} (X{-r3M,x-} ta124 ta125) a_rXk + >_a19e lit_a19f + \ c_rXn + -> [(C1{-r9,x-}{i} + [ta124, ta125] a1_rXr, + b1_rXs) | + ("C1", d_rXp) <- PrelRead.lex{-rkK,p-} c_rXn, (a1_rXr, b1_rXs) <- readsPrec_a19w PrelBase.I#{-5b,w-}{i} 10# + d_rXp] + b_rXl) + (++_a19C (X{-r3M,x-} ta124 ta125, PrelBase.String{-rfZ,p-}) + (PrelRead.readParen{-rkX,p-} (X{-r3M,x-} ta124 ta125) a_rXk + >_a19D lit_a19E + \ c_rXu + -> [(C2{-r8,x-}{i} + [ta124, ta125] a1_rXy, + b1_rXz) | + ("C2", d_rXw) <- PrelRead.lex{-rkK,p-} c_rXu, (a1_rXy, b1_rXz) <- readsPrec_a19x PrelBase.I#{-5b,w-}{i} 10# + d_rXw] + b_rXl) + (PrelRead.readParen{-rkX,p-} (X{-r3M,x-} ta124 ta125) a_rXk + >_a19J lit_a19K + \ c_rXB + -> [(C3{-rb,x-}{i} + [ta124, ta125] a1_rXF, + b1_rXG) | + ("C3", d_rXD) <- PrelRead.lex{-rkK,p-} c_rXB, (a1_rXF, b1_rXG) <- readsPrec_a19y PrelBase.I#{-5b,w-}{i} 10# + d_rXD] + b_rXl)) + AbsBinds [] [] [([], readList_a19B, readList_a14s)] + readList_a14s = PrelRead.readList__{-rhB,p-} + (X{-r3M,x-} ta124 ta125) readsPrec_a19z PrelBase.I#{-5b,w-}{i} 0# + d.Read_a11Q = ({-dict-} [] [readsPrec_a19A, readList_a19B]) AbsBinds -[a{-a1ah-}, b{-a1ai-}] -[d.Eq_a1aM, d.Eq_a1aN] -[([a{-a1ah-}, b{-a1ai-}], $d7{-r1gl,x-}, d.Read_a18a)] - d.Eq_a1b3 = - d.Eq_a1aM - d.Read_a1b1 = - $d1{-r1gw,x-} - a{-a1ah-} - d.Eq_a1b3 - readsPrec_a1gv = - PrelRead.readsPrec{-rlS,p-} - (T{-r3L,x-} a{-a1ah-}) - d.Read_a1b1 - d.Eq_a1be = - d.Eq_a1aN - d.Read_a1bc = - $d6{-r1gg,x-} - b{-a1ai-} - d.Eq_a1be - readsPrec_a1gu = - PrelRead.readsPrec{-rlS,p-} - (Y{-r3M,x-} b{-a1ai-}) - d.Read_a1bc - d.Eq_a1bi = - d.Eq_a1aN - d.Eq_a1bj = - d.Eq_a1aM - d.Read_a1bg = - $d7{-r1gl,x-} - [b{-a1ai-}, a{-a1ah-}] - [d.Eq_a1bi, d.Eq_a1bj] - readsPrec_a1gt = - PrelRead.readsPrec{-rlS,p-} - (X{-r3N,x-} b{-a1ai-} a{-a1ah-}) - d.Read_a1bg - readsPrec_a1gs = - readsPrec_a1gr - AbsBinds [] [] [([], readsPrec_a1gr, readsPrec_a18d)] - ++_a1gL = - ++_a1g1 - >_a1gK = - >_a1g0 - lit_a1gJ = - lit_a1fZ - ==_a1gI = - ==_a1fY - lit_a1gH = - lit_a1fX - >>=_a1gG = - >>=_a1fW - return_a1gF = - return_a1fV - zero_a1gE = - zero_a1fU - >_a1gD = - >_a1g0 - lit_a1gC = - lit_a1fZ - ==_a1gB = - ==_a1fY - lit_a1gA = - lit_a1fX - >>=_a1gz = - >>=_a1fW - return_a1gy = - return_a1fV - zero_a1gx = - zero_a1fU - readsPrec_a18d - a_r13j b_r13l - = ++_a1g1 - (X{-r3N,x-} a{-a1ah-} b{-a1ai-}, PrelBase.String{-rdl,p-}) - (PrelRead.readParen{-rmu,p-} - (X{-r3N,x-} a{-a1ah-} b{-a1ai-}) - a_r13j >_a1g0 lit_a1fZ - \ c_r13n -> [ (C1{-rb,x-}{i} - [a{-a1ah-}, b{-a1ai-}] - a1_r13r, - b1_r13s) | - ("C1", d_r13p) <- PrelRead.lex{-rmh,p-} - c_r13n, (a1_r13r, b1_r13s) <- readsPrec_a1gv - lit_a1fX - d_r13p - ] - b_r13l) - (++_a1gL - (X{-r3N,x-} a{-a1ah-} b{-a1ai-}, PrelBase.String{-rdl,p-}) - (PrelRead.readParen{-rmu,p-} - (X{-r3N,x-} a{-a1ah-} b{-a1ai-}) - a_r13j >_a1gK lit_a1gJ - \ c_r13u -> [ (C2{-ra,x-}{i} - [a{-a1ah-}, b{-a1ai-}] - a1_r13y, - b1_r13z) | - ("C2", d_r13w) <- PrelRead.lex{-rmh,p-} - c_r13u, (a1_r13y, b1_r13z) <- readsPrec_a1gu - lit_a1gH - d_r13w - ] - b_r13l) - (PrelRead.readParen{-rmu,p-} - (X{-r3N,x-} a{-a1ah-} b{-a1ai-}) - a_r13j >_a1gD lit_a1gC - \ c_r13B -> [ (C3{-rd,x-}{i} - [a{-a1ah-}, b{-a1ai-}] - a1_r13F, - b1_r13G) | - ("C3", d_r13D) <- PrelRead.lex{-rmh,p-} - c_r13B, (a1_r13F, b1_r13G) <- readsPrec_a1gt - lit_a1gA - d_r13D - ] - b_r13l)) - AbsBinds [] [] [([], readList_a1gq, readList_a1aH)] - readList_a1aH - = PrelRead.readList__{-rjw,p-} - (X{-r3N,x-} a{-a1ah-} b{-a1ai-}) - readsPrec_a1gs - lit_a1fT - d.Read_a18a = - ({-dict-} [] [readsPrec_a1gr, readList_a1gq]) -{- rec -} +[ta15f] +[d.Eq_a15F] +[([ta15f], $d8{-r192,x-}, d.Show_a157)] + d.Eq_a15N = PrelBase.$d8{-rbj,p-} + d.Eq_a15O = d.Eq_a15F + d.Show_a15L = + $d9{-r193,x-} [PrelBase.Int{-3g,W-}, ta15f] [d.Eq_a15N, d.Eq_a15O] + showsPrec_a19P = + PrelBase.showsPrec{-rfW,p-} (X{-r3M,x-} PrelBase.Int{-3g,W-} ta15f) + d.Show_a15L + showsPrec_a19Q = showsPrec_a19R + AbsBinds [] [] [([], showsPrec_a19R, showsPrec_a15b)] + showsPrec_a15b a_rXO D1{-rd,x-}{i} + = PrelBase.showString{-rgN,p-} "D1" + showsPrec_a15b a_rXQ (D2{-rc,x-}{i} b1_rXR) + = PrelBase.showParen{-rgK,p-} a_rXQ >=_a19k lit_a19l + PrelBase..{-rfC,p-} + [PrelBase.String{-rfZ,p-}, PrelBase.String{-rfZ,p-}, PrelBase.String{-rfZ,p-}] PrelBase.showString{-rgN,p-} "D2 " + showsPrec_a19P PrelBase.I#{-5b,w-}{i} 10# + b1_rXR + AbsBinds [] [] [([], showList_a19S, showList_a15A)] + showList_a15A = PrelBase.showList__{-r3J,p-} + (Y{-r3L,x-} ta15f) showsPrec_a19Q PrelBase.I#{-5b,w-}{i} 0# + d.Show_a157 = ({-dict-} [] [showsPrec_a19R, showList_a19S]) AbsBinds -[b{-a1bz-}] -[d.Eq_a1c4] -[([b{-a1bz-}], $d8{-r1gM,x-}, d.Show_a1bs)] - d.Eq_a1cg = - PrelBase.$d7{-rc5,p-} - d.Eq_a1ch = - d.Eq_a1c4 - d.Show_a1ce = - $d9{-r1gR,x-} - [PrelBase.Int{-3g,p-}, b{-a1bz-}] - [d.Eq_a1cg, d.Eq_a1ch] - showsPrec_a1gQ = - PrelBase.showsPrec{-rdi,p-} - (X{-r3N,x-} PrelBase.Int{-3g,p-} b{-a1bz-}) - d.Show_a1ce - showsPrec_a1gP = - showsPrec_a1gO - AbsBinds [] [] [([], showsPrec_a1gO, showsPrec_a1bv)] - lit_a1gS = - lit_a1fR - showsPrec_a1bv - a_r13N D1{-r6,x-}{i} - = PrelBase.showString{-rhV,p-} - "D1" - showsPrec_a1bv - a_r13Q (D2{-r5,x-}{i} b1_r13S) - = PrelBase.showParen{-rhS,p-} - a_r13Q >=_a1fS lit_a1fR - PrelBase..{-rd1,p-} - [PrelBase.String{-rdl,p-}, PrelBase.String{-rdl,p-}, PrelBase.String{-rdl,p-}] - PrelBase.showString{-rhV,p-} - "D2 " - showsPrec_a1gQ - lit_a1gS b1_r13S - AbsBinds [] [] [([], showList_a1gN, showList_a1bZ)] - showList_a1bZ - = PrelBase.showList__{-r3J,p-} - (Y{-r3M,x-} b{-a1bz-}) - showsPrec_a1gP - lit_a1fQ - d.Show_a1bs = - ({-dict-} [] [showsPrec_a1gO, showList_a1gN]) -{- rec -} +[ta167, ta16a] +[d.Eq_a171, d.Eq_a172] +[([ta167, ta16a], $d9{-r193,x-}, d.Show_a15X)] + d.Eq_a17a = d.Eq_a171 + d.Show_a178 = $d2{-r195,x-} ta167 d.Eq_a17a + showsPrec_a19T = + PrelBase.showsPrec{-rfW,p-} (T{-r3K,x-} ta167) d.Show_a178 + d.Eq_a17e = d.Eq_a172 + d.Show_a17c = $d8{-r192,x-} ta16a d.Eq_a17e + showsPrec_a19U = + PrelBase.showsPrec{-rfW,p-} (Y{-r3L,x-} ta16a) d.Show_a17c + d.Eq_a17i = d.Eq_a172 + d.Eq_a17j = d.Eq_a171 + d.Show_a17g = $d9{-r193,x-} [ta16a, ta167] [d.Eq_a17i, d.Eq_a17j] + showsPrec_a19V = + PrelBase.showsPrec{-rfW,p-} (X{-r3M,x-} ta16a ta167) d.Show_a17g + showsPrec_a19W = showsPrec_a19X + AbsBinds [] [] [([], showsPrec_a19X, showsPrec_a161)] + >=_a19Z = >=_a19m + lit_a1a0 = lit_a19n + >=_a1a1 = >=_a19m + lit_a1a2 = lit_a19n + showsPrec_a161 a_rXZ (C1{-r9,x-}{i} b1_rY0) + = PrelBase.showParen{-rgK,p-} a_rXZ >=_a19m lit_a19n + PrelBase..{-rfC,p-} + [PrelBase.String{-rfZ,p-}, PrelBase.String{-rfZ,p-}, PrelBase.String{-rfZ,p-}] PrelBase.showString{-rgN,p-} "C1 " + showsPrec_a19T PrelBase.I#{-5b,w-}{i} 10# + b1_rY0 + showsPrec_a161 a_rY2 (C2{-r8,x-}{i} b1_rY3) + = PrelBase.showParen{-rgK,p-} a_rY2 >=_a19Z lit_a1a0 + PrelBase..{-rfC,p-} + [PrelBase.String{-rfZ,p-}, PrelBase.String{-rfZ,p-}, PrelBase.String{-rfZ,p-}] PrelBase.showString{-rgN,p-} "C2 " + showsPrec_a19U PrelBase.I#{-5b,w-}{i} 10# + b1_rY3 + showsPrec_a161 a_rY5 (C3{-rb,x-}{i} b1_rY6) + = PrelBase.showParen{-rgK,p-} a_rY5 >=_a1a1 lit_a1a2 + PrelBase..{-rfC,p-} + [PrelBase.String{-rfZ,p-}, PrelBase.String{-rfZ,p-}, PrelBase.String{-rfZ,p-}] PrelBase.showString{-rgN,p-} "C3 " + showsPrec_a19V PrelBase.I#{-5b,w-}{i} 10# + b1_rY6 + AbsBinds [] [] [([], showList_a19Y, showList_a16W)] + showList_a16W = PrelBase.showList__{-r3J,p-} + (X{-r3M,x-} ta167 ta16a) showsPrec_a19W PrelBase.I#{-5b,w-}{i} 0# + d.Show_a15X = ({-dict-} [] [showsPrec_a19X, showList_a19Y]) AbsBinds -[a{-a1cA-}, b{-a1cD-}] -[d.Eq_a1dJ, d.Eq_a1dK] -[([a{-a1cA-}, b{-a1cD-}], $d9{-r1gR,x-}, d.Show_a1cr)] - d.Eq_a1dW = - d.Eq_a1dJ - d.Show_a1dU = - $d2{-r1gZ,x-} - a{-a1cA-} - d.Eq_a1dW - showsPrec_a1gY = - PrelBase.showsPrec{-rdi,p-} - (T{-r3L,x-} a{-a1cA-}) - d.Show_a1dU - d.Eq_a1e0 = - d.Eq_a1dK - d.Show_a1dY = - $d8{-r1gM,x-} - b{-a1cD-} - d.Eq_a1e0 - showsPrec_a1gX = - PrelBase.showsPrec{-rdi,p-} - (Y{-r3M,x-} b{-a1cD-}) - d.Show_a1dY - d.Eq_a1e4 = - d.Eq_a1dK - d.Eq_a1e5 = - d.Eq_a1dJ - d.Show_a1e2 = - $d9{-r1gR,x-} - [b{-a1cD-}, a{-a1cA-}] - [d.Eq_a1e4, d.Eq_a1e5] - showsPrec_a1gW = - PrelBase.showsPrec{-rdi,p-} - (X{-r3N,x-} b{-a1cD-} a{-a1cA-}) - d.Show_a1e2 - showsPrec_a1gV = - showsPrec_a1gU - AbsBinds [] [] [([], showsPrec_a1gU, showsPrec_a1cu)] - lit_a1h6 = - lit_a1fO - >=_a1h5 = - >=_a1fP - lit_a1h4 = - lit_a1fO - lit_a1h3 = - lit_a1fO - >=_a1h2 = - >=_a1fP - lit_a1h1 = - lit_a1fO - lit_a1h0 = - lit_a1fO - showsPrec_a1cu - a_r13Z (C1{-rb,x-}{i} b1_r141) - = PrelBase.showParen{-rhS,p-} - a_r13Z >=_a1fP lit_a1fO - PrelBase..{-rd1,p-} - [PrelBase.String{-rdl,p-}, PrelBase.String{-rdl,p-}, PrelBase.String{-rdl,p-}] - PrelBase.showString{-rhV,p-} - "C1 " - showsPrec_a1gY - lit_a1h6 b1_r141 - showsPrec_a1cu - a_r143 (C2{-ra,x-}{i} b1_r145) - = PrelBase.showParen{-rhS,p-} - a_r143 >=_a1h5 lit_a1h4 - PrelBase..{-rd1,p-} - [PrelBase.String{-rdl,p-}, PrelBase.String{-rdl,p-}, PrelBase.String{-rdl,p-}] - PrelBase.showString{-rhV,p-} - "C2 " - showsPrec_a1gX - lit_a1h3 b1_r145 - showsPrec_a1cu - a_r147 (C3{-rd,x-}{i} b1_r149) - = PrelBase.showParen{-rhS,p-} - a_r147 >=_a1h2 lit_a1h1 - PrelBase..{-rd1,p-} - [PrelBase.String{-rdl,p-}, PrelBase.String{-rdl,p-}, PrelBase.String{-rdl,p-}] - PrelBase.showString{-rhV,p-} - "C3 " - showsPrec_a1gW - lit_a1h0 b1_r149 - AbsBinds [] [] [([], showList_a1gT, showList_a1dE)] - showList_a1dE - = PrelBase.showList__{-r3J,p-} - (X{-r3N,x-} a{-a1cA-} b{-a1cD-}) - showsPrec_a1gV - lit_a1fN - d.Show_a1cr = - ({-dict-} [] [showsPrec_a1gU, showList_a1gT]) -{- rec -} +[ta17y] +[d.Eq_a17H] +[([ta17y], $d1{-r194,x-}, d.Read_a17r)] + d.Read_a17L = d.Read_a17r + $mreadList_a1a3 = + PrelRead.$mreadList{-rkF,p-} (T{-r3K,x-} ta17y) d.Read_a17L + AbsBinds [] [] [([], readsPrec_a1a4, readsPrec_a17v)] + readsPrec_a17v + = IOBase.error{-87,w-} + (PrelBase.Int{-3g,W-} + -> PrelBase.String{-rfZ,p-} + -> [(T{-r3K,x-} ta17y, PrelBase.String{-rfZ,p-})]) "read" + AbsBinds [] [] [([], readList_a1a5, readList_a17E)] + readList_a17E = $mreadList_a1a3 + d.Read_a17r = ({-dict-} [] [readsPrec_a1a4, readList_a1a5]) AbsBinds -[a{-a1ek-}] -[d.Eq_a1es] -[([a{-a1ek-}], $d1{-r1gw,x-}, d.Read_a1ee)] - d.Read_a1ew = - d.Read_a1ee - $mreadList_a1h8 = - PrelRead.$mreadList{-rlO,p-} - (T{-r3L,x-} a{-a1ek-}) - d.Read_a1ew - AbsBinds [] [] [([], readsPrec_a1h7, readsPrec_a1eh)] - readsPrec_a1eh - = IOBase.error{-87,p-} - (PrelBase.Int{-3g,p-} - -> PrelBase.String{-rdl,p-} - -> [(T{-r3L,x-} a{-a1ek-}, PrelBase.String{-rdl,p-})]) - "read" - AbsBinds [] [] [([], readList_a1en, readList_a1ep)] - readList_a1ep - = $mreadList_a1h8 - d.Read_a1ee = - ({-dict-} [] [readsPrec_a1h7, readList_a1en]) -{- rec -} -AbsBinds -[a{-a1eJ-}] -[d.Eq_a1eR] -[([a{-a1eJ-}], $d2{-r1gZ,x-}, d.Show_a1eD)] - d.Show_a1eV = - d.Show_a1eD - $mshowList_a1ha = - PrelBase.$mshowList{-rcA,p-} - (T{-r3L,x-} a{-a1eJ-}) - d.Show_a1eV - AbsBinds [] [] [([], showsPrec_a1h9, showsPrec_a1eG)] - showsPrec_a1eG - = IOBase.error{-87,p-} - (PrelBase.Int{-3g,p-} - -> T{-r3L,x-} a{-a1eJ-} - -> PrelBase.String{-rdl,p-} - -> PrelBase.String{-rdl,p-}) - "show" - AbsBinds [] [] [([], showList_a1eM, showList_a1eO)] - showList_a1eO - = $mshowList_a1ha - d.Show_a1eD = - ({-dict-} [] [showsPrec_a1h9, showList_a1eM]) -{- nonrec -} -d.MonadPlus_a1eY = - PrelBase.$d22{-rbr,p-} -++_a1gd = - PrelBase.++{-rfN,p-} - PrelBase.[]{-3j,p-} - d.MonadPlus_a1eY -d.Eq_a1f3 = - PrelBase.$d33{-rbD,p-} -d.Eq_a1f1 = - PrelBase.$d27{-rbw,p-} - PrelBase.Char{-38,p-} - d.Eq_a1f3 -==_a1gc = - PrelBase.=={-8Y,p-} - [PrelBase.Char{-38,p-}] - d.Eq_a1f1 -d.Monad_a1f6 = - PrelBase.$d24{-rbt,p-} ->>=_a1gb = - PrelBase.>>={-811,p-} - PrelBase.[]{-3j,p-} - d.Monad_a1f6 -d.Monad_a1f9 = - d.Monad_a1f6 -return_a1ga = - PrelBase.return{-816,p-} - PrelBase.[]{-3j,p-} - d.Monad_a1f9 -d.MonadZero_a1fb = - PrelBase.$d23{-rbs,p-} -zero_a1g9 = - PrelBase.zero{-810,p-} - PrelBase.[]{-3j,p-} - d.MonadZero_a1fb -d.Ord_a1fe = - PrelBase.$d6{-rc4,p-} ->_a1g8 = - PrelBase.>{-rdf,p-} - PrelBase.Int{-3g,p-} - d.Ord_a1fe -d.Num_a1fi = - PrelBase.$d3{-rbz,p-} -fromInt_a1g7 = - PrelBase.fromInt{-8R,p-} - PrelBase.Int{-3g,p-} - d.Num_a1fi -lit_a1g6 = - fromInt_a1g7 - PrelBase.I#{-5b,p-}{i} - 9# -fromInt_a1g5 = - fromInt_a1g7 -lit_a1g4 = - fromInt_a1g5 - PrelBase.I#{-5b,p-}{i} - 10# -fromInt_a1g3 = - fromInt_a1g7 -lit_a1g2 = - fromInt_a1g3 - PrelBase.I#{-5b,p-}{i} - 0# -++_a1g1 = - ++_a1gd ->_a1g0 = - >_a1g8 -lit_a1fZ = - lit_a1g6 -==_a1fY = - ==_a1gc -lit_a1fX = - lit_a1g4 ->>=_a1fW = - >>=_a1gb -return_a1fV = - return_a1ga -zero_a1fU = - zero_a1g9 -lit_a1fT = - lit_a1g2 -d.Ord_a1fn = - d.Ord_a1fe ->=_a1fS = - PrelBase.>={-8Z,p-} - PrelBase.Int{-3g,p-} - d.Ord_a1fn -lit_a1fR = - lit_a1g4 -lit_a1fQ = - lit_a1g2 ->=_a1fP = - >=_a1fS -lit_a1fO = - lit_a1g4 -lit_a1fN = - lit_a1g2 +[ta17Z] +[d.Eq_a188] +[([ta17Z], $d2{-r195,x-}, d.Show_a17S)] + d.Show_a18c = d.Show_a17S + $mshowList_a1a6 = + PrelBase.$mshowList{-rfz,p-} (T{-r3K,x-} ta17Z) d.Show_a18c + AbsBinds [] [] [([], showsPrec_a1a7, showsPrec_a17W)] + showsPrec_a17W + = IOBase.error{-87,w-} + (PrelBase.Int{-3g,W-} + -> T{-r3K,x-} ta17Z + -> PrelBase.String{-rfZ,p-} + -> PrelBase.String{-rfZ,p-}) "show" + AbsBinds [] [] [([], showList_a1a8, showList_a185)] + showList_a185 = $mshowList_a1a6 + d.Show_a17S = ({-dict-} [] [showsPrec_a1a7, showList_a1a8]) +d.MonadPlus_a18f = PrelBase.$d23{-raE,p-} +++_a196 = PrelBase.++{-rfK,p-} PrelBase.[]{-3j,W-} d.MonadPlus_a18f +d.Eq_a18k = PrelBase.$d34{-raQ,p-} +d.Eq_a18i = PrelBase.$d28{-raJ,p-} PrelBase.Char{-38,W-} d.Eq_a18k +==_a197 = PrelBase.=={-8Y,p-} [PrelBase.Char{-38,W-}] d.Eq_a18i +d.Monad_a18n = PrelBase.$d25{-raG,p-} +>>=_a198 = PrelBase.>>={-811,p-} PrelBase.[]{-3j,W-} d.Monad_a18n +d.Monad_a18q = d.Monad_a18n +return_a199 = + PrelBase.return{-816,p-} PrelBase.[]{-3j,W-} d.Monad_a18q +d.MonadZero_a18s = PrelBase.$d24{-raF,p-} +zero_a19a = + PrelBase.zero{-810,p-} PrelBase.[]{-3j,W-} d.MonadZero_a18s +d.Ord_a18v = PrelBase.$d7{-rbi,p-} +>_a19b = PrelBase.>{-rfT,p-} PrelBase.Int{-3g,W-} d.Ord_a18v +lit_a19c = PrelBase.I#{-5b,w-}{i} 9# +++_a19d = ++_a196 +>_a19e = >_a19b +lit_a19f = lit_a19c +==_a19g = ==_a197 +>>=_a19h = >>=_a198 +return_a19i = return_a199 +zero_a19j = zero_a19a +d.Ord_a18y = d.Ord_a18v +>=_a19k = PrelBase.>={-8Z,p-} PrelBase.Int{-3g,W-} d.Ord_a18y +lit_a19l = PrelBase.I#{-5b,w-}{i} 10# +>=_a19m = >=_a19k +lit_a19n = lit_a19l ghc: module version changed to 1; reason: no old .hi file +_interface_ ShouldSucceed 1 +_instance_modules_ +ArrBase IO PrelNum +_usages_ +PrelBase 1 :: $d1 1 $d12 1 $d15 1 $d16 1 $d2 1 $d22 1 $d23 1 $d24 1 $d25 1 $d27 1 $d28 1 $d3 1 $d33 1 $d34 1 $d35 1 $d38 1 $d39 1 $d4 1 $d40 1 $d42 1 $d43 1 $d45 1 $d46 1 $d47 1 $d50 1 $d51 1 $d52 1 $d55 1 $d56 1 $d7 1 $d8 1 $d9 1 $m- 1 $m/= 1 $m< 1 $m<= 1 $m> 1 $m>= 1 $m>> 1 $mcompare 1 $mfromInt 1 $mmax 1 $mmin 1 $mshowList 1 . 1 showList__ 1 showParen 1 showSpace 1 showString 1 Eq 1 Eval 1 Monad 1 MonadPlus 1 MonadZero 1 Num 1 Ord 1 Ordering 1 Show 1 ShowS 1 String 1; +PrelNum 1 :: $d10 1 $d16 1 $d17 1 $d18 1 $d29 1 $d33 1 $d34 1 $d35 1; +PrelRead 1 :: $d10 1 $d11 1 $d14 1 $d15 1 $d16 1 $d4 1 $d5 1 $d6 1 $d8 1 $mreadList 1 lex 1 readList__ 1 readParen 1 Read 1 ReadS 1; +PrelTup 1 :: $d13 1 $d4 1 $d49 1 $d9 1; +_exports_ +ShouldSucceed T(E1) X(C1 C2 C3) Y(D1 D2); +_instances_ +instance _forall_ [a] {PrelBase.Eq a} => {PrelRead.Read (T a)} = $d1; +instance _forall_ [a] {PrelBase.Eq a} => {PrelBase.Show (T a)} = $d2; +instance _forall_ [a] => {PrelBase.Eval (T a)} = $d3; +instance _forall_ [b] => {PrelBase.Eval (Y b)} = $d4; +instance _forall_ [a b] => {PrelBase.Eval (X a b)} = $d5; +instance _forall_ [b] {PrelBase.Eq b} => {PrelRead.Read (Y b)} = $d6; +instance _forall_ [a b] {PrelBase.Eq a, PrelBase.Eq b} => {PrelRead.Read (X a b)} = $d7; +instance _forall_ [b] {PrelBase.Eq b} => {PrelBase.Show (Y b)} = $d8; +instance _forall_ [a b] {PrelBase.Eq a, PrelBase.Eq b} => {PrelBase.Show (X a b)} = $d9; +_declarations_ +1 $d1 _:_ _forall_ [a] {PrelBase.Eq a} => {PrelRead.Read (T a)} ;; +1 $d2 _:_ _forall_ [a] {PrelBase.Eq a} => {PrelBase.Show (T a)} ;; +1 $d3 _:_ _forall_ [a] => {PrelBase.Eval (T a)} ;; +1 $d4 _:_ _forall_ [b] => {PrelBase.Eval (Y b)} ;; +1 $d5 _:_ _forall_ [a b] => {PrelBase.Eval (X a b)} ;; +1 $d6 _:_ _forall_ [b] {PrelBase.Eq b} => {PrelRead.Read (Y b)} ;; +1 $d7 _:_ _forall_ [a b] {PrelBase.Eq a, PrelBase.Eq b} => {PrelRead.Read (X a b)} ;; +1 $d8 _:_ _forall_ [b] {PrelBase.Eq b} => {PrelBase.Show (Y b)} ;; +1 $d9 _:_ _forall_ [a b] {PrelBase.Eq a, PrelBase.Eq b} => {PrelBase.Show (X a b)} ;; +1 data T a = E1 ; +1 data X a b = C1 (T a) | C2 (Y b) | C3 (X b a) ; +1 data Y b = D1 | D2 (X PrelBase.Int b) ; diff --git a/ghc/tests/deriving/should_compile/drv002.stderr b/ghc/tests/deriving/should_compile/drv002.stderr index 0a9d5ef..9668c0d 100644 --- a/ghc/tests/deriving/should_compile/drv002.stderr +++ b/ghc/tests/deriving/should_compile/drv002.stderr @@ -2,302 +2,175 @@ ================================================================================ Typechecked: -{- nonrec -} -{- nonrec -} -E1{-r3B,x-}{i} = - _/\_ a{-r3t-} -> - E1{-r3B,x-}{i} - {_@_ a{-r3t-}} -{- nonrec -} +E1{-r3D,x-}{i} = _/\_ a_tr3t -> E1{-r3D,x-}{i} {_@_ a_tr3t} C1{-r6,x-}{i} = - _/\_ a{-r3v-} b{-r3w-} -> \ tpl_B1 -> - C1{-r6,x-}{i} - {_@_ a{-r3v-} _@_ b{-r3w-} tpl_B1} + _/\_ a_tr3v b_tr3w -> \ tpl_B1 -> + C1{-r6,x-}{i} {_@_ a_tr3v _@_ b_tr3w tpl_B1} C2{-r5,x-}{i} = - _/\_ a{-r3v-} b{-r3w-} -> \ tpl_B1 -> - C2{-r5,x-}{i} - {_@_ a{-r3v-} _@_ b{-r3w-} tpl_B1} -{- rec -} -AbsBinds [a{-a1a9-}] [] [([a{-a1a9-}], $d3{-r1ag,x-}, d.Eval_a14Q)] - d.Eval_a14Q = - ({-dict-} [] []) -{- rec -} + _/\_ a_tr3v b_tr3w -> \ tpl_B1 -> + C2{-r5,x-}{i} {_@_ a_tr3v _@_ b_tr3w tpl_B1} +AbsBinds [ta13t] [] [([ta13t], $d3{-r13E,x-}, d.Eval_aYx)] + d.Eval_aYx = ({-dict-} [] []) AbsBinds -[a{-a1aa-}, b{-a1ab-}] +[ta13u, ta13v] [] -[([a{-a1aa-}, b{-a1ab-}], $d4{-r1aw,x-}, d.Eval_a14X)] - d.Eval_a14X = - ({-dict-} [] []) -{- rec -} +[([ta13u, ta13v], $d4{-r13F,x-}, d.Eval_aYE)] + d.Eval_aYE = ({-dict-} [] []) AbsBinds -[a{-a16r-}, b{-a16s-}] -[d.Eq_a16W] -[([a{-a16r-}, b{-a16s-}], $d5{-r1ax,x-}, d.Read_a154)] - d.Eq_a17c = - d.Eq_a16W - d.Read_a17a = - $d1{-r1aD,x-} - a{-a16r-} - d.Eq_a17c - readsPrec_a1aC = - PrelRead.readsPrec{-r62,p-} - (T{-r3C,x-} a{-a16r-}) - d.Read_a17a - d.Eq_a17p = - d.Eq_a16W - d.Eq_a17n = - PrelBase.$d27{-rf7,p-} - a{-a16r-} - d.Eq_a17p - d.Read_a17l = - $d5{-r1ax,x-} - [[a{-a16r-}], [b{-a16s-}]] - d.Eq_a17n - readsPrec_a1aB = - PrelRead.readsPrec{-r62,p-} - (Z{-r3D,x-} [a{-a16r-}] [b{-a16s-}]) - d.Read_a17l - readsPrec_a1aA = - readsPrec_a1az - AbsBinds [] [] [([], readsPrec_a1az, readsPrec_a157)] - >_a1aK = - >_a1au - lit_a1aJ = - lit_a1as - ==_a1aI = - ==_a1ar - lit_a1aH = - lit_a1ap - >>=_a1aG = - >>=_a1ao - return_a1aF = - return_a1an - zero_a1aE = - zero_a1am - readsPrec_a157 - a_r12I b_r12K - = ++_a1av - (Z{-r3D,x-} a{-a16r-} b{-a16s-}, PrelBase.String{-r7r,p-}) - (PrelRead.readParen{-r6E,p-} - (Z{-r3D,x-} a{-a16r-} b{-a16s-}) - a_r12I >_a1au lit_a1as - \ c_r12M -> [ (C1{-r6,x-}{i} - [a{-a16r-}, b{-a16s-}] - a1_r12Q, - b1_r12R) | - ("C1", d_r12O) <- PrelRead.lex{-r6r,p-} - c_r12M, (a1_r12Q, b1_r12R) <- readsPrec_a1aC - lit_a1ap - d_r12O - ] - b_r12K) - (PrelRead.readParen{-r6E,p-} - (Z{-r3D,x-} a{-a16r-} b{-a16s-}) - a_r12I >_a1aK lit_a1aJ - \ c_r12T -> [ (C2{-r5,x-}{i} - [a{-a16r-}, b{-a16s-}] - a1_r12X, - b1_r12Y) | - ("C2", d_r12V) <- PrelRead.lex{-r6r,p-} - c_r12T, (a1_r12X, b1_r12Y) <- readsPrec_a1aB - lit_a1aH - d_r12V - ] - b_r12K) - AbsBinds [] [] [([], readList_a1ay, readList_a16R)] - readList_a16R - = PrelRead.readList__{-r3A,p-} - (Z{-r3D,x-} a{-a16r-} b{-a16s-}) - readsPrec_a1aA - lit_a1ak - d.Read_a154 = - ({-dict-} [] [readsPrec_a1az, readList_a1ay]) -{- rec -} +[taYZ, taZ0] +[d.Eq_a10G] +[([taYZ, taZ0], $d5{-r13G,x-}, d.Read_aYL)] + d.Eq_a10S = d.Eq_a10G + d.Read_a10Q = $d1{-r13I,x-} taYZ d.Eq_a10S + readsPrec_a13T = + PrelRead.readsPrec{-r6M,p-} (T{-r3B,x-} taYZ) d.Read_a10Q + d.Eq_a114 = d.Eq_a10G + d.Eq_a112 = PrelBase.$d28{-re2,p-} taYZ d.Eq_a114 + d.Read_a110 = $d5{-r13G,x-} [[taYZ], [taZ0]] d.Eq_a112 + readsPrec_a13U = + PrelRead.readsPrec{-r6M,p-} (Z{-r3C,x-} [taYZ] [taZ0]) d.Read_a110 + readsPrec_a13V = readsPrec_a13W + AbsBinds [] [] [([], readsPrec_a13W, readsPrec_aYP)] + >_a13Y = >_a13L + lit_a13Z = lit_a13M + ==_a140 = ==_a13N + >>=_a141 = >>=_a13O + return_a142 = return_a13P + zero_a143 = zero_a13Q + readsPrec_aYP a_rWJ b_rWK + = ++_a13K (Z{-r3C,x-} taYZ taZ0, PrelBase.String{-r79,p-}) + (PrelRead.readParen{-r72,p-} (Z{-r3C,x-} taYZ taZ0) a_rWJ + >_a13L lit_a13M + \ c_rWM + -> [(C1{-r6,x-}{i} + [taYZ, taZ0] a1_rWQ, + b1_rWR) | + ("C1", d_rWO) <- PrelRead.lex{-r6P,p-} c_rWM, (a1_rWQ, b1_rWR) <- readsPrec_a13T PrelBase.I#{-5b,w-}{i} 10# + d_rWO] + b_rWK) + (PrelRead.readParen{-r72,p-} (Z{-r3C,x-} taYZ taZ0) a_rWJ + >_a13Y lit_a13Z + \ c_rWT + -> [(C2{-r5,x-}{i} + [taYZ, taZ0] a1_rWX, + b1_rWY) | + ("C2", d_rWV) <- PrelRead.lex{-r6P,p-} c_rWT, (a1_rWX, b1_rWY) <- readsPrec_a13U PrelBase.I#{-5b,w-}{i} 10# + d_rWV] + b_rWK) + AbsBinds [] [] [([], readList_a13X, readList_a10B)] + readList_a10B = PrelRead.readList__{-r3A,p-} + (Z{-r3C,x-} taYZ taZ0) readsPrec_a13V PrelBase.I#{-5b,w-}{i} 0# + d.Read_aYL = ({-dict-} [] [readsPrec_a13W, readList_a13X]) AbsBinds -[a{-a17H-}, b{-a17K-}] -[d.Eq_a18v] -[([a{-a17H-}, b{-a17K-}], $d6{-r1aL,x-}, d.Show_a17y)] - d.Eq_a18H = - d.Eq_a18v - d.Show_a18F = - $d2{-r1aR,x-} - a{-a17H-} - d.Eq_a18H - showsPrec_a1aQ = - PrelBase.showsPrec{-rgT,p-} - (T{-r3C,x-} a{-a17H-}) - d.Show_a18F - d.Eq_a18N = - d.Eq_a18v - d.Eq_a18L = - PrelBase.$d27{-rf7,p-} - a{-a17H-} - d.Eq_a18N - d.Show_a18J = - $d6{-r1aL,x-} - [[a{-a17H-}], [b{-a17K-}]] - d.Eq_a18L - showsPrec_a1aP = - PrelBase.showsPrec{-rgT,p-} - (Z{-r3D,x-} [a{-a17H-}] [b{-a17K-}]) - d.Show_a18J - showsPrec_a1aO = - showsPrec_a1aN - AbsBinds [] [] [([], showsPrec_a1aN, showsPrec_a17B)] - lit_a1aV = - lit_a1ai - >=_a1aU = - >=_a1aj - lit_a1aT = - lit_a1ai - lit_a1aS = - lit_a1ai - showsPrec_a17B - a_r135 (C1{-r6,x-}{i} b1_r137) - = PrelBase.showParen{-rlt,p-} - a_r135 >=_a1aj lit_a1ai - PrelBase..{-rgC,p-} - [PrelBase.String{-r7r,p-}, PrelBase.String{-r7r,p-}, PrelBase.String{-r7r,p-}] - PrelBase.showString{-rlw,p-} - "C1 " - showsPrec_a1aQ - lit_a1aV b1_r137 - showsPrec_a17B - a_r139 (C2{-r5,x-}{i} b1_r13b) - = PrelBase.showParen{-rlt,p-} - a_r139 >=_a1aU lit_a1aT - PrelBase..{-rgC,p-} - [PrelBase.String{-r7r,p-}, PrelBase.String{-r7r,p-}, PrelBase.String{-r7r,p-}] - PrelBase.showString{-rlw,p-} - "C2 " - showsPrec_a1aP - lit_a1aS b1_r13b - AbsBinds [] [] [([], showList_a1aM, showList_a18q)] - showList_a18q - = PrelBase.showList__{-rlr,p-} - (Z{-r3D,x-} a{-a17H-} b{-a17K-}) - showsPrec_a1aO - lit_a1ah - d.Show_a17y = - ({-dict-} [] [showsPrec_a1aN, showList_a1aM]) -{- rec -} +[ta11m, ta11p] +[d.Eq_a120] +[([ta11m, ta11p], $d6{-r13H,x-}, d.Show_a11c)] + d.Eq_a128 = d.Eq_a120 + d.Show_a126 = $d2{-r13J,x-} ta11m d.Eq_a128 + showsPrec_a144 = + PrelBase.showsPrec{-rjf,p-} (T{-r3B,x-} ta11m) d.Show_a126 + d.Eq_a12e = d.Eq_a120 + d.Eq_a12c = PrelBase.$d28{-re2,p-} ta11m d.Eq_a12e + d.Show_a12a = $d6{-r13H,x-} [[ta11m], [ta11p]] d.Eq_a12c + showsPrec_a145 = + PrelBase.showsPrec{-rjf,p-} (Z{-r3C,x-} [ta11m] [ta11p]) + d.Show_a12a + showsPrec_a146 = showsPrec_a147 + AbsBinds [] [] [([], showsPrec_a147, showsPrec_a11g)] + >=_a149 = >=_a13R + lit_a14a = lit_a13S + showsPrec_a11g a_rX6 (C1{-r6,x-}{i} b1_rX7) + = PrelBase.showParen{-rk3,p-} a_rX6 >=_a13R lit_a13S + PrelBase..{-riV,p-} + [PrelBase.String{-r79,p-}, PrelBase.String{-r79,p-}, PrelBase.String{-r79,p-}] PrelBase.showString{-rk6,p-} "C1 " + showsPrec_a144 PrelBase.I#{-5b,w-}{i} 10# + b1_rX7 + showsPrec_a11g a_rX9 (C2{-r5,x-}{i} b1_rXa) + = PrelBase.showParen{-rk3,p-} a_rX9 >=_a149 lit_a14a + PrelBase..{-riV,p-} + [PrelBase.String{-r79,p-}, PrelBase.String{-r79,p-}, PrelBase.String{-r79,p-}] PrelBase.showString{-rk6,p-} "C2 " + showsPrec_a145 PrelBase.I#{-5b,w-}{i} 10# + b1_rXa + AbsBinds [] [] [([], showList_a148, showList_a11V)] + showList_a11V = PrelBase.showList__{-rk1,p-} + (Z{-r3C,x-} ta11m ta11p) showsPrec_a146 PrelBase.I#{-5b,w-}{i} 0# + d.Show_a11c = ({-dict-} [] [showsPrec_a147, showList_a148]) AbsBinds -[a{-a191-}] -[d.Eq_a199] -[([a{-a191-}], $d1{-r1aD,x-}, d.Read_a18V)] - d.Read_a19d = - d.Read_a18V - $mreadList_a1aX = - PrelRead.$mreadList{-r5Y,p-} - (T{-r3C,x-} a{-a191-}) - d.Read_a19d - AbsBinds [] [] [([], readsPrec_a1aW, readsPrec_a18Y)] - readsPrec_a18Y - = IOBase.error{-87,p-} - (PrelBase.Int{-3g,p-} - -> PrelBase.String{-r7r,p-} - -> [(T{-r3C,x-} a{-a191-}, PrelBase.String{-r7r,p-})]) - "read" - AbsBinds [] [] [([], readList_a194, readList_a196)] - readList_a196 - = $mreadList_a1aX - d.Read_a18V = - ({-dict-} [] [readsPrec_a1aW, readList_a194]) -{- rec -} +[ta12s] +[d.Eq_a12B] +[([ta12s], $d1{-r13I,x-}, d.Read_a12l)] + d.Read_a12F = d.Read_a12l + $mreadList_a14b = + PrelRead.$mreadList{-r6K,p-} (T{-r3B,x-} ta12s) d.Read_a12F + AbsBinds [] [] [([], readsPrec_a14c, readsPrec_a12p)] + readsPrec_a12p + = IOBase.error{-87,w-} + (PrelBase.Int{-3g,W-} + -> PrelBase.String{-r79,p-} + -> [(T{-r3B,x-} ta12s, PrelBase.String{-r79,p-})]) "read" + AbsBinds [] [] [([], readList_a14d, readList_a12y)] + readList_a12y = $mreadList_a14b + d.Read_a12l = ({-dict-} [] [readsPrec_a14c, readList_a14d]) AbsBinds -[a{-a19q-}] -[d.Eq_a19y] -[([a{-a19q-}], $d2{-r1aR,x-}, d.Show_a19k)] - d.Show_a19C = - d.Show_a19k - $mshowList_a1aZ = - PrelBase.$mshowList{-rgb,p-} - (T{-r3C,x-} a{-a19q-}) - d.Show_a19C - AbsBinds [] [] [([], showsPrec_a1aY, showsPrec_a19n)] - showsPrec_a19n - = IOBase.error{-87,p-} - (PrelBase.Int{-3g,p-} - -> T{-r3C,x-} a{-a19q-} - -> PrelBase.String{-r7r,p-} - -> PrelBase.String{-r7r,p-}) - "show" - AbsBinds [] [] [([], showList_a19t, showList_a19v)] - showList_a19v - = $mshowList_a1aZ - d.Show_a19k = - ({-dict-} [] [showsPrec_a1aY, showList_a19t]) -{- nonrec -} -d.MonadPlus_a19F = - PrelBase.$d22{-rf2,p-} -++_a1av = - PrelBase.++{-rjn,p-} - PrelBase.[]{-3j,p-} - d.MonadPlus_a19F -d.Ord_a19I = - PrelBase.$d6{-rfF,p-} ->_a1au = - PrelBase.>{-rgQ,p-} - PrelBase.Int{-3g,p-} - d.Ord_a19I -d.Num_a19M = - PrelBase.$d3{-rfa,p-} -fromInt_a1at = - PrelBase.fromInt{-8R,p-} - PrelBase.Int{-3g,p-} - d.Num_a19M -lit_a1as = - fromInt_a1at - PrelBase.I#{-5b,p-}{i} - 9# -d.Eq_a19R = - PrelBase.$d33{-rfe,p-} -d.Eq_a19P = - PrelBase.$d27{-rf7,p-} - PrelBase.Char{-38,p-} - d.Eq_a19R -==_a1ar = - PrelBase.=={-8Y,p-} - [PrelBase.Char{-38,p-}] - d.Eq_a19P -fromInt_a1aq = - fromInt_a1at -lit_a1ap = - fromInt_a1aq - PrelBase.I#{-5b,p-}{i} - 10# -d.Monad_a19V = - PrelBase.$d24{-rf4,p-} ->>=_a1ao = - PrelBase.>>={-811,p-} - PrelBase.[]{-3j,p-} - d.Monad_a19V -d.Monad_a19Y = - d.Monad_a19V -return_a1an = - PrelBase.return{-816,p-} - PrelBase.[]{-3j,p-} - d.Monad_a19Y -d.MonadZero_a1a0 = - PrelBase.$d23{-rf3,p-} -zero_a1am = - PrelBase.zero{-810,p-} - PrelBase.[]{-3j,p-} - d.MonadZero_a1a0 -fromInt_a1al = - fromInt_a1at -lit_a1ak = - fromInt_a1al - PrelBase.I#{-5b,p-}{i} - 0# -d.Ord_a1a4 = - d.Ord_a19I ->=_a1aj = - PrelBase.>={-8Z,p-} - PrelBase.Int{-3g,p-} - d.Ord_a1a4 -lit_a1ai = - lit_a1ap -lit_a1ah = - lit_a1ak +[ta12T] +[d.Eq_a132] +[([ta12T], $d2{-r13J,x-}, d.Show_a12M)] + d.Show_a136 = d.Show_a12M + $mshowList_a14e = + PrelBase.$mshowList{-riS,p-} (T{-r3B,x-} ta12T) d.Show_a136 + AbsBinds [] [] [([], showsPrec_a14f, showsPrec_a12Q)] + showsPrec_a12Q + = IOBase.error{-87,w-} + (PrelBase.Int{-3g,W-} + -> T{-r3B,x-} ta12T + -> PrelBase.String{-r79,p-} + -> PrelBase.String{-r79,p-}) "show" + AbsBinds [] [] [([], showList_a14g, showList_a12Z)] + showList_a12Z = $mshowList_a14e + d.Show_a12M = ({-dict-} [] [showsPrec_a14f, showList_a14g]) +d.MonadPlus_a139 = PrelBase.$d23{-rdX,p-} +++_a13K = PrelBase.++{-rj3,p-} PrelBase.[]{-3j,W-} d.MonadPlus_a139 +d.Ord_a13c = PrelBase.$d7{-reB,p-} +>_a13L = PrelBase.>{-rjc,p-} PrelBase.Int{-3g,W-} d.Ord_a13c +lit_a13M = PrelBase.I#{-5b,w-}{i} 9# +d.Eq_a13h = PrelBase.$d34{-re9,p-} +d.Eq_a13f = PrelBase.$d28{-re2,p-} PrelBase.Char{-38,W-} d.Eq_a13h +==_a13N = PrelBase.=={-8Y,p-} [PrelBase.Char{-38,W-}] d.Eq_a13f +d.Monad_a13k = PrelBase.$d25{-rdZ,p-} +>>=_a13O = PrelBase.>>={-811,p-} PrelBase.[]{-3j,W-} d.Monad_a13k +d.Monad_a13n = d.Monad_a13k +return_a13P = + PrelBase.return{-816,p-} PrelBase.[]{-3j,W-} d.Monad_a13n +d.MonadZero_a13p = PrelBase.$d24{-rdY,p-} +zero_a13Q = + PrelBase.zero{-810,p-} PrelBase.[]{-3j,W-} d.MonadZero_a13p +d.Ord_a13s = d.Ord_a13c +>=_a13R = PrelBase.>={-8Z,p-} PrelBase.Int{-3g,W-} d.Ord_a13s +lit_a13S = PrelBase.I#{-5b,w-}{i} 10# ghc: module version changed to 1; reason: no old .hi file +_interface_ ShouldSucceed 1 +_instance_modules_ +ArrBase IO PrelNum +_usages_ +PrelBase 1 :: $d1 1 $d12 1 $d15 1 $d16 1 $d2 1 $d22 1 $d23 1 $d24 1 $d25 1 $d27 1 $d28 1 $d3 1 $d33 1 $d34 1 $d35 1 $d38 1 $d39 1 $d4 1 $d40 1 $d42 1 $d43 1 $d45 1 $d46 1 $d47 1 $d50 1 $d51 1 $d52 1 $d55 1 $d56 1 $d7 1 $d8 1 $d9 1 $m- 1 $m/= 1 $m< 1 $m<= 1 $m> 1 $m>= 1 $m>> 1 $mcompare 1 $mfromInt 1 $mmax 1 $mmin 1 $mshowList 1 . 1 showList__ 1 showParen 1 showSpace 1 showString 1 Eq 1 Eval 1 Monad 1 MonadPlus 1 MonadZero 1 Num 1 Ord 1 Ordering 1 Show 1 ShowS 1 String 1; +PrelNum 1 :: $d10 1 $d16 1 $d17 1 $d18 1 $d29 1 $d33 1 $d34 1 $d35 1; +PrelRead 1 :: $d10 1 $d11 1 $d14 1 $d15 1 $d16 1 $d4 1 $d5 1 $d6 1 $d8 1 $mreadList 1 lex 1 readList__ 1 readParen 1 Read 1 ReadS 1; +PrelTup 1 :: $d13 1 $d4 1 $d49 1 $d9 1; +_exports_ +ShouldSucceed T(E1) Z(C1 C2); +_instances_ +instance _forall_ [a] {PrelBase.Eq a} => {PrelRead.Read (T a)} = $d1; +instance _forall_ [a] {PrelBase.Eq a} => {PrelBase.Show (T a)} = $d2; +instance _forall_ [a] => {PrelBase.Eval (T a)} = $d3; +instance _forall_ [a b] => {PrelBase.Eval (Z a b)} = $d4; +instance _forall_ [a b] {PrelBase.Eq a} => {PrelRead.Read (Z a b)} = $d5; +instance _forall_ [a b] {PrelBase.Eq a} => {PrelBase.Show (Z a b)} = $d6; +_declarations_ +1 $d1 _:_ _forall_ [a] {PrelBase.Eq a} => {PrelRead.Read (T a)} ;; +1 $d2 _:_ _forall_ [a] {PrelBase.Eq a} => {PrelBase.Show (T a)} ;; +1 $d3 _:_ _forall_ [a] => {PrelBase.Eval (T a)} ;; +1 $d4 _:_ _forall_ [a b] => {PrelBase.Eval (Z a b)} ;; +1 $d5 _:_ _forall_ [a b] {PrelBase.Eq a} => {PrelRead.Read (Z a b)} ;; +1 $d6 _:_ _forall_ [a b] {PrelBase.Eq a} => {PrelBase.Show (Z a b)} ;; +1 data T a = E1 ; +1 data Z a b = C1 (T a) | C2 (Z [a] [b]) ; diff --git a/ghc/tests/deriving/should_compile/drv003.stderr b/ghc/tests/deriving/should_compile/drv003.stderr index 592f2e6..fac639a 100644 --- a/ghc/tests/deriving/should_compile/drv003.stderr +++ b/ghc/tests/deriving/should_compile/drv003.stderr @@ -1,184 +1,125 @@ + +drv003.hs:15: No explicit method nor default method for `PrelBase.==' + in an instance declaration for `PrelBase.Eq' + +drv003.hs:12: No explicit method nor default method for `PrelBase.==' + in an instance declaration for `PrelBase.Eq' ================================================================================ Typechecked: -{- nonrec -} -MkBar{-r3E,x-}{i} = - _/\_ a{-r3u-} -> \ tpl_B1 tpl_B2 -> - MkBar{-r3E,x-}{i} - {_@_ a{-r3u-} tpl_B1 tpl_B2} -{- nonrec -} -MkFoo{-r3G,x-}{i} = - _/\_ a{-r3z-} -> \ tpl_B1 tpl_B2 -> - MkFoo{-r3G,x-}{i} - {_@_ a{-r3z-} tpl_B1 tpl_B2} -{- nonrec -} +MkBar{-r3I,x-}{i} = + _/\_ a_tr3u -> \ tpl_B1 tpl_B2 -> + MkBar{-r3I,x-}{i} {_@_ a_tr3u tpl_B1 tpl_B2} +MkFoo{-r3H,x-}{i} = + _/\_ a_tr3z -> \ tpl_B1 tpl_B2 -> + MkFoo{-r3H,x-}{i} {_@_ a_tr3z tpl_B1 tpl_B2} C1{-r9,x-}{i} = - _/\_ a{-r3B-} b{-r3C-} -> \ tpl_B1 tpl_B2 -> - C1{-r9,x-}{i} - {_@_ a{-r3B-} _@_ b{-r3C-} tpl_B1 tpl_B2} + _/\_ a_tr3B b_tr3C -> \ tpl_B1 tpl_B2 -> + C1{-r9,x-}{i} {_@_ a_tr3B _@_ b_tr3C tpl_B1 tpl_B2} C2{-r8,x-}{i} = - _/\_ a{-r3B-} b{-r3C-} -> \ tpl_B1 tpl_B2 -> - C2{-r8,x-}{i} - {_@_ a{-r3B-} _@_ b{-r3C-} tpl_B1 tpl_B2} + _/\_ a_tr3B b_tr3C -> \ tpl_B1 tpl_B2 -> + C2{-r8,x-}{i} {_@_ a_tr3B _@_ b_tr3C tpl_B1 tpl_B2} C3{-rb,x-}{i} = - _/\_ a{-r3B-} b{-r3C-} -> \ tpl_B1 -> - C3{-rb,x-}{i} - {_@_ a{-r3B-} _@_ b{-r3C-} tpl_B1} -{- nonrec -} -{- nonrec -} -{- rec -} + _/\_ a_tr3B b_tr3C -> \ tpl_B1 -> + C3{-rb,x-}{i} {_@_ a_tr3B _@_ b_tr3C tpl_B1} AbsBinds -[a{-aHF-}, b{-aHG-}] -[d.Eq_aIL, d.Ping_aIM, d.Eq_aIN, d.Ping_aIO] -[([a{-aHF-}, b{-aHG-}], $d3{-rKF,x-}, d.Eq_aHt)] - d.Eq_aIU = - d.Eq_aIL - d.Eq_aIS = - $d2{-rKO,x-} - a{-aHF-} - d.Eq_aIU - ==_aKN = - PrelBase.=={-8Y,p-} - (Foo{-r3H,x-} a{-aHF-}) - d.Eq_aIS - d.Ping_aIY = - d.Ping_aIO - d.Eq_aIW = - $d1{-rKP,x-} - b{-aHG-} - d.Ping_aIY - ==_aKM = - PrelBase.=={-8Y,p-} - (Bar{-r3F,x-} b{-aHG-}) - d.Eq_aIW - d.Eq_aJ4 = - d.Eq_aIN - d.Ping_aJ5 = - d.Ping_aIO - d.Eq_aJ6 = - d.Eq_aIL - d.Ping_aJ7 = - d.Ping_aIM - d.Eq_aJ2 = - $d3{-rKF,x-} - [b{-aHG-}, a{-aHF-}] - [d.Eq_aJ4, d.Ping_aJ5, d.Eq_aJ6, d.Ping_aJ7] - ==_aKL = - PrelBase.=={-8Y,p-} - (T{-r3I,x-} b{-aHG-} a{-aHF-}) - d.Eq_aJ2 - d.Eq_aJb = - d.Eq_aIL - d.Ping_aJc = - d.Ping_aIM - d.Eq_aJd = - d.Eq_aIL - d.Ping_aJe = - d.Ping_aIM - d.Eq_aJ9 = - $d3{-rKF,x-} - [a{-aHF-}, a{-aHF-}] - [d.Eq_aJb, d.Ping_aJc, d.Eq_aJd, d.Ping_aJe] - ==_aKK = - PrelBase.=={-8Y,p-} - (T{-r3I,x-} a{-aHF-} a{-aHF-}) - d.Eq_aJ9 - ==_aKJ = - ==_aKI - AbsBinds [] [] [([], ==_aKI, ==_aHw)] - ==_aHw - (C1{-r9,x-}{i} a1_rGO a2_rGP) (C1{-r9,x-}{i} b1_rGR b2_rGS) - = (a1_rGO ==_aKN b1_rGR) - PrelBase.&&{-rcW,p-} (a2_rGP ==_aKM b2_rGS) - ==_aHw - (C2{-r8,x-}{i} a1_rGU a2_rGV) (C2{-r8,x-}{i} b1_rGX b2_rGY) - = (a1_rGU ==_aKG b1_rGX) - PrelBase.&&{-rcW,p-} (a2_rGV ==_aKL b2_rGY) - ==_aHw - (C3{-rb,x-}{i} a1_rH0) (C3{-rb,x-}{i} b1_rH2) - = a1_rH0 ==_aKK b1_rH2 - ==_aHw - a_rH4 b_rH6 - = PrelBase.False{-58,p-}{i} - AbsBinds [] [] [([], /=_aKH, /=_aIE)] - /=_aIE - a_rHa b_rHc - = PrelBase.not{-r3D,p-} - ==_aKJ - a_rHa b_rHc - d.Eq_aHt = - ({-dict-} [] [==_aKI, /=_aKH]) -{- rec -} -AbsBinds [a{-aKB-}] [] [([a{-aKB-}], $d4{-rKR,x-}, d.Eval_aJo)] - d.Eval_aJo = - ({-dict-} [] []) -{- rec -} -AbsBinds [a{-aKC-}] [] [([a{-aKC-}], $d5{-rKT,x-}, d.Eval_aJu)] - d.Eval_aJu = - ({-dict-} [] []) -{- rec -} -AbsBinds -[a{-aKD-}, b{-aKE-}] -[] -[([a{-aKD-}, b{-aKE-}], $d6{-rKV,x-}, d.Eval_aJB)] - d.Eval_aJB = - ({-dict-} [] []) -{- rec -} -AbsBinds -[b{-aJO-}] -[d.Ping_aJX] -[([b{-aJO-}], $d1{-rKP,x-}, d.Eq_aJH)] - d.Eq_aK1 = - d.Eq_aJH - $m==_aKX = - PrelBase.$m=={-rcc,p-} - (Bar{-r3F,x-} b{-aJO-}) - d.Eq_aK1 - d.Eq_aK3 = - d.Eq_aJH - $m/=_aKW = - PrelBase.$m/={-rc9,p-} - (Bar{-r3F,x-} b{-aJO-}) - d.Eq_aK3 - AbsBinds [] [] [([], ==_aJJ, ==_aJL)] - ==_aJL - = $m==_aKX - AbsBinds [] [] [([], /=_aJS, /=_aJU)] - /=_aJU - = $m/=_aKW - d.Eq_aJH = - ({-dict-} [] [==_aJJ, /=_aJS]) -{- rec -} -AbsBinds -[a{-aKh-}] -[d.Eq_aKq] -[([a{-aKh-}], $d2{-rKO,x-}, d.Eq_aKa)] - d.Eq_aKu = - d.Eq_aKa - $m==_aKZ = - PrelBase.$m=={-rcc,p-} - (Foo{-r3H,x-} a{-aKh-}) - d.Eq_aKu - d.Eq_aKw = - d.Eq_aKa - $m/=_aKY = - PrelBase.$m/={-rc9,p-} - (Foo{-r3H,x-} a{-aKh-}) - d.Eq_aKw - AbsBinds [] [] [([], ==_aKc, ==_aKe)] - ==_aKe - = $m==_aKZ - AbsBinds [] [] [([], /=_aKl, /=_aKn)] - /=_aKn - = $m/=_aKY - d.Eq_aKa = - ({-dict-} [] [==_aKc, /=_aKl]) -{- nonrec -} -d.Eq_aKA = - PrelBase.$d7{-rc2,p-} -==_aKG = - PrelBase.=={-8Y,p-} - PrelBase.Int{-3g,p-} - d.Eq_aKA +[taCu, taCv] +[d.Eq_aDz, d.Ping_aDA, d.Eq_aDB, d.Ping_aDC] +[([taCu, taCv], $d3{-rFu,x-}, d.Eq_aCh)] + d.Eq_aDI = d.Eq_aDz + d.Eq_aDG = $d2{-rFC,x-} taCu d.Eq_aDI + ==_aFE = PrelBase.=={-8Y,p-} (Foo{-r3F,x-} taCu) d.Eq_aDG + d.Ping_aDM = d.Ping_aDC + d.Eq_aDK = $d1{-rFB,x-} taCv d.Ping_aDM + ==_aFF = PrelBase.=={-8Y,p-} (Bar{-r3E,x-} taCv) d.Eq_aDK + d.Eq_aDS = d.Eq_aDB + d.Ping_aDT = d.Ping_aDC + d.Eq_aDU = d.Eq_aDz + d.Ping_aDV = d.Ping_aDA + d.Eq_aDQ = + $d3{-rFu,x-} [taCv, taCu] + [d.Eq_aDS, d.Ping_aDT, d.Eq_aDU, d.Ping_aDV] + ==_aFG = PrelBase.=={-8Y,p-} (T{-r3G,x-} taCv taCu) d.Eq_aDQ + d.Eq_aDZ = d.Eq_aDz + d.Ping_aE0 = d.Ping_aDA + d.Eq_aE1 = d.Eq_aDz + d.Ping_aE2 = d.Ping_aDA + d.Eq_aDX = + $d3{-rFu,x-} [taCu, taCu] + [d.Eq_aDZ, d.Ping_aE0, d.Eq_aE1, d.Ping_aE2] + ==_aFH = PrelBase.=={-8Y,p-} (T{-r3G,x-} taCu taCu) d.Eq_aDX + ==_aFI = ==_aFJ + AbsBinds [] [] [([], ==_aFJ, ==_aCl)] + ==_aCl (C1{-r9,x-}{i} a1_rBE a2_rBF) (C1{-r9,x-}{i} b1_rBG b2_rBH) + = (a1_rBE ==_aFE b1_rBG) + PrelBase.&&{-rfy,p-} (a2_rBF ==_aFF b2_rBH) + ==_aCl (C2{-r8,x-}{i} a1_rBJ a2_rBK) (C2{-r8,x-}{i} b1_rBL b2_rBM) + = (a1_rBJ ==_aFD b1_rBL) + PrelBase.&&{-rfy,p-} (a2_rBK ==_aFG b2_rBM) + ==_aCl (C3{-rb,x-}{i} a1_rBO) (C3{-rb,x-}{i} b1_rBP) + = a1_rBO ==_aFH b1_rBP + ==_aCl a_rBR b_rBS = PrelBase.False{-58,w-}{i} + AbsBinds [] [] [([], /=_aFK, /=_aDs)] + /=_aDs a_rBW b_rBX = PrelBase.not{-r3D,p-} ==_aFI a_rBW b_rBX + d.Eq_aCh = ({-dict-} [] [==_aFJ, /=_aFK]) +AbsBinds [taFp] [] [([taFp], $d4{-rFw,x-}, d.Eval_aEc)] + d.Eval_aEc = ({-dict-} [] []) +AbsBinds [taFq] [] [([taFq], $d5{-rFy,x-}, d.Eval_aEi)] + d.Eval_aEi = ({-dict-} [] []) +AbsBinds [taFr, taFs] [] [([taFr, taFs], $d6{-rFA,x-}, d.Eval_aEp)] + d.Eval_aEp = ({-dict-} [] []) +AbsBinds [taED] [d.Ping_aEM] [([taED], $d1{-rFB,x-}, d.Eq_aEv)] + d.Eq_aEQ = d.Eq_aEv + $m/=_aFL = PrelBase.$m/={-rfk,p-} (Bar{-r3E,x-} taED) d.Eq_aEQ + AbsBinds [] [] [([], ==_aFM, ==_aEA)] + ==_aEA + = GHCerr.noDefaultMethodError{-8k,w-} + (Bar{-r3E,x-} taED + -> Bar{-r3E,x-} taED + -> PrelBase.Bool{-34,W-}) "|PrelBase.==" + AbsBinds [] [] [([], /=_aFN, /=_aEJ)] + /=_aEJ = $m/=_aFL + d.Eq_aEv = ({-dict-} [] [==_aFM, /=_aFN]) +AbsBinds [taF5] [d.Eq_aFe] [([taF5], $d2{-rFC,x-}, d.Eq_aEX)] + d.Eq_aFi = d.Eq_aEX + $m/=_aFO = PrelBase.$m/={-rfk,p-} (Foo{-r3F,x-} taF5) d.Eq_aFi + AbsBinds [] [] [([], ==_aFP, ==_aF2)] + ==_aF2 + = GHCerr.noDefaultMethodError{-8k,w-} + (Foo{-r3F,x-} taF5 + -> Foo{-r3F,x-} taF5 + -> PrelBase.Bool{-34,W-}) "|PrelBase.==" + AbsBinds [] [] [([], /=_aFQ, /=_aFb)] + /=_aFb = $m/=_aFO + d.Eq_aEX = ({-dict-} [] [==_aFP, /=_aFQ]) +AbsBinds [taFt] [d.Ping_aFm] [] +d.Eq_aFo = PrelBase.$d8{-rbg,p-} +==_aFD = PrelBase.=={-8Y,p-} PrelBase.Int{-3g,W-} d.Eq_aFo ghc: module version changed to 1; reason: no old .hi file +_interface_ ShouldSucceed 1 +_instance_modules_ +ArrBase IO PrelNum +_usages_ +PrelBase 1 :: $d16 1 $d2 1 $d33 1 $d38 1 $d40 1 $d42 1 $d47 1 $d8 1 $m/= 1 && 1 not 1 Eq 1 Eval 1; +PrelNum 1 :: $d18 1; +_exports_ +ShouldSucceed Bar(MkBar) Foo(MkFoo) Ping T(C1 C2 C3); +_instances_ +instance _forall_ [b] {Ping b} => {PrelBase.Eq (Bar b)} = $d1; +instance _forall_ [a] {PrelBase.Eq a} => {PrelBase.Eq (Foo a)} = $d2; +instance _forall_ [a b] {PrelBase.Eq a, Ping a, PrelBase.Eq b, Ping b} => {PrelBase.Eq (T a b)} = $d3; +instance _forall_ [a] => {PrelBase.Eval (Bar a)} = $d4; +instance _forall_ [a] => {PrelBase.Eval (Foo a)} = $d5; +instance _forall_ [a b] => {PrelBase.Eval (T a b)} = $d6; +_declarations_ +1 $d1 _:_ _forall_ [b] {Ping b} => {PrelBase.Eq (Bar b)} ;; +1 $d2 _:_ _forall_ [a] {PrelBase.Eq a} => {PrelBase.Eq (Foo a)} ;; +1 $d3 _:_ _forall_ [a b] {PrelBase.Eq a, Ping a, PrelBase.Eq b, Ping b} => {PrelBase.Eq (T a b)} ;; +1 $d4 _:_ _forall_ [a] => {PrelBase.Eval (Bar a)} ;; +1 $d5 _:_ _forall_ [a] => {PrelBase.Eval (Foo a)} ;; +1 $d6 _:_ _forall_ [a b] => {PrelBase.Eval (T a b)} ;; +1 data Bar a = MkBar PrelBase.Int PrelBase.Int ; +1 data Foo a = MkFoo PrelBase.Double a ; +1 class Ping a ; +1 data T a b = C1 (Foo a) (Bar b) | C2 PrelBase.Int (T b a) | C3 (T a a) ; diff --git a/ghc/tests/deriving/should_compile/drv004.hs b/ghc/tests/deriving/should_compile/drv004.hs index 82afb6b..5c095dd 100644 --- a/ghc/tests/deriving/should_compile/drv004.hs +++ b/ghc/tests/deriving/should_compile/drv004.hs @@ -1,8 +1,9 @@ ---!!! simple example of deriving Ord (and, implicitly, Eq) +--!!! simple example of deriving Ord and Eq simultaneously -- module ShouldSucceed where -data Foo a b +data Foo a b c = C1 a Int | C2 b Double - deriving Ord + | C3 c String + deriving (Eq, Ord) diff --git a/ghc/tests/deriving/should_compile/drv004.stderr b/ghc/tests/deriving/should_compile/drv004.stderr index f54e1f7..c92e43a 100644 --- a/ghc/tests/deriving/should_compile/drv004.stderr +++ b/ghc/tests/deriving/should_compile/drv004.stderr @@ -1,9 +1,203 @@ - -drv004.hs:5: No instance for: - `PrelBase.Eq (Foo a{-aIX-} b{-aIY-})' - drv004.hs:5: - in an instance declaration - When checking superclass constraints of an instance declaration -Compilation had errors +================================================================================ +Typechecked: +C1{-r4,x-}{i} = + _/\_ a_tr3j b_tr3k c_tr3l -> \ tpl_B1 tpl_B2 -> + C1{-r4,x-}{i} {_@_ a_tr3j _@_ b_tr3k _@_ c_tr3l tpl_B1 tpl_B2} +C2{-r3,x-}{i} = + _/\_ a_tr3j b_tr3k c_tr3l -> \ tpl_B1 tpl_B2 -> + C2{-r3,x-}{i} {_@_ a_tr3j _@_ b_tr3k _@_ c_tr3l tpl_B1 tpl_B2} +C3{-r6,x-}{i} = + _/\_ a_tr3j b_tr3k c_tr3l -> \ tpl_B1 tpl_B2 -> + C3{-r6,x-}{i} {_@_ a_tr3j _@_ b_tr3k _@_ c_tr3l tpl_B1 tpl_B2} +AbsBinds +[taEz, taEB, taEC] +[] +[([taEz, taEB, taEC], con2tag_Foo#_rBK, con2tag_Foo#_aE7)] + con2tag_Foo#_aE7 (C1{-r4,x-}{i} _ _) = 0# + con2tag_Foo#_aE7 (C2{-r3,x-}{i} _ _) = 1# + con2tag_Foo#_aE7 (C3{-r6,x-}{i} _ _) = 2# +AbsBinds +[taEU, taEX, taF0] +[d.Eq_aGk, d.Eq_aGl, d.Eq_aGm] +[([taEU, taEX, taF0], $d1{-rLl,x-}, d.Eq_aEK)] + d.Eq_aGq = d.Eq_aGk + ==_aLu = PrelBase.=={-8Y,p-} taEU d.Eq_aGq + d.Eq_aGu = d.Eq_aGl + ==_aLv = PrelBase.=={-8Y,p-} taEX d.Eq_aGu + d.Eq_aGy = d.Eq_aGm + ==_aLw = PrelBase.=={-8Y,p-} taF0 d.Eq_aGy + ==_aLx = ==_aLy + AbsBinds [] [] [([], ==_aLy, ==_aEO)] + ==_aEO (C1{-r4,x-}{i} a1_rBS a2_rBT) (C1{-r4,x-}{i} b1_rBU b2_rBV) + = (a1_rBS ==_aLu b1_rBU) + PrelBase.&&{-rfc,p-} (a2_rBT ==_aLo b2_rBV) + ==_aEO (C2{-r3,x-}{i} a1_rBX a2_rBY) (C2{-r3,x-}{i} b1_rBZ b2_rC0) + = (a1_rBX ==_aLv b1_rBZ) + PrelBase.&&{-rfc,p-} (a2_rBY ==_aLp b2_rC0) + ==_aEO (C3{-r6,x-}{i} a1_rC2 a2_rC3) (C3{-r6,x-}{i} b1_rC4 b2_rC5) + = (a1_rC2 ==_aLw b1_rC4) + PrelBase.&&{-rfc,p-} (a2_rC3 ==_aLq b2_rC5) + ==_aEO a_rC7 b_rC8 = PrelBase.False{-58,w-}{i} + AbsBinds [] [] [([], /=_aLz, /=_aGd)] + /=_aGd a_rCc b_rCd = PrelBase.not{-rga,p-} ==_aLx a_rCc b_rCd + d.Eq_aEK = ({-dict-} [] [==_aLy, /=_aLz]) +AbsBinds +[taLi, taLj, taLk] +[] +[([taLi, taLj, taLk], $d2{-rLm,x-}, d.Eval_aGL)] + d.Eval_aGL = ({-dict-} [] []) +AbsBinds +[taH0, taH1, taH2] +[d.Ord_aKA, d.Ord_aKB, d.Ord_aKC, d.Eq_aKD] +[([taH0, taH1, taH2], $d3{-rLn,x-}, d.Ord_aGT)] + d.Eq_aKz = d.Eq_aKD + d.Ord_aJb = d.Ord_aKA + d.Ord_aJc = d.Ord_aKB + d.Ord_aJd = d.Ord_aKC + compare_aLA = compare_aLG + compare_aLB = compare_aLG + compare_aLC = compare_aLG + compare_aLD = compare_aLG + compare_aLE = compare_aLG + compare_aLF = compare_aLG + AbsBinds [] [] [([], compare_aLG, compare_aGX)] + compare_aGX a_rD5 b_rD6 + = case con2tag_Foo#_rBK [taH2, taH0, taH1] a_rD5 of + a#_rDI + -> case con2tag_Foo#_rBK [taH2, taH0, taH1] b_rD6 of + b#_rDK + -> if a#_rDI GHC.==#{-79,w-}{I} b#_rDK then + case cmp_eq_aLN a_rD5 b_rD6 of + PrelBase.LT{-r9P,p-}{i} -> PrelBase.LT{-r9P,p-}{i} + PrelBase.EQ{-r3m,p-}{i} -> PrelBase.EQ{-r3m,p-}{i} + PrelBase.GT{-r9Q,p-}{i} -> PrelBase.GT{-r9Q,p-}{i} + else + if a#_rDI GHC.<#{-7b,w-}{I} b#_rDK then + PrelBase.LT{-r9P,p-}{i} + else + PrelBase.GT{-r9Q,p-}{i} + where + {- nonrec -} + AbsBinds + [taIi, taIj, taIm] + [d.Ord_aIx, d.Ord_aIB, d.Ord_aIF] + [([taIi, taIj, taIm], cmp_eq_rD8, cmp_eq_aH6)] + compare_aLO = PrelBase.compare{-rfr,p-} taIi d.Ord_aIx + compare_aLP = PrelBase.compare{-rfr,p-} taIj d.Ord_aIB + compare_aLQ = PrelBase.compare{-rfr,p-} taIm d.Ord_aIF + cmp_eq_aH6 (C1{-r4,x-}{i} a1_rDa a2_rDb) + (C1{-r4,x-}{i} b1_rDc b2_rDd) + = case compare_aLO a1_rDa b1_rDc of + PrelBase.LT{-r9P,p-}{i} -> PrelBase.LT{-r9P,p-}{i} + PrelBase.EQ{-r3m,p-}{i} + -> case compare_aLr a2_rDb b2_rDd of + PrelBase.LT{-r9P,p-}{i} -> PrelBase.LT{-r9P,p-}{i} + PrelBase.EQ{-r3m,p-}{i} -> PrelBase.EQ{-r3m,p-}{i} + PrelBase.GT{-r9Q,p-}{i} -> PrelBase.GT{-r9Q,p-}{i} + PrelBase.GT{-r9Q,p-}{i} -> PrelBase.GT{-r9Q,p-}{i} + cmp_eq_aH6 (C2{-r3,x-}{i} a1_rDl a2_rDm) + (C2{-r3,x-}{i} b1_rDn b2_rDo) + = case compare_aLP a1_rDl b1_rDn of + PrelBase.LT{-r9P,p-}{i} -> PrelBase.LT{-r9P,p-}{i} + PrelBase.EQ{-r3m,p-}{i} + -> case compare_aLs a2_rDm b2_rDo of + PrelBase.LT{-r9P,p-}{i} -> PrelBase.LT{-r9P,p-}{i} + PrelBase.EQ{-r3m,p-}{i} -> PrelBase.EQ{-r3m,p-}{i} + PrelBase.GT{-r9Q,p-}{i} -> PrelBase.GT{-r9Q,p-}{i} + PrelBase.GT{-r9Q,p-}{i} -> PrelBase.GT{-r9Q,p-}{i} + cmp_eq_aH6 (C3{-r6,x-}{i} a1_rDw a2_rDx) + (C3{-r6,x-}{i} b1_rDy b2_rDz) + = case compare_aLQ a1_rDw b1_rDy of + PrelBase.LT{-r9P,p-}{i} -> PrelBase.LT{-r9P,p-}{i} + PrelBase.EQ{-r3m,p-}{i} + -> case compare_aLt a2_rDx b2_rDz of + PrelBase.LT{-r9P,p-}{i} -> PrelBase.LT{-r9P,p-}{i} + PrelBase.EQ{-r3m,p-}{i} -> PrelBase.EQ{-r3m,p-}{i} + PrelBase.GT{-r9Q,p-}{i} -> PrelBase.GT{-r9Q,p-}{i} + PrelBase.GT{-r9Q,p-}{i} -> PrelBase.GT{-r9Q,p-}{i} + cmp_eq_aH6 _ _ + = IOBase.error{-87,w-} + PrelBase.Ordering{-3o,p-} "Urk! in TcGenDeriv" + {- nonrec -} + cmp_eq_aLN = + cmp_eq_rD8 [taH0, taH1, taH2] [d.Ord_aJb, d.Ord_aJc, d.Ord_aJd] + {- nonrec -} + AbsBinds [] [] [([], <_aLH, <_aJo)] + <_aJo a_rCj b_rCk + = case compare_aLA a_rCj b_rCk of + PrelBase.LT{-r9P,p-}{i} -> PrelBase.True{-5E,w-}{i} + PrelBase.EQ{-r3m,p-}{i} -> PrelBase.False{-58,w-}{i} + PrelBase.GT{-r9Q,p-}{i} -> PrelBase.False{-58,w-}{i} + AbsBinds [] [] [([], <=_aLI, <=_aJB)] + <=_aJB a_rCr b_rCs + = case compare_aLB a_rCr b_rCs of + PrelBase.LT{-r9P,p-}{i} -> PrelBase.True{-5E,w-}{i} + PrelBase.EQ{-r3m,p-}{i} -> PrelBase.True{-5E,w-}{i} + PrelBase.GT{-r9Q,p-}{i} -> PrelBase.False{-58,w-}{i} + AbsBinds [] [] [([], >=_aLJ, >=_aJO)] + >=_aJO a_rCz b_rCA + = case compare_aLC a_rCz b_rCA of + PrelBase.LT{-r9P,p-}{i} -> PrelBase.False{-58,w-}{i} + PrelBase.EQ{-r3m,p-}{i} -> PrelBase.True{-5E,w-}{i} + PrelBase.GT{-r9Q,p-}{i} -> PrelBase.True{-5E,w-}{i} + AbsBinds [] [] [([], >_aLK, >_aK1)] + >_aK1 a_rCH b_rCI + = case compare_aLD a_rCH b_rCI of + PrelBase.LT{-r9P,p-}{i} -> PrelBase.False{-58,w-}{i} + PrelBase.EQ{-r3m,p-}{i} -> PrelBase.False{-58,w-}{i} + PrelBase.GT{-r9Q,p-}{i} -> PrelBase.True{-5E,w-}{i} + AbsBinds [] [] [([], max_aLL, max_aKe)] + max_aKe a_rCP b_rCQ + = case compare_aLE a_rCP b_rCQ of + PrelBase.LT{-r9P,p-}{i} -> b_rCQ + PrelBase.EQ{-r3m,p-}{i} -> a_rCP + PrelBase.GT{-r9Q,p-}{i} -> a_rCP + AbsBinds [] [] [([], min_aLM, min_aKr)] + min_aKr a_rCX b_rCY + = case compare_aLF a_rCX b_rCY of + PrelBase.LT{-r9P,p-}{i} -> a_rCX + PrelBase.EQ{-r3m,p-}{i} -> b_rCY + PrelBase.GT{-r9Q,p-}{i} -> b_rCY + d.Ord_aGT = + ({-dict-} + [d.Eq_aKz] + [compare_aLG, <_aLH, <=_aLI, >=_aLJ, >_aLK, max_aLL, min_aLM]) +d.Eq_aKX = PrelBase.$d8{-raU,p-} +==_aLo = PrelBase.=={-8Y,p-} PrelBase.Int{-3g,W-} d.Eq_aKX +d.Eq_aL0 = PrelNum.$d18{-rtI,p-} +==_aLp = PrelBase.=={-8Y,p-} PrelBase.Double{-3a,W-} d.Eq_aL0 +d.Eq_aL5 = PrelBase.$d34{-rar,p-} +d.Eq_aL3 = PrelBase.$d28{-rak,p-} PrelBase.Char{-38,W-} d.Eq_aL5 +==_aLq = PrelBase.=={-8Y,p-} PrelBase.String{-rfA,p-} d.Eq_aL3 +d.Ord_aL8 = PrelBase.$d7{-raT,p-} +compare_aLr = + PrelBase.compare{-rfr,p-} PrelBase.Int{-3g,W-} d.Ord_aL8 +d.Ord_aLb = PrelNum.$d17{-rtH,p-} +compare_aLs = + PrelBase.compare{-rfr,p-} PrelBase.Double{-3a,W-} d.Ord_aLb +d.Ord_aLg = PrelBase.$d51{-raK,p-} +d.Eq_aLh = d.Eq_aL3 +d.Ord_aLe = + PrelBase.$d27{-raj,p-} PrelBase.Char{-38,W-} [d.Ord_aLg, d.Eq_aLh] +compare_aLt = + PrelBase.compare{-rfr,p-} PrelBase.String{-rfA,p-} d.Ord_aLe +ghc: module version changed to 1; reason: no old .hi file +_interface_ ShouldSucceed 1 +_instance_modules_ +ArrBase IO PrelNum +_usages_ +PrelBase 1 :: $d15 1 $d16 1 $d2 1 $d27 1 $d28 1 $d33 1 $d34 1 $d35 1 $d38 1 $d39 1 $d40 1 $d42 1 $d45 1 $d46 1 $d47 1 $d50 1 $d51 1 $d52 1 $d7 1 $d8 1 $m/= 1 $m< 1 $m<= 1 $m> 1 $m>= 1 $mcompare 1 $mmax 1 $mmin 1 && 1 . 1 not 1 Eq 1 Eval 1 Ord 1 Ordering 1 String 1; +PrelNum 1 :: $d17 1 $d18 1; +_exports_ +ShouldSucceed Foo(C1 C2 C3); +_instances_ +instance _forall_ [a b c] {PrelBase.Eq a, PrelBase.Eq b, PrelBase.Eq c} => {PrelBase.Eq (Foo a b c)} = $d1; +instance _forall_ [a b c] => {PrelBase.Eval (Foo a b c)} = $d2; +instance _forall_ [a b c] {PrelBase.Ord a, PrelBase.Ord b, PrelBase.Ord c} => {PrelBase.Ord (Foo a b c)} = $d3; +_declarations_ +1 $d1 _:_ _forall_ [a b c] {PrelBase.Eq a, PrelBase.Eq b, PrelBase.Eq c} => {PrelBase.Eq (Foo a b c)} ;; +1 $d2 _:_ _forall_ [a b c] => {PrelBase.Eval (Foo a b c)} ;; +1 $d3 _:_ _forall_ [a b c] {PrelBase.Ord a, PrelBase.Ord b, PrelBase.Ord c, PrelBase.Eq (Foo a b c)} => {PrelBase.Ord (Foo a b c)} ;; +1 data Foo a b c = C1 a PrelBase.Int | C2 b PrelBase.Double | C3 c PrelBase.String ; diff --git a/ghc/tests/deriving/should_compile/drv005.stderr b/ghc/tests/deriving/should_compile/drv005.stderr index af453f9..08f43c3 100644 --- a/ghc/tests/deriving/should_compile/drv005.stderr +++ b/ghc/tests/deriving/should_compile/drv005.stderr @@ -2,187 +2,98 @@ ================================================================================ Typechecked: -{- nonrec -} -Foo1{-r4,x-}{i} = - Foo1{-r4,x-}{i} - {} -Foo2{-r3,x-}{i} = - Foo2{-r3,x-}{i} - {} -Foo3{-r6,x-}{i} = - Foo3{-r6,x-}{i} - {} -Foo4{-r8,x-}{i} = - Foo4{-r8,x-}{i} - {} -Foo5{-ra,x-}{i} = - Foo5{-ra,x-}{i} - {} -Foo6{-rc,x-}{i} = - Foo6{-rc,x-}{i} - {} -Foo7{-re,x-}{i} = - Foo7{-re,x-}{i} - {} -Foo8{-rg,x-}{i} = - Foo8{-rg,x-}{i} - {} -{- rec -} -AbsBinds [] [] [([], $d1{-rJK,x-}, d.Enum_aHX)] - map_aJU = - map_aJP - AbsBinds [] [] [([], toEnum_aJT, toEnum_aI0)] - toEnum_aI0 - a_rH5 = tag2con_Foo#_rGH - a_rH5 - AbsBinds [] [] [([], fromEnum_aJS, fromEnum_aI5)] - fromEnum_aI5 - a_rHp = case - con2tag_Foo#_rGJ - a_rHp - of - a#_rHr -> PrelBase.I#{-5b,p-}{i} - a#_rHr - AbsBinds [] [] [([], enumFrom_aJR, enumFrom_aIc)] - enumFrom_aIc - a_rH9 = case - con2tag_Foo#_rGJ - a_rH9 - of - a#_rHb -> map_aJP - [PrelBase.Int{-3g,p-}, Foo{-rZ,x-}] - tag2con_Foo#_rGH - enumFromTo_aJO - PrelBase.I#{-5b,p-}{i} - a#_rHb - maxtag_Foo#_rGI - AbsBinds [] [] [([], enumFromThen_aJQ, enumFromThen_aIA)] - enumFromThen_aIA - a_rHf b_rHh - = case - con2tag_Foo#_rGJ - a_rHf - of - a#_rHj -> case - con2tag_Foo#_rGJ - b_rHh - of - b#_rHl -> map_aJU - [PrelBase.Int{-3g,p-}, Foo{-rZ,x-}] - tag2con_Foo#_rGH - enumFromThenTo_aJN - PrelBase.I#{-5b,p-}{i} - a#_rHj - PrelBase.I#{-5b,p-}{i} - b#_rHl - maxtag_Foo#_rGI - AbsBinds [] [] [([], enumFromTo_aJ1, enumFromTo_aJ3)] - enumFromTo_aJ3 - = $menumFromTo_aJM - AbsBinds [] [] [([], enumFromThenTo_aJa, enumFromThenTo_aJc)] - enumFromThenTo_aJc - = $menumFromThenTo_aJL - d.Enum_aHX = +Foo1{-r4,x-}{i} = Foo1{-r4,x-}{i} {} +Foo2{-r3,x-}{i} = Foo2{-r3,x-}{i} {} +Foo3{-r6,x-}{i} = Foo3{-r6,x-}{i} {} +Foo4{-r8,x-}{i} = Foo4{-r8,x-}{i} {} +Foo5{-ra,x-}{i} = Foo5{-ra,x-}{i} {} +Foo6{-rc,x-}{i} = Foo6{-rc,x-}{i} {} +Foo7{-re,x-}{i} = Foo7{-re,x-}{i} {} +Foo8{-rg,x-}{i} = Foo8{-rg,x-}{i} {} +AbsBinds [] [] [([], con2tag_Foo#_rBo, con2tag_Foo#_aCh)] + con2tag_Foo#_aCh Foo1{-r4,x-}{i} = 0# + con2tag_Foo#_aCh Foo2{-r3,x-}{i} = 1# + con2tag_Foo#_aCh Foo3{-r6,x-}{i} = 2# + con2tag_Foo#_aCh Foo4{-r8,x-}{i} = 3# + con2tag_Foo#_aCh Foo5{-ra,x-}{i} = 4# + con2tag_Foo#_aCh Foo6{-rc,x-}{i} = 5# + con2tag_Foo#_aCh Foo7{-re,x-}{i} = 6# + con2tag_Foo#_aCh Foo8{-rg,x-}{i} = 7# +AbsBinds [] [] [([], maxtag_Foo#_rBn, maxtag_Foo#_aCm)] + maxtag_Foo#_aCm = PrelBase.I#{-5b,w-}{i} 7# +AbsBinds [] [] [([], tag2con_Foo#_rBm, tag2con_Foo#_aCp)] + tag2con_Foo#_aCp (PrelBase.I#{-5b,w-}{i} 0#) = Foo1{-r4,x-}{i} + tag2con_Foo#_aCp (PrelBase.I#{-5b,w-}{i} 1#) = Foo2{-r3,x-}{i} + tag2con_Foo#_aCp (PrelBase.I#{-5b,w-}{i} 2#) = Foo3{-r6,x-}{i} + tag2con_Foo#_aCp (PrelBase.I#{-5b,w-}{i} 3#) = Foo4{-r8,x-}{i} + tag2con_Foo#_aCp (PrelBase.I#{-5b,w-}{i} 4#) = Foo5{-ra,x-}{i} + tag2con_Foo#_aCp (PrelBase.I#{-5b,w-}{i} 5#) = Foo6{-rc,x-}{i} + tag2con_Foo#_aCp (PrelBase.I#{-5b,w-}{i} 6#) = Foo7{-re,x-}{i} + tag2con_Foo#_aCp (PrelBase.I#{-5b,w-}{i} 7#) = Foo8{-rg,x-}{i} + tag2con_Foo#_aCp _ + = IOBase.error{-87,w-} Foo{-r12,x-} "Urk! in TcGenDeriv" +AbsBinds [] [] [([], $d1{-rEx,x-}, d.Enum_aCB)] + map_aEF = map_aEA + AbsBinds [] [] [([], toEnum_aEG, toEnum_aCF)] + toEnum_aCF a_rBL = tag2con_Foo#_rBm a_rBL + AbsBinds [] [] [([], fromEnum_aEH, fromEnum_aCL)] + fromEnum_aCL a_rC4 + = case con2tag_Foo#_rBo a_rC4 of + a#_rC6 -> PrelBase.I#{-5b,w-}{i} a#_rC6 + AbsBinds [] [] [([], enumFrom_aEI, enumFrom_aCV)] + enumFrom_aCV a_rBP + = case con2tag_Foo#_rBo a_rBP of + a#_rBR + -> map_aEA [PrelBase.Int{-3g,W-}, Foo{-r12,x-}] tag2con_Foo#_rBm + enumFromTo_aEB PrelBase.I#{-5b,w-}{i} a#_rBR + maxtag_Foo#_rBn + AbsBinds [] [] [([], enumFromThen_aEJ, enumFromThen_aDk)] + enumFromThen_aDk a_rBV b_rBW + = case con2tag_Foo#_rBo a_rBV of + a#_rBY + -> case con2tag_Foo#_rBo b_rBW of + b#_rC0 + -> map_aEF [PrelBase.Int{-3g,W-}, Foo{-r12,x-}] tag2con_Foo#_rBm + enumFromThenTo_aEC PrelBase.I#{-5b,w-}{i} a#_rBY + PrelBase.I#{-5b,w-}{i} b#_rC0 + maxtag_Foo#_rBn + AbsBinds [] [] [([], enumFromTo_aEK, enumFromTo_aDP)] + enumFromTo_aDP = $menumFromTo_aED + AbsBinds [] [] [([], enumFromThenTo_aEL, enumFromThenTo_aDZ)] + enumFromThenTo_aDZ = $menumFromThenTo_aEE + d.Enum_aCB = ({-dict-} [] - [toEnum_aJT, fromEnum_aJS, enumFrom_aJR, enumFromThen_aJQ, enumFromTo_aJ1, enumFromThenTo_aJa]) -{- rec -} -AbsBinds [] [] [([], $d2{-rJW,x-}, d.Eval_aJw)] - d.Eval_aJw = - ({-dict-} [] []) -{- nonrec -} -d.Functor_aJy = - PrelBase.$d25{-rbd,p-} -map_aJP = - PrelBase.map{-rY,p-} - PrelBase.[]{-3j,p-} - d.Functor_aJy -d.Enum_aJB = - PrelBase.$d5{-rbE,p-} -enumFromTo_aJO = - PrelBase.enumFromTo{-8W,p-} - PrelBase.Int{-3g,p-} - d.Enum_aJB -d.Enum_aJE = - d.Enum_aJB -enumFromThenTo_aJN = - PrelBase.enumFromThenTo{-8X,p-} - PrelBase.Int{-3g,p-} - d.Enum_aJE -d.Enum_aJG = - $d1{-rJK,x-} -$menumFromTo_aJM = - PrelBase.$menumFromTo{-rc8,p-} - Foo{-rZ,x-} - d.Enum_aJG -d.Enum_aJJ = - d.Enum_aJG -$menumFromThenTo_aJL = - PrelBase.$menumFromThenTo{-rc7,p-} - Foo{-rZ,x-} - d.Enum_aJJ -{- nonrec -} -AbsBinds [] [] [([], con2tag_Foo#_rGJ, con2tag_Foo#_aHG)] - con2tag_Foo#_aHG - Foo1{-r4,x-}{i} - = 0# - con2tag_Foo#_aHG - Foo2{-r3,x-}{i} - = 1# - con2tag_Foo#_aHG - Foo3{-r6,x-}{i} - = 2# - con2tag_Foo#_aHG - Foo4{-r8,x-}{i} - = 3# - con2tag_Foo#_aHG - Foo5{-ra,x-}{i} - = 4# - con2tag_Foo#_aHG - Foo6{-rc,x-}{i} - = 5# - con2tag_Foo#_aHG - Foo7{-re,x-}{i} - = 6# - con2tag_Foo#_aHG - Foo8{-rg,x-}{i} - = 7# -{- nonrec -} -{- nonrec -} -AbsBinds [] [] [([], maxtag_Foo#_rGI, maxtag_Foo#_aHK)] - maxtag_Foo#_aHK - = PrelBase.I#{-5b,p-}{i} - 7# -{- nonrec -} -{- nonrec -} -AbsBinds [] [] [([], tag2con_Foo#_rGH, tag2con_Foo#_aHO)] - tag2con_Foo#_aHO - (PrelBase.I#{-5b,p-}{i} 0#) - = Foo1{-r4,x-}{i} - tag2con_Foo#_aHO - (PrelBase.I#{-5b,p-}{i} 1#) - = Foo2{-r3,x-}{i} - tag2con_Foo#_aHO - (PrelBase.I#{-5b,p-}{i} 2#) - = Foo3{-r6,x-}{i} - tag2con_Foo#_aHO - (PrelBase.I#{-5b,p-}{i} 3#) - = Foo4{-r8,x-}{i} - tag2con_Foo#_aHO - (PrelBase.I#{-5b,p-}{i} 4#) - = Foo5{-ra,x-}{i} - tag2con_Foo#_aHO - (PrelBase.I#{-5b,p-}{i} 5#) - = Foo6{-rc,x-}{i} - tag2con_Foo#_aHO - (PrelBase.I#{-5b,p-}{i} 6#) - = Foo7{-re,x-}{i} - tag2con_Foo#_aHO - (PrelBase.I#{-5b,p-}{i} 7#) - = Foo8{-rg,x-}{i} - tag2con_Foo#_aHO - _ = IOBase.error{-87,p-} - Foo{-rZ,x-} - "Urk! in TcGenDeriv" -{- nonrec -} + [toEnum_aEG, fromEnum_aEH, enumFrom_aEI, enumFromThen_aEJ, enumFromTo_aEK, enumFromThenTo_aEL]) +AbsBinds [] [] [([], $d2{-rEz,x-}, d.Eval_aEj)] + d.Eval_aEj = ({-dict-} [] []) +d.Functor_aEl = PrelBase.$d26{-raq,p-} +map_aEA = PrelBase.map{-r11,p-} PrelBase.[]{-3j,W-} d.Functor_aEl +d.Enum_aEo = PrelBase.$d6{-rb0,p-} +enumFromTo_aEB = + PrelBase.enumFromTo{-8W,p-} PrelBase.Int{-3g,W-} d.Enum_aEo +d.Enum_aEr = d.Enum_aEo +enumFromThenTo_aEC = + PrelBase.enumFromThenTo{-8X,p-} PrelBase.Int{-3g,W-} d.Enum_aEr +d.Enum_aEt = $d1{-rEx,x-} +$menumFromTo_aED = + PrelBase.$menumFromTo{-rfe,p-} Foo{-r12,x-} d.Enum_aEt +d.Enum_aEw = d.Enum_aEt +$menumFromThenTo_aEE = + PrelBase.$menumFromThenTo{-rfd,p-} Foo{-r12,x-} d.Enum_aEw ghc: module version changed to 1; reason: no old .hi file +_interface_ ShouldSucceed 1 +_instance_modules_ +ArrBase IO PrelNum +_usages_ +PrelBase 1 :: $d14 1 $d2 1 $d26 1 $d31 1 $d38 1 $d40 1 $d42 1 $d45 1 $d47 1 $d6 1 $menumFromThenTo 1 $menumFromTo 1 Enum 1 Eval 1 Functor 1; +PrelNum 1 :: $d8 1; +_exports_ +ShouldSucceed Foo(Foo1 Foo2 Foo3 Foo4 Foo5 Foo6 Foo7 Foo8); +_instances_ +instance {PrelBase.Enum Foo} = $d1; +instance {PrelBase.Eval Foo} = $d2; +_declarations_ +1 $d1 _:_ {PrelBase.Enum Foo} ;; +1 $d2 _:_ {PrelBase.Eval Foo} ;; +1 data Foo = Foo1 | Foo2 | Foo3 | Foo4 | Foo5 | Foo6 | Foo7 | Foo8 ; diff --git a/ghc/tests/deriving/should_compile/drv006.stderr b/ghc/tests/deriving/should_compile/drv006.stderr index 4d1f585..70f99a0 100644 --- a/ghc/tests/deriving/should_compile/drv006.stderr +++ b/ghc/tests/deriving/should_compile/drv006.stderr @@ -2,404 +2,224 @@ ================================================================================ Typechecked: -{- nonrec -} -{- nonrec -} -MkBar{-r4H,x-}{i} = - _/\_ a{-r4B-} b{-r4C-} -> \ tpl_B1 tpl_B2 tpl_B3 tpl_B4 tpl_B5 -> - MkBar{-r4H,x-}{i} - {_@_ a{-r4B-} _@_ b{-r4C-} tpl_B1 tpl_B2 tpl_B3 tpl_B4 tpl_B5} -{- nonrec -} -Foo1{-r4t,x-}{i} = - Foo1{-r4t,x-}{i} - {} -Foo2{-r4s,x-}{i} = - Foo2{-r4s,x-}{i} - {} -Foo3{-r4u,x-}{i} = - Foo3{-r4u,x-}{i} - {} -Foo4{-r4v,x-}{i} = - Foo4{-r4v,x-}{i} - {} -Foo5{-r4w,x-}{i} = - Foo5{-r4w,x-}{i} - {} -Foo6{-r4x,x-}{i} = - Foo6{-r4x,x-}{i} - {} -Foo7{-r4y,x-}{i} = - Foo7{-r4y,x-}{i} - {} -Foo8{-r4z,x-}{i} = - Foo8{-r4z,x-}{i} - {} -{- rec -} -AbsBinds [] [] [([], $d1{-r193,x-}, d.Eq_a14i)] - ==_a19a = - ==_a199 - AbsBinds [] [] [([], ==_a199, ==_a14l)] - ==_a14l - a_r10n b_r10p - = case - con2tag_Foo#_r101 - a_r10n - of - a#_r10r -> case - con2tag_Foo#_r101 - b_r10p - of - b#_r10t -> if a#_r10r GHC.==#{-79,p-}{I} b#_r10t then - PrelBase.True{-5E,p-}{i} - else - PrelBase.False{-58,p-}{i} - AbsBinds [] [] [([], /=_a198, /=_a14x)] - /=_a14x - a_r10x b_r10z - = PrelBase.not{-rho,p-} - ==_a19a - a_r10x b_r10z - d.Eq_a14i = - ({-dict-} [] [==_a199, /=_a198]) -{- rec -} +MkBar{-r4A,x-}{i} = + _/\_ a_tr4s b_tr4t -> \ tpl_B1 tpl_B2 tpl_B3 tpl_B4 tpl_B5 -> + MkBar{-r4A,x-}{i} + {_@_ a_tr4s _@_ b_tr4t tpl_B1 tpl_B2 tpl_B3 tpl_B4 tpl_B5} +Foo1{-r6,x-}{i} = Foo1{-r6,x-}{i} {} +Foo2{-r5,x-}{i} = Foo2{-r5,x-}{i} {} +Foo3{-r8,x-}{i} = Foo3{-r8,x-}{i} {} +Foo4{-ra,x-}{i} = Foo4{-ra,x-}{i} {} +Foo5{-rc,x-}{i} = Foo5{-rc,x-}{i} {} +Foo6{-re,x-}{i} = Foo6{-re,x-}{i} {} +Foo7{-rg,x-}{i} = Foo7{-rg,x-}{i} {} +Foo8{-ri,x-}{i} = Foo8{-ri,x-}{i} {} +AbsBinds [] [] [([], con2tag_Foo#_rUI, con2tag_Foo#_aYg)] + con2tag_Foo#_aYg Foo1{-r6,x-}{i} = 0# + con2tag_Foo#_aYg Foo2{-r5,x-}{i} = 1# + con2tag_Foo#_aYg Foo3{-r8,x-}{i} = 2# + con2tag_Foo#_aYg Foo4{-ra,x-}{i} = 3# + con2tag_Foo#_aYg Foo5{-rc,x-}{i} = 4# + con2tag_Foo#_aYg Foo6{-re,x-}{i} = 5# + con2tag_Foo#_aYg Foo7{-rg,x-}{i} = 6# + con2tag_Foo#_aYg Foo8{-ri,x-}{i} = 7# +AbsBinds [] [] [([], maxtag_Foo#_rUH, maxtag_Foo#_aYl)] + maxtag_Foo#_aYl = PrelBase.I#{-5b,w-}{i} 7# +AbsBinds [] [] [([], tag2con_Foo#_rUG, tag2con_Foo#_aYo)] + tag2con_Foo#_aYo (PrelBase.I#{-5b,w-}{i} 0#) = Foo1{-r6,x-}{i} + tag2con_Foo#_aYo (PrelBase.I#{-5b,w-}{i} 1#) = Foo2{-r5,x-}{i} + tag2con_Foo#_aYo (PrelBase.I#{-5b,w-}{i} 2#) = Foo3{-r8,x-}{i} + tag2con_Foo#_aYo (PrelBase.I#{-5b,w-}{i} 3#) = Foo4{-ra,x-}{i} + tag2con_Foo#_aYo (PrelBase.I#{-5b,w-}{i} 4#) = Foo5{-rc,x-}{i} + tag2con_Foo#_aYo (PrelBase.I#{-5b,w-}{i} 5#) = Foo6{-re,x-}{i} + tag2con_Foo#_aYo (PrelBase.I#{-5b,w-}{i} 6#) = Foo7{-rg,x-}{i} + tag2con_Foo#_aYo (PrelBase.I#{-5b,w-}{i} 7#) = Foo8{-ri,x-}{i} + tag2con_Foo#_aYo _ + = IOBase.error{-87,w-} Foo{-r4z,x-} "Urk! in TcGenDeriv" +AbsBinds [] [] [([], $d1{-r13o,x-}, d.Eq_aYA)] + ==_a13w = ==_a13x + AbsBinds [] [] [([], ==_a13x, ==_aYE)] + ==_aYE a_rV5 b_rV6 + = case con2tag_Foo#_rUI a_rV5 of + a#_rV8 + -> case con2tag_Foo#_rUI b_rV6 of + b#_rVa + -> if a#_rV8 GHC.==#{-79,w-}{I} b#_rVa then + PrelBase.True{-5E,w-}{i} + else + PrelBase.False{-58,w-}{i} + AbsBinds [] [] [([], /=_a13y, /=_aYT)] + /=_aYT a_rVe b_rVf = PrelBase.not{-ri1,p-} ==_a13w a_rVe b_rVf + d.Eq_aYA = ({-dict-} [] [==_a13x, /=_a13y]) AbsBinds -[a{-a191-}, b{-a192-}] +[ta13m, ta13n] [] -[([a{-a191-}, b{-a192-}], $d2{-r19b,x-}, d.Eval_a14N)] - d.Eval_a14N = - ({-dict-} [] []) -{- rec -} -AbsBinds [] [] [([], $d3{-r19c,x-}, d.Eval_a14S)] - d.Eval_a14S = - ({-dict-} [] []) -{- rec -} -AbsBinds [] [] [([], $d4{-r19d,x-}, d.Ord_a14X)] - d.Eq_a16H = - $d1{-r193,x-} - compare_a19q = - compare_a19k - compare_a19p = - compare_a19k - compare_a19o = - compare_a19k - compare_a19n = - compare_a19k - compare_a19m = - compare_a19k - compare_a19l = - compare_a19k - AbsBinds [] [] [([], compare_a19k, compare_a150)] - compare_a150 - a_r11y b_r11A - = case - con2tag_Foo#_r101 - a_r11y - of - a#_r11G -> case - con2tag_Foo#_r101 - b_r11A - of - b#_r11I -> if a#_r11G GHC.==#{-79,p-}{I} b#_r11I then - PrelBase.EQ{-rbX,p-}{i} - else - if a#_r11G GHC.<#{-7b,p-}{I} b#_r11I then - PrelBase.LT{-rbY,p-}{i} - else - PrelBase.GT{-rbZ,p-}{i} +[([ta13m, ta13n], $d2{-r13p,x-}, d.Eval_aZ7)] + d.Eval_aZ7 = ({-dict-} [] []) +AbsBinds [] [] [([], $d3{-r13q,x-}, d.Eval_aZc)] + d.Eval_aZc = ({-dict-} [] []) +AbsBinds [] [] [([], $d4{-r13r,x-}, d.Ord_aZh)] + d.Eq_a110 = $d1{-r13o,x-} + compare_a13z = compare_a13F + compare_a13A = compare_a13F + compare_a13B = compare_a13F + compare_a13C = compare_a13F + compare_a13D = compare_a13F + compare_a13E = compare_a13F + AbsBinds [] [] [([], compare_a13F, compare_aZl)] + compare_aZl a_rW8 b_rW9 + = case con2tag_Foo#_rUI a_rW8 of + a#_rWe + -> case con2tag_Foo#_rUI b_rW9 of + b#_rWg + -> if a#_rWe GHC.==#{-79,w-}{I} b#_rWg then + PrelBase.EQ{-rb0,p-}{i} + else + if a#_rWe GHC.<#{-7b,w-}{I} b#_rWg then + PrelBase.LT{-rb1,p-}{i} + else + PrelBase.GT{-rb2,p-}{i} where {- nonrec -} - AbsBinds - [t{-a15e-}, t{-a15g-}] - [] - [([t{-a15e-}, t{-a15g-}], cmp_eq_r11C, cmp_eq_a154)] - cmp_eq_a154 - _ _ = PrelBase.EQ{-rbX,p-}{i} + AbsBinds [taZE, taZG] [] [([taZE, taZG], cmp_eq_rWb, cmp_eq_aZp)] + cmp_eq_aZp _ _ = PrelBase.EQ{-rb0,p-}{i} {- nonrec -} - AbsBinds [] [] [([], <_a19j, <_a15q)] - <_a15q - a_r10G b_r10I - = case - compare_a19q - a_r10G b_r10I - of - PrelBase.LT{-rbY,p-}{i} - -> PrelBase.True{-5E,p-}{i} - PrelBase.EQ{-rbX,p-}{i} - -> PrelBase.False{-58,p-}{i} - PrelBase.GT{-rbZ,p-}{i} - -> PrelBase.False{-58,p-}{i} - AbsBinds [] [] [([], <=_a19i, <=_a15D)] - <=_a15D - a_r10P b_r10R - = case - compare_a19p - a_r10P b_r10R - of - PrelBase.LT{-rbY,p-}{i} - -> PrelBase.True{-5E,p-}{i} - PrelBase.EQ{-rbX,p-}{i} - -> PrelBase.True{-5E,p-}{i} - PrelBase.GT{-rbZ,p-}{i} - -> PrelBase.False{-58,p-}{i} - AbsBinds [] [] [([], >=_a19h, >=_a15Q)] - >=_a15Q - a_r10Y b_r110 - = case - compare_a19o - a_r10Y b_r110 - of - PrelBase.LT{-rbY,p-}{i} - -> PrelBase.False{-58,p-}{i} - PrelBase.EQ{-rbX,p-}{i} - -> PrelBase.True{-5E,p-}{i} - PrelBase.GT{-rbZ,p-}{i} - -> PrelBase.True{-5E,p-}{i} - AbsBinds [] [] [([], >_a19g, >_a163)] - >_a163 - a_r117 b_r119 - = case - compare_a19n - a_r117 b_r119 - of - PrelBase.LT{-rbY,p-}{i} - -> PrelBase.False{-58,p-}{i} - PrelBase.EQ{-rbX,p-}{i} - -> PrelBase.False{-58,p-}{i} - PrelBase.GT{-rbZ,p-}{i} - -> PrelBase.True{-5E,p-}{i} - AbsBinds [] [] [([], max_a19f, max_a16g)] - max_a16g - a_r11g b_r11i - = case - compare_a19m - a_r11g b_r11i - of - PrelBase.LT{-rbY,p-}{i} - -> b_r11i - PrelBase.EQ{-rbX,p-}{i} - -> a_r11g - PrelBase.GT{-rbZ,p-}{i} - -> a_r11g - AbsBinds [] [] [([], min_a19e, min_a16v)] - min_a16v - a_r11p b_r11r - = case - compare_a19l - a_r11p b_r11r - of - PrelBase.LT{-rbY,p-}{i} - -> a_r11p - PrelBase.EQ{-rbX,p-}{i} - -> b_r11r - PrelBase.GT{-rbZ,p-}{i} - -> b_r11r - d.Ord_a14X = + {- nonrec -} + AbsBinds [] [] [([], <_a13G, <_aZT)] + <_aZT a_rVm b_rVn + = case compare_a13z a_rVm b_rVn of + PrelBase.LT{-rb1,p-}{i} -> PrelBase.True{-5E,w-}{i} + PrelBase.EQ{-rb0,p-}{i} -> PrelBase.False{-58,w-}{i} + PrelBase.GT{-rb2,p-}{i} -> PrelBase.False{-58,w-}{i} + AbsBinds [] [] [([], <=_a13H, <=_a105)] + <=_a105 a_rVu b_rVv + = case compare_a13A a_rVu b_rVv of + PrelBase.LT{-rb1,p-}{i} -> PrelBase.True{-5E,w-}{i} + PrelBase.EQ{-rb0,p-}{i} -> PrelBase.True{-5E,w-}{i} + PrelBase.GT{-rb2,p-}{i} -> PrelBase.False{-58,w-}{i} + AbsBinds [] [] [([], >=_a13I, >=_a10h)] + >=_a10h a_rVC b_rVD + = case compare_a13B a_rVC b_rVD of + PrelBase.LT{-rb1,p-}{i} -> PrelBase.False{-58,w-}{i} + PrelBase.EQ{-rb0,p-}{i} -> PrelBase.True{-5E,w-}{i} + PrelBase.GT{-rb2,p-}{i} -> PrelBase.True{-5E,w-}{i} + AbsBinds [] [] [([], >_a13J, >_a10t)] + >_a10t a_rVK b_rVL + = case compare_a13C a_rVK b_rVL of + PrelBase.LT{-rb1,p-}{i} -> PrelBase.False{-58,w-}{i} + PrelBase.EQ{-rb0,p-}{i} -> PrelBase.False{-58,w-}{i} + PrelBase.GT{-rb2,p-}{i} -> PrelBase.True{-5E,w-}{i} + AbsBinds [] [] [([], max_a13K, max_a10F)] + max_a10F a_rVS b_rVT + = case compare_a13D a_rVS b_rVT of + PrelBase.LT{-rb1,p-}{i} -> b_rVT + PrelBase.EQ{-rb0,p-}{i} -> a_rVS + PrelBase.GT{-rb2,p-}{i} -> a_rVS + AbsBinds [] [] [([], min_a13L, min_a10R)] + min_a10R a_rW0 b_rW1 + = case compare_a13E a_rW0 b_rW1 of + PrelBase.LT{-rb1,p-}{i} -> a_rW0 + PrelBase.EQ{-rb0,p-}{i} -> b_rW1 + PrelBase.GT{-rb2,p-}{i} -> b_rW1 + d.Ord_aZh = ({-dict-} - [d.Eq_a16H] - [compare_a19k, <_a19j, <=_a19i, >=_a19h, >_a19g, max_a19f, min_a19e]) -{- rec -} -AbsBinds [] [] [([], $d5{-r19r,x-}, d.Show_a16O)] - showsPrec_a19u = - showsPrec_a19t - AbsBinds [] [] [([], showsPrec_a19t, showsPrec_a16R)] - showsPrec_a16R - a_r11N Foo1{-r4t,x-}{i} - = PrelBase.showString{-rjF,p-} - "Foo1" - showsPrec_a16R - a_r11Q Foo2{-r4s,x-}{i} - = PrelBase.showString{-rjF,p-} - "Foo2" - showsPrec_a16R - a_r11T Foo3{-r4u,x-}{i} - = PrelBase.showString{-rjF,p-} - "Foo3" - showsPrec_a16R - a_r11W Foo4{-r4v,x-}{i} - = PrelBase.showString{-rjF,p-} - "Foo4" - showsPrec_a16R - a_r11Z Foo5{-r4w,x-}{i} - = PrelBase.showString{-rjF,p-} - "Foo5" - showsPrec_a16R - a_r122 Foo6{-r4x,x-}{i} - = PrelBase.showString{-rjF,p-} - "Foo6" - showsPrec_a16R - a_r125 Foo7{-r4y,x-}{i} - = PrelBase.showString{-rjF,p-} - "Foo7" - showsPrec_a16R - a_r128 Foo8{-r4z,x-}{i} - = PrelBase.showString{-rjF,p-} - "Foo8" - AbsBinds [] [] [([], showList_a19s, showList_a173)] - showList_a173 - = PrelBase.showList__{-r4G,p-} - Foo{-r4J,x-} - showsPrec_a19u - lit_a196 - d.Show_a16O = - ({-dict-} [] [showsPrec_a19t, showList_a19s]) -{- rec -} -AbsBinds [] [] [([], $d6{-r19v,x-}, d.Ix_a17k)] - d.Show_a18G = - $d5{-r19r,x-} - d.Ord_a18H = - $d4{-r19d,x-} - inRange_a19z = - inRange_a19w - AbsBinds [] [] [([], range_a19y, range_a17n)] - range_a17n - (a_r12g, b_r12h) - = case - con2tag_Foo#_r101 - a_r12g - of - a#_r12j -> case - con2tag_Foo#_r101 - b_r12h - of - b#_r12l -> map_a195 - [PrelBase.Int{-3g,p-}, Foo{-r4J,x-}] - tag2con_Foo#_rZZ - enumFromTo_a194 - PrelBase.I#{-5b,p-}{i} - a#_r12j - PrelBase.I#{-5b,p-}{i} - b#_r12l - AbsBinds [] [] [([], index_a19x, index_a17V)] - index_a17V - (c_r12p@(a_r12q, b_r12r)) d_r12t - = if inRange_a19z - c_r12p d_r12t then - case - con2tag_Foo#_r101 - a_r12q - of - a#_r12v -> case - con2tag_Foo#_r101 - d_r12t - of - d#_r12x -> case d#_r12x GHC.-#{-7E,p-}{I} a#_r12v of - c_r12z -> PrelBase.I#{-5b,p-}{i} - c_r12z - else - IOBase.error{-87,p-} - PrelBase.Int{-3g,p-} - "Ix.Foo.index: out of range\n" - AbsBinds [] [] [([], inRange_a19w, inRange_a18o)] - inRange_a18o - (a_r12D, b_r12E) c_r12G - = case - con2tag_Foo#_r101 - a_r12D - of - a#_r12I -> case - con2tag_Foo#_r101 - b_r12E - of - b#_r12K -> case - con2tag_Foo#_r101 - c_r12G - of - c#_r12M -> if c#_r12M - GHC.>=#{-78,p-}{I} a#_r12I then - c#_r12M - GHC.<=#{-7c,p-}{I} b#_r12K - else - PrelBase.False{-58,p-}{i} - d.Ix_a17k = + [d.Eq_a110] + [compare_a13F, <_a13G, <=_a13H, >=_a13I, >_a13J, max_a13K, min_a13L]) +AbsBinds [] [] [([], $d5{-r13s,x-}, d.Show_a117)] + showsPrec_a13M = showsPrec_a13N + AbsBinds [] [] [([], showsPrec_a13N, showsPrec_a11b)] + showsPrec_a11b a_rWl Foo1{-r6,x-}{i} + = PrelBase.showString{-rif,p-} "Foo1" + showsPrec_a11b a_rWn Foo2{-r5,x-}{i} + = PrelBase.showString{-rif,p-} "Foo2" + showsPrec_a11b a_rWp Foo3{-r8,x-}{i} + = PrelBase.showString{-rif,p-} "Foo3" + showsPrec_a11b a_rWr Foo4{-ra,x-}{i} + = PrelBase.showString{-rif,p-} "Foo4" + showsPrec_a11b a_rWt Foo5{-rc,x-}{i} + = PrelBase.showString{-rif,p-} "Foo5" + showsPrec_a11b a_rWv Foo6{-re,x-}{i} + = PrelBase.showString{-rif,p-} "Foo6" + showsPrec_a11b a_rWx Foo7{-rg,x-}{i} + = PrelBase.showString{-rif,p-} "Foo7" + showsPrec_a11b a_rWz Foo8{-ri,x-}{i} + = PrelBase.showString{-rif,p-} "Foo8" + AbsBinds [] [] [([], showList_a13O, showList_a11o)] + showList_a11o = PrelBase.showList__{-r4x,p-} + Foo{-r4z,x-} showsPrec_a13M PrelBase.I#{-5b,w-}{i} 0# + d.Show_a117 = ({-dict-} [] [showsPrec_a13N, showList_a13O]) +AbsBinds [] [] [([], $d6{-r13t,x-}, d.Ix_a11z)] + d.Show_a136 = $d5{-r13s,x-} + d.Ord_a137 = $d4{-r13r,x-} + inRange_a13P = inRange_a13S + AbsBinds [] [] [([], range_a13Q, range_a11D)] + range_a11D (a_rWH, b_rWI) + = case con2tag_Foo#_rUI a_rWH of + a#_rWK + -> case con2tag_Foo#_rUI b_rWI of + b#_rWM + -> map_a13u [PrelBase.Int{-3g,W-}, Foo{-r4z,x-}] tag2con_Foo#_rUG + enumFromTo_a13v PrelBase.I#{-5b,w-}{i} a#_rWK + PrelBase.I#{-5b,w-}{i} b#_rWM + AbsBinds [] [] [([], index_a13R, index_a12d)] + index_a12d (c_rWQ@(a_rWR, b_rWS)) d_rWT + = if inRange_a13P c_rWQ d_rWT then + case con2tag_Foo#_rUI a_rWR of + a#_rWV + -> case con2tag_Foo#_rUI d_rWT of + d#_rWX + -> case d#_rWX GHC.-#{-7E,w-}{I} a#_rWV of + c_rWZ -> PrelBase.I#{-5b,w-}{i} c_rWZ + else + IOBase.error{-87,w-} + PrelBase.Int{-3g,W-} "Ix.Foo.index: out of range\n" + AbsBinds [] [] [([], inRange_a13S, inRange_a12K)] + inRange_a12K (a_rX3, b_rX4) c_rX5 + = case con2tag_Foo#_rUI a_rX3 of + a#_rX7 + -> case con2tag_Foo#_rUI b_rX4 of + b#_rX9 + -> case con2tag_Foo#_rUI c_rX5 of + c#_rXb + -> if c#_rXb GHC.>=#{-78,w-}{I} a#_rX7 then + c#_rXb GHC.<=#{-7c,w-}{I} b#_rX9 + else + PrelBase.False{-58,w-}{i} + d.Ix_a11z = ({-dict-} - [d.Show_a18G, d.Ord_a18H] - [range_a19y, index_a19x, inRange_a19w]) -{- nonrec -} -d.Num_a18U = - PrelBase.$d3{-rdj,p-} -fromInt_a197 = - PrelBase.fromInt{-8R,p-} - PrelBase.Int{-3g,p-} - d.Num_a18U -lit_a196 = - fromInt_a197 - PrelBase.I#{-5b,p-}{i} - 0# -d.Functor_a18X = - PrelBase.$d25{-rde,p-} -map_a195 = - PrelBase.map{-reK,p-} - PrelBase.[]{-3j,p-} - d.Functor_a18X -d.Enum_a190 = - PrelBase.$d5{-rdF,p-} -enumFromTo_a194 = - PrelBase.enumFromTo{-8W,p-} - PrelBase.Int{-3g,p-} - d.Enum_a190 -{- nonrec -} -AbsBinds [] [] [([], con2tag_Foo#_r101, con2tag_Foo#_a141)] - con2tag_Foo#_a141 - Foo1{-r4t,x-}{i} - = 0# - con2tag_Foo#_a141 - Foo2{-r4s,x-}{i} - = 1# - con2tag_Foo#_a141 - Foo3{-r4u,x-}{i} - = 2# - con2tag_Foo#_a141 - Foo4{-r4v,x-}{i} - = 3# - con2tag_Foo#_a141 - Foo5{-r4w,x-}{i} - = 4# - con2tag_Foo#_a141 - Foo6{-r4x,x-}{i} - = 5# - con2tag_Foo#_a141 - Foo7{-r4y,x-}{i} - = 6# - con2tag_Foo#_a141 - Foo8{-r4z,x-}{i} - = 7# -{- nonrec -} -{- nonrec -} -AbsBinds [] [] [([], maxtag_Foo#_r100, maxtag_Foo#_a145)] - maxtag_Foo#_a145 - = PrelBase.I#{-5b,p-}{i} - 7# -{- nonrec -} -{- nonrec -} -AbsBinds [] [] [([], tag2con_Foo#_rZZ, tag2con_Foo#_a149)] - tag2con_Foo#_a149 - (PrelBase.I#{-5b,p-}{i} 0#) - = Foo1{-r4t,x-}{i} - tag2con_Foo#_a149 - (PrelBase.I#{-5b,p-}{i} 1#) - = Foo2{-r4s,x-}{i} - tag2con_Foo#_a149 - (PrelBase.I#{-5b,p-}{i} 2#) - = Foo3{-r4u,x-}{i} - tag2con_Foo#_a149 - (PrelBase.I#{-5b,p-}{i} 3#) - = Foo4{-r4v,x-}{i} - tag2con_Foo#_a149 - (PrelBase.I#{-5b,p-}{i} 4#) - = Foo5{-r4w,x-}{i} - tag2con_Foo#_a149 - (PrelBase.I#{-5b,p-}{i} 5#) - = Foo6{-r4x,x-}{i} - tag2con_Foo#_a149 - (PrelBase.I#{-5b,p-}{i} 6#) - = Foo7{-r4y,x-}{i} - tag2con_Foo#_a149 - (PrelBase.I#{-5b,p-}{i} 7#) - = Foo8{-r4z,x-}{i} - tag2con_Foo#_a149 - _ = IOBase.error{-87,p-} - Foo{-r4J,x-} - "Urk! in TcGenDeriv" -{- nonrec -} + [d.Show_a136, d.Ord_a137] + [range_a13Q, index_a13R, inRange_a13S]) +d.Functor_a13i = PrelBase.$d26{-rc9,p-} +map_a13u = PrelBase.map{-rh9,p-} PrelBase.[]{-3j,W-} d.Functor_a13i +d.Enum_a13l = PrelBase.$d6{-rcJ,p-} +enumFromTo_a13v = + PrelBase.enumFromTo{-8W,p-} PrelBase.Int{-3g,W-} d.Enum_a13l NOTE: Simplifier still going after 4 iterations; bailing out. ghc: module version changed to 1; reason: no old .hi file +_interface_ ShouldSucceed 1 +_instance_modules_ +ArrBase IO PrelNum +_usages_ +Ix 1 :: $d4 1 $d5 1 $d6 1 $d7 1 $d8 1 $d9 1 Ix 1; +PrelBase 1 :: $d1 1 $d11 1 $d12 1 $d14 1 $d15 1 $d16 1 $d2 1 $d22 1 $d24 1 $d25 1 $d26 1 $d27 1 $d28 1 $d3 1 $d31 1 $d32 1 $d33 1 $d34 1 $d35 1 $d38 1 $d39 1 $d4 1 $d40 1 $d42 1 $d43 1 $d45 1 $d46 1 $d47 1 $d50 1 $d51 1 $d52 1 $d55 1 $d56 1 $d6 1 $d7 1 $d8 1 $d9 1 $m- 1 $m/= 1 $m< 1 $m<= 1 $m> 1 $m>= 1 $m>> 1 $mcompare 1 $menumFromThenTo 1 $menumFromTo 1 $mfromInt 1 $mmax 1 $mmin 1 $mshowList 1 && 1 . 1 not 1 showList__ 1 showParen 1 showSpace 1 showString 1 Enum 1 Eq 1 Eval 1 Functor 1 Monad 1 MonadZero 1 Num 1 Ord 1 Ordering 1 Ordering 1 Show 1 ShowS 1 String 1; +PrelNum 1 :: $d10 1 $d16 1 $d17 1 $d18 1 $d28 1 $d29 1 $d30 1 $d33 1 $d34 1 $d35 1 $d8 1; +PrelTup 1 :: $d13 1 $d4 1 $d49 1 $d9 1; +_exports_ +ShouldSucceed Bar(MkBar) Foo(Foo1 Foo2 Foo3 Foo4 Foo5 Foo6 Foo7 Foo8); +_instances_ +instance {PrelBase.Eq Foo} = $d1; +instance _forall_ [a b] => {PrelBase.Eval (Bar a b)} = $d2; +instance {PrelBase.Eval Foo} = $d3; +instance {PrelBase.Ord Foo} = $d4; +instance {PrelBase.Show Foo} = $d5; +instance {Ix.Ix Foo} = $d6; +_declarations_ +1 $d1 _:_ {PrelBase.Eq Foo} ;; +1 $d2 _:_ _forall_ [a b] => {PrelBase.Eval (Bar a b)} ;; +1 $d3 _:_ {PrelBase.Eval Foo} ;; +1 $d4 _:_ {PrelBase.Ord Foo} ;; +1 $d5 _:_ {PrelBase.Show Foo} ;; +1 $d6 _:_ {Ix.Ix Foo} ;; +1 data Bar a b = MkBar a PrelBase.Int b PrelBase.Integer a ; +1 data Foo = Foo1 | Foo2 | Foo3 | Foo4 | Foo5 | Foo6 | Foo7 | Foo8 ; diff --git a/ghc/tests/deriving/should_compile/drv007.stderr b/ghc/tests/deriving/should_compile/drv007.stderr deleted file mode 100644 index 5648ec0..0000000 --- a/ghc/tests/deriving/should_compile/drv007.stderr +++ /dev/null @@ -1,13 +0,0 @@ - -drv007.hs:2: No instance for class - `PrelBase.Eq' - at type - `PrelBase.Int -> PrelBase.Int' - -drv007.hs:4: No instance for: - `PrelBase.Eq (PrelBase.Int -> PrelBase.Int)' - drv007.hs:4: - at a use of an overloaded identifier: `PrelBase.==' - - -Compilation had errors diff --git a/ghc/tests/deriving/should_fail/Makefile b/ghc/tests/deriving/should_fail/Makefile new file mode 100644 index 0000000..fb0a5f3 --- /dev/null +++ b/ghc/tests/deriving/should_fail/Makefile @@ -0,0 +1,14 @@ +TOP = ../../../.. +include $(TOP)/mk/boilerplate.mk + +HS_SRCS = $(wildcard *.hs) + +SRC_RUNTEST_OPTS += -o1 $*.stdout -o2 $*.stderr -x 1 +HC_OPTS += -noC + +%.o : %.hs + $(RUNTEST) $(HC) $(RUNTEST_OPTS) -- $(HC_OPTS) -c $< -o $@ + +all :: $(HS_OBJS) + +include $(TOP)/mk/target.mk diff --git a/ghc/tests/deriving/should_fail/drvfail004.hs b/ghc/tests/deriving/should_fail/drvfail004.hs new file mode 100644 index 0000000..cbdd96f --- /dev/null +++ b/ghc/tests/deriving/should_fail/drvfail004.hs @@ -0,0 +1,8 @@ +--!!! deriving Ord without deriving Eq +-- +module ShouldFail where + +data Foo a b + = C1 a Int + | C2 b Double + deriving Ord diff --git a/ghc/tests/deriving/should_fail/drvfail004.stderr b/ghc/tests/deriving/should_fail/drvfail004.stderr new file mode 100644 index 0000000..b9a7a56 --- /dev/null +++ b/ghc/tests/deriving/should_fail/drvfail004.stderr @@ -0,0 +1,7 @@ + +drvfail004.hs:5: No instance for: `PrelBase.Eq (Foo taDH taDI)' + arising from an instance declaration at drvfail004.hs:5 + When checking superclass constraints of an instance declaration + + +Compilation had errors diff --git a/ghc/tests/deriving/should_compile/drv007.hs b/ghc/tests/deriving/should_fail/drvfail007.hs similarity index 80% rename from ghc/tests/deriving/should_compile/drv007.hs rename to ghc/tests/deriving/should_fail/drvfail007.hs index ba1a864..87efc24 100644 --- a/ghc/tests/deriving/should_compile/drv007.hs +++ b/ghc/tests/deriving/should_fail/drvfail007.hs @@ -1,4 +1,4 @@ --!!! buggy deriving with function type, reported by Sigbjorn Finne -module ShouldSucceed where +module ShouldFail where data Foo = Foo (Int -> Int) deriving Eq diff --git a/ghc/tests/deriving/should_fail/drvfail007.stderr b/ghc/tests/deriving/should_fail/drvfail007.stderr new file mode 100644 index 0000000..43c09b1 --- /dev/null +++ b/ghc/tests/deriving/should_fail/drvfail007.stderr @@ -0,0 +1,10 @@ + +drvfail007.hs:2: No instance for `PrelBase.Eq PrelBase.Int + -> PrelBase.Int' + +drvfail007.hs:4: No instance for: `PrelBase.Eq (PrelBase.Int + -> PrelBase.Int)' + arising from use of `PrelBase.==' at drvfail007.hs:4 + + +Compilation had errors diff --git a/ghc/tests/deriving/should_run/Makefile b/ghc/tests/deriving/should_run/Makefile new file mode 100644 index 0000000..4c05806 --- /dev/null +++ b/ghc/tests/deriving/should_run/Makefile @@ -0,0 +1,19 @@ +TOP = ../../../.. +include $(TOP)/mk/boilerplate.mk + +HS_SRCS = $(wildcard *.hs) +BINS = $(patsubst %.o,%,$(HS_OBJS)) +RUNTESTS = $(patsubst %,%.run,$(BINS)) + +SRC_RUNTEST_OPTS += -o1 $*.stdout -o2 $*.stderr -x 0 +HC_OPTS += -dcore-lint + +all :: $(RUNTESTS) + +%.run : % + $(RUNTEST) $< $(RUNTEST_OPTS) + +% : %.o + $(HC) $(HC_OPTS) $< -o $@ + +include $(TOP)/mk/target.mk diff --git a/ghc/tests/deriving/should_run/drvrun001.hs b/ghc/tests/deriving/should_run/drvrun001.hs index 7b68599..b6bd259 100644 --- a/ghc/tests/deriving/should_run/drvrun001.hs +++ b/ghc/tests/deriving/should_run/drvrun001.hs @@ -4,5 +4,10 @@ newtype Age = MkAge Int deriving (Eq, Show) instance Num Age where (+) (MkAge a) (MkAge b) = MkAge (a+b) + (*) = undefined + negate = undefined + abs = undefined + signum = undefined + fromInteger = undefined main = print (MkAge 3 + MkAge 5) -- 1.7.10.4