ghc/compiler/tests/rename/bevan-bug-1/bevan-bug-1.stderr

   1 Typechecked:
   2 AbsBinds [] [] [(t_source_pos.t2, Lexer_Ops.t_source_pos)]
   3     {- nonrec -}
   4     t_source_pos.t2 ::
   5         (Source_Position.Source_Position -> Source_Position.Source_Position)
   6         -> Lexer_State.Lexer_State -> ((), Lexer_State.Lexer_State)
   7     t_source_pos.t2
   8         transformer.r49
   9                 = (Lexer_Combinators.and_with
  10                        [Source_Position.Source_Position, ()])
  11                       Lexer_State.p_source_pos
  12                       (\ pos.r50 -> Lexer_State.i_source_pos
  13                                         (transformer.r49 pos.r50))
  14 AbsBinds [] [] [(t_buffer.t11, Lexer_Ops.t_buffer)]
  15     {- nonrec -}
  16     t_buffer.t11 ::
  17         (Lexer_Buffer.Lexer_Buffer -> Lexer_Buffer.Lexer_Buffer)
  18         -> Lexer_State.Lexer_State -> ((), Lexer_State.Lexer_State)
  19     t_buffer.t11
  20         transformer.r51
  21                 = (Lexer_Combinators.and_with [Lexer_Buffer.Lexer_Buffer, ()])
  22                       Lexer_State.p_buffer
  23                       (\ buff.r52 -> Lexer_State.i_buffer
  24                                          (transformer.r51 buff.r52))
  25 AbsBinds [] [] [(buffer_len.t20, Lexer_Ops.buffer_len)]
  26     {- nonrec -}
  27     buffer_len.t20 :: Lexer_State.Lexer_State -> (Int, Lexer_State.Lexer_State)
  28     buffer_len.t20
  29         = (Lexer_Combinators.and_with [Lexer_Buffer.Lexer_Buffer, Int])
  30               Lexer_State.p_buffer
  31               (\ buff.r53 -> (Lexer_Combinators.return Int)
  32                                  (Lexer_Buffer.len buff.r53))
  33 AbsBinds [] [] [(decimal_to_int.t28, Lexer_Ops.decimal_to_int)]
  34     {- nonrec -}
  35     decimal_to_int.t28 ::
  36         Lexer_State.Lexer_State
  37         -> (Oberon_Integer.Oberon_Integer, Lexer_State.Lexer_State)
  38     decimal_to_int.t28
  39         = (Lexer_Combinators.and_with
  40                [Lexer_Buffer.Lexer_Buffer, Oberon_Integer.Oberon_Integer])
  41               Lexer_State.p_buffer
  42               (\ buff.r54 -> (Lexer_Combinators.return
  43                                   Oberon_Integer.Oberon_Integer)
  44                                  (Oberon_Integer.from_decimal_string
  45                                       (Lexer_Buffer.to_string buff.r54)))
  46 AbsBinds [] [] [(flush_buffer.t36, Lexer_Ops.flush_buffer)]
  47     {- nonrec -}
  48     flush_buffer.t36 :: Lexer_State.Lexer_State -> ((), Lexer_State.Lexer_State)
  49     flush_buffer.t36 = Lexer_Ops.t_buffer Lexer_Buffer.flush
  50 AbsBinds [] [] [(hex_to_int.t39, Lexer_Ops.hex_to_int)]
  51     {- nonrec -}
  52     hex_to_int.t39 ::
  53         Lexer_State.Lexer_State
  54         -> (Oberon_Integer.Oberon_Integer, Lexer_State.Lexer_State)
  55     hex_to_int.t39
  56         = (Lexer_Combinators.and_with
  57                [Lexer_Buffer.Lexer_Buffer, Oberon_Integer.Oberon_Integer])
  58               Lexer_State.p_buffer
  59               (\ buff.r55 -> (Lexer_Combinators.return
  60                                   Oberon_Integer.Oberon_Integer)
  61                                  (Oberon_Integer.from_hex_string
  62                                       (Lexer_Buffer.to_string buff.r55)))
  63 AbsBinds [] [] [(move_input_column.t47, Lexer_Ops.move_input_column)]
  64     {- nonrec -}
  65     move_input_column.t47 :: Int -> Lexer_State.Lexer_Action ()
  66     move_input_column.t47
  67         dist.r56 = Lexer_Ops.t_source_pos
  68                        ((flip [Source_Position.Source_Position,
  69                                Int,
  70                                Source_Position.Source_Position])
  71                             Source_Position.shift_column dist.r56)
  72 AbsBinds [] [] [(next_input_line.t54, Lexer_Ops.next_input_line)]
  73     {- nonrec -}
  74     next_input_line.t54 ::
  75         Lexer_State.Lexer_State -> ((), Lexer_State.Lexer_State)
  76     next_input_line.t54 = Lexer_Ops.t_source_pos Source_Position.next_line
  77 AbsBinds [] [] [(store_char.t57, Lexer_Ops.store_char)]
  78     {- nonrec -}
  79     store_char.t57 :: Char -> Lexer_State.Lexer_Action ()
  80     store_char.t57
  81         c.r57 = Lexer_Ops.t_buffer (Lexer_Buffer.add c.r57)
  82 AbsBinds [] [] [(to_char.t61, Lexer_Ops.to_char)]
  83     (toInteger.t79, int2Integer)
  84     {- nonrec -}
  85     to_char.t61 ::
  86         Lexer_State.Lexer_State
  87         -> (Oberon_Integer.Oberon_Integer, Lexer_State.Lexer_State)
  88     to_char.t61
  89         = (Lexer_Combinators.and_with
  90                [Lexer_Buffer.Lexer_Buffer, Oberon_Integer.Oberon_Integer])
  91               Lexer_State.p_buffer
  92               (\ buff.r58 -> (Lexer_Combinators.return
  93                                   Oberon_Integer.Oberon_Integer)
  94                                  ((((.) [Lexer_Buffer.Lexer_Buffer,
  95                                          [Char],
  96                                          Oberon_Integer.Oberon_Integer])
  97                                        (((.) [[Char],
  98                                               Char,
  99                                               Oberon_Integer.Oberon_Integer])
 100                                             (((.) [Char,
 101                                                    Int,
 102                                                    Oberon_Integer.Oberon_Integer])
 103                                                  (((.) [Int,
 104                                                         Integer,
 105                                                         Oberon_Integer.Oberon_Integer])
 106                                                       Oberon_Integer.from_int
 107                                                       toInteger.t79)
 108                                                  ord)
 109                                             (head Char))
 110                                        Lexer_Buffer.to_string) buff.r58))
 111 AbsBinds [] [] [(to_id.t88, Lexer_Ops.to_id)]
 112     {- nonrec -}
 113     to_id.t88 ::
 114         Lexer_State.Lexer_State
 115         -> (Oberon_Id.Oberon_Id, Lexer_State.Lexer_State)
 116     to_id.t88
 117         = (Lexer_Combinators.and_with
 118                [Lexer_Buffer.Lexer_Buffer, Oberon_Id.Oberon_Id])
 119               Lexer_State.p_buffer
 120               (\ buff.r59 -> (Lexer_Combinators.return Oberon_Id.Oberon_Id)
 121                                  (Oberon_Id.from_string
 122                                       (Lexer_Buffer.to_string buff.r59)))
 123 AbsBinds [] [] [(to_real.t96, Lexer_Ops.to_real)]
 124     {- nonrec -}
 125     to_real.t96 ::
 126         Lexer_State.Lexer_State
 127         -> (Oberon_Real.Oberon_Real, Lexer_State.Lexer_State)
 128     to_real.t96
 129         = (Lexer_Combinators.and_with
 130                [Lexer_Buffer.Lexer_Buffer, Oberon_Real.Oberon_Real])
 131               Lexer_State.p_buffer
 132               (\ buff.r60 -> (Lexer_Combinators.return Oberon_Real.Oberon_Real)
 133                                  (Oberon_Real.from_string
 134                                       (Lexer_Buffer.to_string buff.r60)))
 135 AbsBinds [] [] [(to_string.t104, Lexer_Ops.to_string)]
 136     {- nonrec -}
 137     to_string.t104 ::
 138         Lexer_State.Lexer_State
 139         -> (Oberon_String.Oberon_String, Lexer_State.Lexer_State)
 140     to_string.t104
 141         = (Lexer_Combinators.and_with
 142                [Lexer_Buffer.Lexer_Buffer, Oberon_String.Oberon_String])
 143               Lexer_State.p_buffer
 144               (\ buff.r61 -> (Lexer_Combinators.return
 145                                   Oberon_String.Oberon_String)
 146                                  (Oberon_String.from_string
 147                                       (Lexer_Buffer.to_string buff.r61)))