/home/bollu/work/lean4-contrib/tests/bench$ elan toolchain link lean-contrib /home/bollu/work/lean4-contrib/build/release/stage2/
/home/bollu/work/lean4-contrib/tests/bench$ elan override set lean-contrib
info: override toolchain for '/home/bollu/work/lean4-contrib/tests/bench' set to 'lean-contrib'
/home/bollu/work/lean4-contrib/tests/bench$ 

  36.16%  exe.out  exe.out           [.] l_check
  20.60%  exe.out  exe.out           [.] lean_del
  13.17%  exe.out  exe.out           [.] l_make_x27
  12.07%  exe.out  exe.out           [.] lean_alloc_ctor_memory
   9.89%  exe.out  exe.out           [.] lean_free_small
   7.32%  exe.out  exe.out           [.] lean_alloc_small
   0.08%  exe.out  libc-2.33.so      [.] __memset_avx2_erms
   0.06%  exe.out  exe.out           [.] l_depth
   0.05%  exe.out  [kernel.vmlinux]  [k] check_preemption_disabled

  34.46%  exe-ref.out  exe-ref.out       [.] l_check
  24.58%  exe-ref.out  exe-ref.out       [.] lean_del
  16.53%  exe-ref.out  exe-ref.out       [.] l_make_x27.part.0
  12.46%  exe-ref.out  exe-ref.out       [.] lean_free_small
  10.69%  exe-ref.out  exe-ref.out       [.] lean_alloc_small
   0.45%  exe-ref.out  exe-ref.out       [.] l_sumT
   0.18%  exe-ref.out  exe-ref.out       [.] lean::allocator::alloc_page
   0.08%  exe-ref.out  [kernel.vmlinux]  [k] irqentry_exit_to_user_mode
   0.04%  exe-ref.out  ld-2.33.so        [.] _dl_lookup_symbol_x
   0.04%  exe-ref.out  [kernel.vmlinux]  [k] get_page_from_freelist
   0.04%  exe-ref.out  [kernel.vmlinux]  [k] free_unref_page_list

(ours)
  36.84%  exe.out  exe.out           [.] l_check
  18.98%  exe.out  exe.out           [.] lean_del
  13.57%  exe.out  exe.out           [.] l_make_x27
  11.43%  exe.out  exe.out           [.] lean_alloc_ctor_memory
   9.66%  exe.out  exe.out           [.] lean_free_small
   7.11%  exe.out  exe.out           [.] lean_alloc_small
   0.70%  exe.out  exe.out           [.] main
   0.37%  exe.out  libc-2.33.so      [.] __memset_avx2_erms
   0.17%  exe.out  [kernel.vmlinux]  [k] irqentry_exit_to_user_mode
   0.16%  exe.out  [kernel.vmlinux]  [k] check_preemption_disabled
   0.11%  exe.out  exe.out           [.] l_depth___lambda__1
   0.09%  exe.out  [kernel.vmlinux]  [k] clear_page_erms
   0.07%  exe.out  [kernel.vmlinux]  [k] native_irq_return_iret
   0.07%  exe.out  [kernel.vmlinux]  [k] error_entry
   0.05%  exe.out  [kernel.vmlinux]  [k] swapgs_restore_regs_and_return_to_usermode
   0.04%  exe.out  [kernel.vmlinux]  [k] get_page_from_freelist
   0.04%  exe.out  [kernel.vmlinux]  [k] __mod_memcg_state.part.0
   0.03%  exe.out  [kernel.vmlinux]  [k] handle_mm_fault
   0.03%  exe.out  [kernel.vmlinux]  [k] __mod_node_page_state
   0.03%  exe.out  [kernel.vmlinux]  [k] __mod_memcg_lruvec_state
   0.02%  exe.out  [kernel.vmlinux]  [k] __mod_lruvec_state
   0.02%  exe.out  [kernel.vmlinux]  [k] __free_one_page
   0.02%  exe.out  [kernel.vmlinux]  [k] sync_regs
   0.02%  exe.out  [kernel.vmlinux]  [k] mem_cgroup_charge
   0.02%  exe.out  [kernel.vmlinux]  [k] prep_new_page
   0.02%  exe.out  [kernel.vmlinux]  [k] __this_cpu_preempt_check
   0.02%  exe.out  [kernel.vmlinux]  [k] unmap_page_range

(theirs)
  34.81%  exe-ref.out  exe-ref.out         [.] l_check
  24.03%  exe-ref.out  exe-ref.out         [.] lean_del
  15.56%  exe-ref.out  exe-ref.out         [.] l_make_x27.part.0
  11.24%  exe-ref.out  exe-ref.out         [.] lean_free_small
  10.79%  exe-ref.out  exe-ref.out         [.] lean_alloc_small
   0.85%  exe-ref.out  exe-ref.out         [.] lean_mark_persistent
   0.47%  exe-ref.out  exe-ref.out         [.] l_depth___lambda__1___boxed
   0.41%  exe-ref.out  exe-ref.out         [.] lean::allocator::alloc_page
   0.17%  exe-ref.out  [kernel.vmlinux]    [k] check_preemption_disabled
   0.16%  exe-ref.out  [kernel.vmlinux]    [k] clear_page_erms
   0.15%  exe-ref.out  [kernel.vmlinux]    [k] irqentry_exit_to_user_mode
   0.08%  exe-ref.out  [kernel.vmlinux]    [k] error_entry
   0.07%  exe-ref.out  [kernel.vmlinux]    [k] try_charge
   0.07%  exe-ref.out  [kernel.vmlinux]    [k] native_irq_return_iret
   0.07%  exe-ref.out  [kernel.vmlinux]    [k] swapgs_restore_regs_and_return_to_usermode
   0.06%  exe-ref.out  [kernel.vmlinux]    [k] handle_mm_fault
   0.06%  exe-ref.out  [kernel.vmlinux]    [k] __mod_node_page_state
   0.05%  exe-ref.out  [kernel.vmlinux]    [k] __pagevec_lru_add_fn
   0.05%  exe-ref.out  [kernel.vmlinux]    [k] __free_one_page
   0.05%  exe-ref.out  [kernel.vmlinux]    [k] release_pages
   0.05%  exe-ref.out  [kernel.vmlinux]    [k] page_remove_rmap
   0.04%  exe-ref.out  [kernel.vmlinux]    [k] __mod_memcg_lruvec_state
   0.04%  exe-ref.out  [kernel.vmlinux]    [k] unmap_page_range
   0.03%  exe-ref.out  [kernel.vmlinux]    [k] kernel_init_free_pages
   0.03%  exe-ref.out  [kernel.vmlinux]    [k] __rcu_read_unlock
   0.03%  exe-ref.out  [kernel.vmlinux]    [k] get_page_from_freelist
   0.03%  exe-ref.out  [kernel.vmlinux]    [k] __mod_zone_page_state
   0.03%  exe-ref.out  [kernel.vmlinux]    [k] free_pages_and_swap_cache
   0.03%  exe-ref.out  [kernel.vmlinux]    [k] free_unref_page_list

https://gist.github.com/bollu/89b4b6f412433305022fbbbccd82614b
define i8* @l_even(i8* %0) local_unnamed_addr !dbg !7 {
  ...
  %9 = tail call i8* @l_odd(i8* %8), !dbg !19
  ...
}

define i8* @l_odd(i8* %0) local_unnamed_addr !dbg !23 {
  ...
  %9 = tail call i8* @l_even(i8* %8), !dbg !32
  ...  
}

56      in /home/bollu/work/lz/test/lambdapure/compile/<stdin>
(gdb) bt
#0  l_even () at /home/bollu/work/lz/test/lambdapure/compile/<stdin>:56
#1  0x0000000000406612 in l_odd () at /home/bollu/work/lz/test/lambdapure/compile/<stdin>:95
#2  0x000000000040659e in l_even () at /home/bollu/work/lz/test/lambdapure/compile/<stdin>:69
#3  0x0000000000406612 in l_odd () at /home/bollu/work/lz/test/lambdapure/compile/<stdin>:95
#4  0x000000000040659e in l_even () at /home/bollu/work/lz/test/lambdapure/compile/<stdin>:69
#5  0x0000000000406612 in l_odd () at /home/bollu/work/lz/test/lambdapure/compile/<stdin>:95
#6  0x000000000040659e in l_even () at /home/bollu/work/lz/test/lambdapure/compile/<stdin>:69
#7  0x0000000000406612 in l_odd () at /home/bollu/work/lz/test/lambdapure/compile/<stdin>:95
#8  0x000000000040659e in l_even () at /home/bollu/work/lz/test/lambdapure/compile/<stdin>:69
#9  0x000000000040685e in main_lean_custom_entrypoint_hack () at /home/bollu/work/lz/test/lambdapure/compile/<stdin>:223
#10 0x0000000000432d86 in main ()
(gdb)  

define i8* @l_even(i8* %0) local_unnamed_addr !dbg !7 {
  ...
  %9 = tail call i8* @l_odd(i8* %8), !dbg !19
  tail call void bitcast (void (%struct.lean_object*)* @lean_dec to void (i8*)*)(i8* %8), !dbg !20
  ret i8* %9, !dbg !21
}

(theirs)
  30.09%  exe-ref.out  exe-ref.out       [.] l_check
  20.28%  exe-ref.out  exe-ref.out       [.] l_make_x27.part.0
  18.12%  exe-ref.out  exe-ref.out       [.] lean_del
  11.48%  exe-ref.out  exe-ref.out       [.] lean_alloc_small
  10.27%  exe-ref.out  exe-ref.out       [.] lean_free_small
   2.63%  exe-ref.out  [kernel.vmlinux]  [k] clear_page_erms
   1.40%  exe-ref.out  ld-2.33.so        [.] _dl_relocate_object
   1.03%  exe-ref.out  [kernel.vmlinux]  [k] irqentry_exit_to_user_mode
   0.95%  exe-ref.out  exe-ref.out       [.] initialize_Init_Data_ByteArray_Basic
   0.82%  exe-ref.out  exe-ref.out       [.] lean_mark_persistent
   0.64%  exe-ref.out  [kernel.vmlinux]  [k] __memcg_kmem_charge_page
   0.64%  exe-ref.out  exe-ref.out       [.] lean::allocator::alloc_page
   0.41%  exe-ref.out  [kernel.vmlinux]  [k] unmap_page_range
   0.41%  exe-ref.out  [kernel.vmlinux]  [k] kmem_cache_alloc
   0.40%  exe-ref.out  [kernel.vmlinux]  [k] free_pcp_prepare
   0.40%  exe-ref.out  [kernel.vmlinux]  [k] free_unref_page_commit
   0.03%  perf         [kernel.vmlinux]  [k] perf_event_exec
   0.00%  perf         [kernel.vmlinux]  [k] intel_bts_enable_local
   0.00%  perf         [kernel.vmlinux]  [k] native_write_msr

(ours)
  31.02%  exe.out  exe.out           [.] l_check
  17.97%  exe.out  exe.out           [.] lean_del
  16.39%  exe.out  exe.out           [.] l_make_x27
  10.70%  exe.out  exe.out           [.] lean_alloc_small
   9.51%  exe.out  exe.out           [.] lean_alloc_ctor_memory
   6.81%  exe.out  exe.out           [.] lean_free_small
   1.49%  exe.out  libc-2.33.so      [.] __memset_avx2_erms
   1.05%  exe.out  [kernel.vmlinux]  [k] prep_new_page
   1.00%  exe.out  ld-2.33.so        [.] do_lookup_x
   0.94%  exe.out  exe.out           [.] main
   0.74%  exe.out  [kernel.vmlinux]  [k] clear_page_erms
   0.58%  exe.out  [kernel.vmlinux]  [k] unmap_page_range
   0.46%  exe.out  [kernel.vmlinux]  [k] __this_cpu_preempt_check
   0.43%  exe.out  [kernel.vmlinux]  [k] try_charge
   0.29%  exe.out  [kernel.vmlinux]  [k] native_irq_return_iret
   0.29%  exe.out  [kernel.vmlinux]  [k] __mod_node_page_state
   0.29%  exe.out  [kernel.vmlinux]  [k] __free_one_page
   0.03%  perf     [kernel.vmlinux]  [k] strrchr
   0.00%  perf     [kernel.vmlinux]  [k] native_sched_clock
   0.00%  perf     [kernel.vmlinux]  [k] native_write_msr

  16.74%  exe-ref.out  [kernel.vmlinux]  [k] swapgs_restore_regs_and_return_to_usermode
  14.09%  exe-ref.out  [kernel.vmlinux]  [k] clear_page_erms
  11.31%  exe-ref.out  [kernel.vmlinux]  [k] vma_interval_tree_insert
  11.19%  exe-ref.out  ld-2.33.so        [.] check_match
   9.33%  exe-ref.out  ld-2.33.so        [.] lookup_malloc_symbol
   7.63%  exe-ref.out  [kernel.vmlinux]  [k] handle_mm_fault
   6.56%  exe-ref.out  exe-ref.out       [.] initialize_Init_Data_Format_Basic
   6.29%  exe-ref.out  [kernel.vmlinux]  [k] page_remove_rmap
   5.88%  exe-ref.out  [kernel.vmlinux]  [k] lru_add_drain_cpu
   5.68%  exe-ref.out  [kernel.vmlinux]  [k] free_pages_and_swap_cache
   5.03%  exe-ref.out  [kernel.vmlinux]  [k] _find_next_bit.constprop.0
   0.24%  perf         [kernel.vmlinux]  [k] native_write_msr
   0.01%  perf         [kernel.vmlinux]  [k] intel_bts_enable_local

  16.43%  exe.out  [kernel.vmlinux]  [k] __split_vma
  15.66%  exe.out  ld-2.33.so        [.] _dl_lookup_symbol_x
  14.31%  exe.out  libc-2.33.so      [.] __memset_avx2_erms
  13.09%  exe.out  [kernel.vmlinux]  [k] release_pages
  12.04%  exe.out  [kernel.vmlinux]  [k] native_irq_return_iret
  10.37%  exe.out  exe.out           [.] lean_mark_persistent
   9.57%  exe.out  [kernel.vmlinux]  [k] unlink_file_vma
   8.05%  exe.out  [kernel.vmlinux]  [k] perf_event_mmap_output
   0.44%  perf     [kernel.vmlinux]  [k] perf_event_exec
   0.02%  perf     [kernel.vmlinux]  [k] native_sched_clock
   0.00%  perf     [kernel.vmlinux]  [k] native_write_msr

MLIR (ours)

  33.64%  exe.out  exe.out           [.] l_check
  18.24%  exe.out  exe.out           [.] lean_del
  13.28%  exe.out  exe.out           [.] l_make_x27
  10.55%  exe.out  exe.out           [.] lean_free_small
   8.82%  exe.out  exe.out           [.] lean_alloc_ctor_memory
   7.15%  exe.out  exe.out           [.] lean_alloc_small
   1.57%  exe.out  libc-2.33.so      [.] __memset_avx2_erms
   1.15%  exe.out  [kernel.vmlinux]  [k] get_page_from_freelist
   0.93%  exe.out  ld-2.33.so        [.] _dl_map_object_from_fd
   0.90%  exe.out  ld-2.33.so        [.] do_lookup_x
   0.82%  exe.out  exe.out           [.] main
   0.55%  exe.out  [kernel.vmlinux]  [k] error_entry
   0.48%  exe.out  [kernel.vmlinux]  [k] irqentry_exit_to_user_mode
   0.38%  exe.out  [kernel.vmlinux]  [k] __task_pid_nr_ns
   0.37%  exe.out  [kernel.vmlinux]  [k] __pagevec_lru_add_fn
   0.29%  exe.out  [kernel.vmlinux]  [k] lock_page_memcg
   0.29%  exe.out  [kernel.vmlinux]  [k] unmap_page_range
   0.29%  exe.out  [kernel.vmlinux]  [k] check_preemption_disabled
   0.29%  exe.out  [kernel.vmlinux]  [k] free_pcppages_bulk
   0.02%  perf     [kernel.vmlinux]  [k] perf_event_exec
   0.00%  perf     [kernel.vmlinux]  [k] check_preemption_disabled
   0.00%  perf     [kernel.vmlinux]  [k] native_write_msr

  26.63%  exe-ref.out  exe-ref.out       [.] l_check
  24.14%  exe-ref.out  exe-ref.out       [.] lean_del
  16.74%  exe-ref.out  exe-ref.out       [.] l_make_x27.part.0
  11.81%  exe-ref.out  exe-ref.out       [.] lean_alloc_small
   9.21%  exe-ref.out  exe-ref.out       [.] lean_free_small
   2.88%  exe-ref.out  ld-2.33.so        [.] do_lookup_x
   1.47%  exe-ref.out  exe-ref.out       [.] lean_mark_persistent
   1.15%  exe-ref.out  exe-ref.out       [.] lean::allocator::alloc_page
   1.05%  exe-ref.out  [kernel.vmlinux]  [k] __mod_lruvec_state
   0.96%  exe-ref.out  [kernel.vmlinux]  [k] __pagevec_lru_add_fn
   0.89%  exe-ref.out  [kernel.vmlinux]  [k] clear_page_erms
   0.71%  exe-ref.out  [kernel.vmlinux]  [k] copy_page
   0.69%  exe-ref.out  [kernel.vmlinux]  [k] exc_page_fault
   0.41%  exe-ref.out  [kernel.vmlinux]  [k] unmap_page_range
   0.41%  exe-ref.out  [kernel.vmlinux]  [k] native_irq_return_iret
   0.41%  exe-ref.out  [kernel.vmlinux]  [k] check_preemption_disabled
   0.41%  exe-ref.out  [kernel.vmlinux]  [k] free_unref_page_list
   0.04%  perf         [kernel.vmlinux]  [k] memcpy_erms
   0.00%  perf         [kernel.vmlinux]  [k] intel_pmu_handle_irq
   0.00%  perf         [kernel.vmlinux]  [k] native_write_msr

%struct.lean_object = type { i64 }
define %struct.lean_object* @cant_inline_1(i8* %0, i32 %1, i32 %2) alwaysinline {
    unreachable
}

define %struct.lean_object* @cant_inline_2(i8* %0, i64 %1, i64 %2) alwaysinline {
    unreachable
}

define %struct.lean_object* @cant_inline_3(%struct.lean_object* %0, i64 %1, i64 %2) alwaysinline {
    unreachable
}

define i1 @main (i8* %in) {
  ;; %out = tail call i8* bitcast (%struct.lean_object* (i8*, i32, i32)* @cant_inline_1 to i8* (i8*, i64, i64)*)(i8* %in, i64 3, i64 0)
   %out2 = tail call i8* bitcast (%struct.lean_object* (i8*, i64, i64)* @cant_inline_2 to i8* (i8*, i64, i64)*)(i8* %in, i64 3, i64 0)
  %out3 = tail call i8* bitcast (%struct.lean_object* (%struct.lean_object*, i64, i64)* @cant_inline_3 to i8* (i8*, i64, i64)*)(i8* %in, i64 3, i64 0)
  ret i1 1
}

cat exe-linked-o3.ll| sed -r -n "s/.*call.*bitcast.*(@.* ).*/\1/p"

@l_make_x27_match__1___rarg___boxed to i8*), i64 3, i64 0), !dbg 
@lean_alloc_ctor to i8* (i64, i64, i64)*)(i64 1, i64 2, i64 2), !dbg 
@lean_ctor_set to void (i8*, i64, i8*)*)(i8* %1, i64 0, i8* nonnull inttoptr (i64 1 to i8*)), !dbg 
@lean_ctor_set to void (i8*, i64, i8*)*)(i8* %1, i64 1, i8* nonnull inttoptr (i64 1 to i8*)), !dbg 
@lean_alloc_ctor to i8* (i64, i64, i64)*)(i64 1, i64 2, i64 2), !dbg 
@lean_ctor_set to void (i8*, i64, i8*)*)(i8* %8, i64 0, i8* %5), !dbg 
@lean_ctor_set to void (i8*, i64, i8*)*)(i8* %8, i64 1, i8* %7), !dbg 
@lean_obj_tag to i64 (i8*)*)(i8* %0), !dbg 
@l_check_match__1___rarg to i8*), i64 3, i64 0), !dbg 
@lean_obj_tag to i64 (i8*)*)(i8* %0), !dbg 
@lean_obj_tag to i64 (i8*)*)(i8* %8), !dbg 
@l_sumT_match__1___rarg___boxed to i8*), i64 4, i64 0), !dbg 
@l_depth_match__1___rarg to i8*), i64 3, i64 0), !dbg 
@l_depth___lambda__1___boxed to i8*), i64 3, i64 2), !dbg 
@lean_closure_set to void (i8*, i64, i8*)*)(i8* %14, i64 0, i8* %0), !dbg 
@lean_closure_set to void (i8*, i64, i8*)*)(i8* %14, i64 1, i8* %13), !dbg 
@lean_alloc_ctor to i8* (i64, i64, i64)*)(i64 0, i64 2, i64 2), !dbg 
@lean_ctor_set to void (i8*, i64, i8*)*)(i8* %19, i64 0, i8* %0), !dbg 
@lean_ctor_set to void (i8*, i64, i8*)*)(i8* %19, i64 1, i8* %18), !dbg 
@lean_alloc_ctor to i8* (i64, i64, i64)*)(i64 0, i64 2, i64 2), !dbg 
@lean_ctor_set to void (i8*, i64, i8*)*)(i8* %20, i64 0, i8* %13), !dbg 
@lean_ctor_set to void (i8*, i64, i8*)*)(i8* %20, i64 1, i8* %19), !dbg 
@lean_alloc_ctor to i8* (i64, i64, i64)*)(i64 1, i64 2, i64 2), !dbg 
@lean_ctor_set to void (i8*, i64, i8*)*)(i8* %24, i64 0, i8* %20), !dbg 
@lean_ctor_set to void (i8*, i64, i8*)*)(i8* %24, i64 1, i8* %23), !dbg 
@l_main_match__1___rarg to i8*), i64 2, i64 0), !dbg 
@lean_obj_tag to i64 (i8*)*)(i8* %0), !dbg 
@lean_alloc_ctor to i8* (i64, i64, i64)*)(i64 0, i64 2, i64 2), !dbg 
@lean_ctor_set to void (i8*, i64, i8*)*)(i8* %6, i64 0, i8* nonnull inttoptr (i64 1 to i8*)), !dbg 
@lean_ctor_set to void (i8*, i64, i8*)*)(i8* %6, i64 1, i8* %.tr1.lcssa), !dbg 
@lean_obj_tag to i64 (i8*)*)(i8* %36), !dbg 
@lean_obj_tag to i64 (i8*)*)(i8* %39), !dbg 
@lean_alloc_ctor to i8* (i64, i64, i64)*)(i64 1, i64 2, i64 2), !dbg 
@lean_ctor_set to void (i8*, i64, i8*)*)(i8* %54, i64 0, i8* %51), !dbg 
@lean_ctor_set to void (i8*, i64, i8*)*)(i8* %54, i64 1, i8* %53), !dbg 
@lean_obj_tag to i64 (i8*)*)(i8* %5), !dbg 
@lean_obj_tag to i64 (i8*)*)(i8* %13), !dbg 
@lean_alloc_ctor to i8* (i64, i64, i64)*)(i64 1, i64 2, i64 2), !dbg 
@lean_ctor_set to void (i8*, i64, i8*)*)(i8* %34, i64 0, i8* %31), !dbg 
@lean_ctor_set to void (i8*, i64, i8*)*)(i8* %34, i64 1, i8* %33), !dbg 
@lean_alloc_ctor to i8* (i64, i64, i64)*)(i64 1, i64 2, i64 2), !dbg 
@lean_ctor_set to void (i8*, i64, i8*)*)(i8* %40, i64 0, i8* %37), !dbg 
@lean_ctor_set to void (i8*, i64, i8*)*)(i8* %40, i64 1, i8* %39), !dbg 
@lean_alloc_ctor to i8* (i64, i64, i64)*)(i64 1, i64 2, i64 2), !dbg 
@lean_ctor_set to void (i8*, i64, i8*)*)(i8* %4, i64 0, i8* nonnull inttoptr (i64 1 to i8*)), !dbg 
@lean_ctor_set to void (i8*, i64, i8*)*)(i8* %4, i64 1, i8* nonnull inttoptr (i64 1 to i8*)), !dbg 
@__dso_handle) 
@__dso_handle) 
@__dso_handle) 
@__dso_handle) 
@_ZN4lean9throwableD2Ev to i8*)) 
@_ZN4lean9throwableD2Ev to i8*)) 
@_ZN4lean9throwableD2Ev to i8*)) 
@_ZN4lean9throwableD2Ev to i8*)) 

23.77%  exe.out  exe.out           [.] lean_del

# Report, OURS (MLIR/LLVM backend)
  23.77%  exe.out  exe.out           [.] lean_del                   
  13.06%  exe.out  exe.out           [.] l_check                    
  11.77%  exe.out  exe.out           [.] lean_ctor_get              
  10.32%  exe.out  exe.out           [.] lean_free_small            
   9.37%  exe.out  exe.out           [.] lean_alloc_ctor            
   9.28%  exe.out  exe.out           [.] lean_obj_tag               
   8.88%  exe.out  exe.out           [.] l_make_x27                 
   4.38%  exe.out  exe.out           [.] lean_alloc_small           
   4.04%  exe.out  exe.out           [.] lean_ctor_set              
   1.11%  exe.out  [kernel.vmlinux]  [k] irqentry_exit_to_user_mode 
   0.80%  exe.out  exe.out           [.] lean_mark_persistent       
   0.55%  exe.out  ld-2.33.so        [.] strcmp                     
   0.54%  exe.out  exe.out           [.] lean::allocator::alloc_page
   0.50%  exe.out  [kernel.vmlinux]  [k] clear_page_erms            
   0.42%  exe.out  exe.out           [.] lean::mix                  
   0.29%  exe.out  [kernel.vmlinux]  [k] do_user_addr_fault         
   0.18%  exe.out  exe.out           [.] l_depth___lambda__1        
   0.18%  exe.out  [kernel.vmlinux]  [k] unmap_page_range           
   0.18%  exe.out  [kernel.vmlinux]  [k] error_entry                
   0.18%  exe.out  [kernel.vmlinux]  [k] __free_one_page            
   0.18%  exe.out  [kernel.vmlinux]  [k] __mod_memcg_lruvec_state   
   0.02%  perf     [kernel.vmlinux]  [k] strrchr                    
   0.00%  perf     [kernel.vmlinux]  [k] intel_pmu_handle_irq       
   0.00%  perf     [kernel.vmlinux]  [k] native_write_msr

  20.75%  exe-ref.out  exe-ref.out       [.] l_check                    
  18.29%  exe-ref.out  exe-ref.out       [.] lean_free_small            
  11.67%  exe-ref.out  exe-ref.out       [.] l_make_x27.part.0          
   7.74%  exe-ref.out  exe-ref.out       [.] lean_alloc_small           
   2.13%  exe-ref.out  ld-2.33.so        [.] do_lookup_x                
   1.16%  exe-ref.out  exe-ref.out       [.] lean_mark_persistent       
   0.84%  exe-ref.out  [kernel.vmlinux]  [k] try_charge                 
   0.77%  exe-ref.out  [kernel.vmlinux]  [k] sync_regs                  
   0.70%  exe-ref.out  [kernel.vmlinux]  [k] filemap_map_pages          
   0.65%  exe-ref.out  [kernel.vmlinux]  [k] get_page_from_freelist     
   0.60%  exe-ref.out  [kernel.vmlinux]  [k] unmap_page_range           
   0.52%  exe-ref.out  [kernel.vmlinux]  [k] memcg_slab_post_alloc_hook 
   0.47%  exe-ref.out  [kernel.vmlinux]  [k] page_mapping               
   0.30%  exe-ref.out  [kernel.vmlinux]  [k] __free_one_page            
   0.29%  exe-ref.out  exe-ref.out       [.] lean::allocator::alloc_page
   0.22%  exe-ref.out  exe-ref.out       [.] l_depth___lambda__1___boxed
   0.03%  perf         [kernel.vmlinux]  [k] strlen                     
   0.00%  perf         [kernel.vmlinux]  [k] intel_pmu_handle_irq       
   0.00%  perf         [kernel.vmlinux]  [k] native_write_msr           

; not converted to the right call?
%4 = call i64 bitcast (i32 (%struct.lean_object*)* @lean_obj_tag to i64 (i8*)*)(i8* %0), !dbg !13

The following tests FAILED:
        568 - leancomptest_closure_bug1.lean (Failed)
        569 - leancomptest_closure_bug2.lean (Failed)
        570 - leancomptest_closure_bug3.lean (Failed)
        576 - leancomptest_expr.lean (Failed)
        585 - leancomptest_phashmap3.lean (Failed)
        642 - leanplugintest_SnakeLinter.lean (Failed)

# src/shell/CMakeLists.txt
# also look at tests/test_single.sh
file(GLOB LEANT0TESTS "${LEAN_SOURCE_DIR}/../tests/lean/trust0/*.lean")
FOREACH(T ${LEANT0TESTS})
  GET_FILENAME_COMPONENT(T_NAME ${T} NAME)
  add_test(NAME "leant0test_${T_NAME}"
           WORKING_DIRECTORY "${LEAN_SOURCE_DIR}/../tests/lean/trust0"
           COMMAND bash -c "PATH=${LEAN_BIN}:$PATH ./test_single.sh ${T_NAME}")
ENDFOREACH(T)

# https://cmake.org/cmake/help/latest/manual/cmake-generator-expressions.7.html#manual:cmake-generator-expressions(7)
$<TARGET_OBJECTS:objLib>
List of objects resulting from build of objLib.

if(LEANCPP)
  add_library(leancpp STATIC IMPORTED)
  set_target_properties(leancpp PROPERTIES
    IMPORTED_LOCATION "${CMAKE_BINARY_DIR}/lib/lean/libleancpp.a")
  add_custom_target(copy-leancpp
    COMMAND cmake -E copy_if_different "${LEANCPP}" "${CMAKE_BINARY_DIR}/lib/lean/libleancpp.a")
  add_dependencies(leancpp copy-leancpp)
else()
  add_subdirectory(runtime)
  set(LEAN_OBJS ${LEAN_OBJS} $<TARGET_OBJECTS:runtime>)
  add_subdirectory(util)
  set(LEAN_OBJS ${LEAN_OBJS} $<TARGET_OBJECTS:util>)
  add_subdirectory(kernel)
  set(LEAN_OBJS ${LEAN_OBJS} $<TARGET_OBJECTS:kernel>)
  add_subdirectory(library)
  set(LEAN_OBJS ${LEAN_OBJS} $<TARGET_OBJECTS:library>)
  add_subdirectory(library/constructions)
  set(LEAN_OBJS ${LEAN_OBJS} $<TARGET_OBJECTS:constructions>)
  add_subdirectory(library/compiler)
  set(LEAN_OBJS ${LEAN_OBJS} $<TARGET_OBJECTS:compiler>)
  add_subdirectory(initialize)
  set(LEAN_OBJS ${LEAN_OBJS} $<TARGET_OBJECTS:initialize>)
  if(${STAGE} EQUAL 0)
    add_subdirectory(../stdlib stdlib)
    set(LEAN_OBJS ${LEAN_OBJS} $<TARGET_OBJECTS:stage0>)
  endif()

def main : IO Unit := let l := length (filter (make 80000)); IO.println (toString l)

-- | Hack to fix crash in `render.lean`.
def emitDec (x : VarId) (n : Nat) (checkRef : Bool) : M Unit := do
  -- if n != 1 then panicM "there is no lean_dec for more than 1 parameter"
  -- let nv <- emitI64 "n" n;
  -- emit $ "call " ++ (if checkRef then "@lean_dec" else "@lean_dec_ref");
  -- emit "(%"; emit x; emitLn ") : (!lz.value) -> ()"
  return ()

/home/bollu/work/lz/test/lambdapure/compile/bench$ time ./exe.out    
./exe.out  0.64s user 0.01s system 99% cpu 0.652 total
/home/bollu/work/lz/test/lambdapure/compile/bench$ time ./exe-ref.out
./exe-ref.out  0.87s user 0.01s system 99% cpu 0.880 total

"lz.caseRet"(%2) ( {
},  {
}) : (!lz.value) -> ()

caseop parent:
func @l_IO_randFloat(%arg0: f64, %arg1: f64, %arg2: !lz.value) -> !lz.value {
  %c0_i64 = constant 0 : i64
  %0 = call @lean_box(%c0_i64) : (i64) -> !lz.value
  %1 = "ptr.loadglobal"() {value = @l_IO_stdGenRef} : () -> !lz.value
  %2 = call @lean_st_ref_get(%1, %arg2) : (!lz.value, !lz.value) -> !lz.value
  %3 = call @lean_obj_tag(%2) : (!lz.value) -> i64
  %c0_i64_0 = constant 0 : i64
  %4 = cmpi eq, %3, %c0_i64_0 : i64
  cond_br %4, ^bb1, ^bb2
  "lz.caseRet"(%2) ( {
  },  {
  }) : (!lz.value) -> ()
^bb1:  // pred: ^bb0
  %5 = "lz.project"(%2) {value = 0 : i64} : (!lz.value) -> !lz.value
  %6 = "lz.project"(%2) {value = 1 : i64} : (!lz.value) -> !lz.value
  %7 = call @l_randomFloat___at_IO_randFloat___spec__1(%5) : (!lz.value) -> !lz.value
  "lz.caseRet"(%7) ( {
    %10 = "lz.project"(%7) {value = 0 : i64} : (!lz.value) -> !lz.value
    %11 = "lz.project"(%7) {value = 1 : i64} : (!lz.value) -> !lz.value
    %12 = call @lean_st_ref_set(%1, %11, %6) : (!lz.value, !lz.value, !lz.value) -> !lz.value
    "lz.caseRet"(%12) ( {
      %13 = "lz.project"(%12) {value = 1 : i64} : (!lz.value) -> !lz.value
      %14 = call @lean_float_sub(%arg1, %arg0) : (f64, f64) -> f64
      %15 = call @lean_unbox_float(%10) : (!lz.value) -> f64
      %16 = call @lean_float_mul(%14, %15) : (f64, f64) -> f64
      %17 = call @lean_float_add(%arg0, %16) : (f64, f64) -> f64
      %18 = call @lean_box_float(%17) : (f64) -> !lz.value
      %19 = "lz.construct"(%18, %13) {dataconstructor = @"0", size = 2 : i64} : (!lz.value, !lz.value) -> !lz.value
      lz.return %19 : !lz.value
    },  {
    }) : (!lz.value) -> ()
  }) : (!lz.value) -> ()
^bb2:  // pred: ^bb0
  %8 = call @lean_obj_tag(%2) : (!lz.value) -> i64
  %c1_i64 = constant 1 : i64
  %9 = cmpi eq, %8, %c1_i64 : i64
}

// ERR: emitDeclAux (l_IO_randFloat) | isExtern?false
// ERR: emitDeclAux Decl.fdecl (l_IO_randFloat)
func @"l_IO_randFloat"(%x_1: f64, %x_2: f64, %x_3: !lz.value) -> !lz.value{
%c0_irr = std.constant 0 : i64
%irrelevant = call @lean_box(%c0_irr) : (i64) -> (!lz.value)
//ERR: fnBody.vdecl (non-tail) call
// ERR: Expr.fap
%x_4 = "ptr.loadglobal"(){value=@"l_IO_stdGenRef"} : () -> !lz.value// <== ERR: emitFullApp (pointer)

//ERR: fnBody.vdecl (non-tail) call
// ERR: Expr.fap
%x_5 = call @"lean_st_ref_get"(%x_4, %x_3) : (!lz.value,!lz.value) -> (!lz.value) // <== ERR: emitSimpleExternalCall // <== ys: [x_4, x_3]| tys: 
// ^^ ERR: ExternEntry.standard
// ^^^ ERR: emitFullApp (Decl.extern)
// ERR: FnBody.case
"lz.caseRet"(%x_5)({
//ERR: fnBody.vdecl (non-tail) call
// ERR: Expr.proj
%x_6 = "lz.project"(%x_5){value=0}:(!lz.value)  -> (!lz.value)
//ERR: fnBody.vdecl (non-tail) call
// ERR: Expr.proj
%x_7 = "lz.project"(%x_5){value=1}:(!lz.value)  -> (!lz.value)
//ERR: fnBody.vdecl (non-tail) call
// ERR: Expr.fap
%x_8 = call @"l_randomFloat___at_IO_randFloat___spec__1"(%x_6):(!lz.value)->(!lz.value)// <== ERR: emitFullApp (fncall)

// ERR: FnBody.case
"lz.caseRet"(%x_8)({
//ERR: fnBody.vdecl (non-tail) call
// ERR: Expr.proj
%x_9 = "lz.project"(%x_8){value=0}:(!lz.value)  -> (!lz.value)
//ERR: fnBody.vdecl (non-tail) call
// ERR: Expr.proj
%x_10 = "lz.project"(%x_8){value=1}:(!lz.value)  -> (!lz.value)
//ERR: fnBody.vdecl (non-tail) call
// ERR: Expr.fap
%x_11 = call @"lean_st_ref_set"(%x_4, %x_10, %x_7) : (!lz.value,!lz.value,!lz.value) -> (!lz.value) // <== ERR: emitSimpleExternalCall // <== ys: [x_4, x_10, x_7]| tys: 
// ^^ ERR: ExternEntry.standard
// ^^^ ERR: emitFullApp (Decl.extern)
// ERR: FnBody.case
"lz.caseRet"(%x_11)({
//ERR: fnBody.vdecl (non-tail) call
// ERR: Expr.proj
%x_12 = "lz.project"(%x_11){value=1}:(!lz.value)  -> (!lz.value)
//ERR: fnBody.vdecl (non-tail) call
// ERR: Expr.fap
%x_13 = call @"lean_float_sub"(%x_2, %x_1) : (f64,f64) -> (f64) // <== ERR: emitSimpleExternalCall // <== ys: [x_2, x_1]| tys: 
// ^^ ERR: ExternEntry.standard
// ^^^ ERR: emitFullApp (Decl.extern)
//ERR: fnBody.vdecl (non-tail) call
// ERR: Expr.unbox
%x_14 = call @lean_unbox_float(%x_9) : (!lz.value) -> (f64)
//^UNBOX type: (f64)
//ERR: fnBody.vdecl (non-tail) call
// ERR: Expr.fap
%x_15 = call @"lean_float_mul"(%x_13, %x_14) : (f64,f64) -> (f64) // <== ERR: emitSimpleExternalCall // <== ys: [x_13, x_14]| tys: 
// ^^ ERR: ExternEntry.standard
// ^^^ ERR: emitFullApp (Decl.extern)
//ERR: fnBody.vdecl (non-tail) call
// ERR: Expr.fap
%x_16 = call @"lean_float_add"(%x_1, %x_15) : (f64,f64) -> (f64) // <== ERR: emitSimpleExternalCall // <== ys: [x_1, x_15]| tys: 
// ^^ ERR: ExternEntry.standard
// ^^^ ERR: emitFullApp (Decl.extern)
//ERR: fnBody.vdecl (non-tail) call
// ERR: Expr.box
%x_17 = call @lean_box_float(%x_16) : (f64) -> (!lz.value) // ERR: xType: float
//ERR: fnBody.vdecl (non-tail) call
%x_18 = "lz.construct"(%x_17, %x_12){dataconstructor = @"0", size=2} : (!lz.value, !lz.value) -> (!lz.value)
//ERR: FnBody.ret
lz.return %x_18 : !lz.value
}
, {
// ERR: FnBody.unreachable
}
)
 : (!lz.value) -> ()
}
)
 : (!lz.value) -> ()
}
, {
// ERR: FnBody.unreachable
}
)
 : (!lz.value) -> ()
}

Writing to out.ppm
./exe-ref.out  532.94s user 8.26s system 712% cpu 1:15.99 total

line 133 of 133
Writing to out.ppm
./exe.out  514.85s user 7.02s system 746% cpu 1:09.91 total
/home/bollu/work/lz/test/lambdapure/compile$ 

/home/bollu/work/lz/test/lambdapure/compile$ llvm-lit -j1 .
-- Testing: 28 tests, 1 workers --

PASS: HASK_OPT :: lambdapure/compile/bench/deriv.lean (1 of 28)
PASS: HASK_OPT :: lambdapure/compile/bench/qsort.lean (2 of 28)
PASS: HASK_OPT :: lambdapure/compile/bench/unionfind.lean (3 of 28)
PASS: HASK_OPT :: lambdapure/compile/bench/rbmap_checkpoint.lean (4 of 28)
PASS: HASK_OPT :: lambdapure/compile/render.lean (5 of 28)
PASS: HASK_OPT :: lambdapure/compile/pap.lean (6 of 28)
PASS: HASK_OPT :: lambdapure/compile/bench/const_fold.lean (7 of 28)
PASS: HASK_OPT :: lambdapure/compile/jmp.lean (8 of 28)
PASS: HASK_OPT :: lambdapure/compile/ctor.lean (9 of 28)
PASS: HASK_OPT :: lambdapure/compile/loop.lean (10 of 28)
PASS: HASK_OPT :: lambdapure/compile/bench/binarytrees-int.lean (11 of 28)
PASS: HASK_OPT :: lambdapure/compile/bench/binarytrees.lean (12 of 28)
PASS: HASK_OPT :: lambdapure/compile/case.lean (13 of 28)
PASS: HASK_OPT :: lambdapure/compile/main-print.lean (14 of 28)
PASS: HASK_OPT :: lambdapure/compile/ctor-simple.lean (15 of 28)
PASS: HASK_OPT :: lambdapure/compile/bench/filter.lean (16 of 28)
PASS: HASK_OPT :: lambdapure/compile/mutualrec.lean (17 of 28)
UNRESOLVED: HASK_OPT :: lambdapure/compile/bench/exe.mlir (18 of 28)
UNRESOLVED: HASK_OPT :: lambdapure/compile/bench/rbmap3.lean (19 of 28)
UNRESOLVED: HASK_OPT :: lambdapure/compile/bench/map-destruct.mlir (20 of 28)
UNRESOLVED: HASK_OPT :: lambdapure/compile/bench/rbmap2.lean (21 of 28)
UNRESOLVED: HASK_OPT :: lambdapure/compile/bench/map-ref.mlir (22 of 28)
UNRESOLVED: HASK_OPT :: lambdapure/compile/bench/rbmap4.lean (23 of 28)
UNRESOLVED: HASK_OPT :: lambdapure/compile/bench/rbmap500k.lean (24 of 28)
UNRESOLVED: HASK_OPT :: lambdapure/compile/bench/lambdapure.mlir (25 of 28)
UNRESOLVED: HASK_OPT :: lambdapure/compile/bench/map-runtime.mlir (26 of 28)
UNRESOLVED: HASK_OPT :: lambdapure/compile/exe.mlir (27 of 28)
UNRESOLVED: HASK_OPT :: lambdapure/compile/bench/loop.mlir (28 of 28)
********************
Unresolved Tests (11):
  HASK_OPT :: lambdapure/compile/bench/exe.mlir
  HASK_OPT :: lambdapure/compile/bench/lambdapure.mlir
  HASK_OPT :: lambdapure/compile/bench/loop.mlir
  HASK_OPT :: lambdapure/compile/bench/map-destruct.mlir
  HASK_OPT :: lambdapure/compile/bench/map-ref.mlir
  HASK_OPT :: lambdapure/compile/bench/map-runtime.mlir
  HASK_OPT :: lambdapure/compile/bench/rbmap2.lean
  HASK_OPT :: lambdapure/compile/bench/rbmap3.lean
  HASK_OPT :: lambdapure/compile/bench/rbmap4.lean
  HASK_OPT :: lambdapure/compile/bench/rbmap500k.lean
  HASK_OPT :: lambdapure/compile/exe.mlir


Testing Time: 47.74s
  Passed    : 17
  Unresolved: 11

58,63d57
<           %3 = "lz.papExtend"(%arg3, %arg0) : (!lz.value, !lz.value) -> !lz.value
<           lz.return %3 : !lz.value
<         },  {
<           %3 = "lz.papExtend"(%arg3, %arg0) : (!lz.value, !lz.value) -> !lz.value
<           lz.return %3 : !lz.value
<         },  {
66a61,63
>         },  {
>           %3 = "lz.papExtend"(%arg3, %arg0) : (!lz.value, !lz.value) -> !lz.value
>           lz.return %3 : !lz.value
70,75d66
<           %3 = "lz.construct"() {dataconstructor = @"0", size = 0 : i64} : () -> !lz.value
<           "lz.jump"(%3) {value = 12 : i64} : (!lz.value) -> ()
<         },  {
<           %3 = "lz.construct"() {dataconstructor = @"0", size = 0 : i64} : () -> !lz.value
<           "lz.jump"(%3) {value = 12 : i64} : (!lz.value) -> ()
<         },  {
77,78c68,69
<             %3 = "lz.project"(%1) {value = 0 : i64} : (!lz.value) -> !lz.value
<             %4 = "lz.papExtend"(%arg2, %3, %2) : (!lz.value, !lz.value, !lz.value) -> !lz.value
---
>             %3 = "lz.project"(%2) {value = 0 : i64} : (!lz.value) -> !lz.value
>             %4 = "lz.papExtend"(%arg1, %1, %3) : (!lz.value, !lz.value, !lz.value) -> !lz.value
84,87d74
<           },  {
<             %3 = "lz.project"(%2) {value = 0 : i64} : (!lz.value) -> !lz.value
<             %4 = "lz.papExtend"(%arg1, %1, %3) : (!lz.value, !lz.value, !lz.value) -> !lz.value
<             lz.return %4 : !lz.value
88a76,78
>         },  {
>           %3 = "lz.construct"() {dataconstructor = @"0", size = 0 : i64} : () -> !lz.value
>           "lz.jump"(%3) {value = 11 : i64} : (!lz.value) -> ()
94,96d83
<     },  {
<       %1 = "lz.papExtend"(%arg3, %arg0) : (!lz.value, !lz.value) -> !lz.value
<       lz.return %1 : !lz.value
135c122
<           %3 = "ptr.loadglobal"() {value = @l_Expr_eval___closed__1} : () -> !lz.value
---
>           %3 = "ptr.loadglobal"() {value = @l_Expr_eval___closed__2} : () -> !lz.value
140,142d126
<         },  {
<           %3 = "ptr.loadglobal"() {value = @l_Expr_eval___closed__2} : () -> !lz.value
<           lz.return %3 : !lz.value
146,151d129
<           %3 = "lz.construct"() {dataconstructor = @"0", size = 0 : i64} : () -> !lz.value
<           "lz.jump"(%3) {value = 8 : i64} : (!lz.value) -> ()
<         },  {
<           %3 = "lz.construct"() {dataconstructor = @"0", size = 0 : i64} : () -> !lz.value
<           "lz.jump"(%3) {value = 8 : i64} : (!lz.value) -> ()
<         },  {
153c131
<             %3 = "ptr.loadglobal"() {value = @l_Expr_eval___closed__3} : () -> !lz.value
---
>             %3 = "ptr.loadglobal"() {value = @l_Expr_eval___closed__2} : () -> !lz.value
158,160d135
<           },  {
<             %3 = "ptr.loadglobal"() {value = @l_Expr_eval___closed__2} : () -> !lz.value
<             lz.return %3 : !lz.value
161a137,139
>         },  {
>           %3 = "lz.construct"() {dataconstructor = @"0", size = 0 : i64} : () -> !lz.value
>           "lz.jump"(%3) {value = 7 : i64} : (!lz.value) -> ()
167,169d144
<     },  {
<       %1 = "ptr.loadglobal"() {value = @l_Expr_eval___closed__1} : () -> !lz.value
<       lz.return %1 : !lz.value
176,181d150
<       %1 = "lz.papExtend"(%arg2, %arg0) : (!lz.value, !lz.value) -> !lz.value
<       lz.return %1 : !lz.value
<     },  {
<       %1 = "lz.papExtend"(%arg2, %arg0) : (!lz.value, !lz.value) -> !lz.value
<       lz.return %1 : !lz.value
<     },  {
184a154,156
>     },  {
>       %1 = "lz.papExtend"(%arg2, %arg0) : (!lz.value, !lz.value) -> !lz.value
>       lz.return %1 : !lz.value
197c169
<       %1 = "lz.int"() {value = 420 : i64} : () -> !lz.value
---
>       %1 = "lz.project"(%arg0) {value = 0 : i64} : (!lz.value) -> !lz.value
201,203d172
<       lz.return %1 : !lz.value
<     },  {
<       %1 = "lz.project"(%arg0) {value = 0 : i64} : (!lz.value) -> !lz.value

private def compileAux (decls : Array Decl) : CompilerM Unit := do
  -- log (LogEntry.message "// compileAux")
  -- logDecls `init decls
  -- logPreamble (LogEntry.message mlirPreamble)
  -- logDeclsUnconditional decls
  checkDecls decls
  let decls ← elimDeadBranches decls
  logDecls `elim_dead_branches decls
  let decls := decls.map Decl.pushProj
  logDecls `push_proj decls
  -- let decls := decls.map Decl.insertResetReuse
  -- logDecls `reset_reuse decls
  let decls := decls.map Decl.elimDead
  logDecls `elim_dead decls
  let decls := decls.map Decl.simpCase
  logDecls `simp_case decls
  let decls := decls.map Decl.normalizeIds
  -- logDeclsUnconditional decls

  -- let decls ← inferBorrow decls
  -- logDecls `borrow decls
  let decls ← explicitBoxing decls
  logDecls `boxing decls
  -- let decls ← explicitRC decls
  -- logDecls `rc decls
  -- let decls := decls.map Decl.expandResetReuse
  -- logDecls `expand_reset_reuse decls
  let decls := decls.map Decl.pushProj
  logDecls `push_proj decls
  let decls ← updateSorryDep decls
  logDecls `result decls
  checkDecls decls
  addDecls decls

HASK_OPT :: lambdapure/compile/bench/deriv.lean
HASK_OPT :: lambdapure/compile/jmp.lean

set_option bootstrap.genMatcherCode false in
-- @[extern c inline "#1 == #2"]
@[extern c "lean_uint64_eq"]
def UInt64.decEq (a b : UInt64) : Decidable (Eq a b) :=
  match a, b with
  | ⟨n⟩, ⟨m⟩ =>
    dite (Eq n m) (fun h => isTrue (h ▸ rfl)) (fun h => isFalse (fun h' => UInt64.noConfusion h' (fun h' => absurd h' h)))

stage0/src/Lean/Meta/Match/Match.lean
571:register_builtin_option bootstrap.genMatcherCode : Bool := {
583:  let compile := bootstrap.genMatcherCode.get (← getOptions)

../build/stage1/lib/temp/Init/Prelude.c:53:9: error: conflicting types for ‘lean_uint64_eq’
   53 | uint8_t lean_uint64_eq(uint64_t, uint64_t);
      |         ^~~~~~~~~~~~~~
In file included from ../build/stage1/lib/temp/Init/Prelude.c:4:
/home/bollu/work/lean4/build/stage1/bin/../include/lean/lean.h:1316:20: note: previous definition of ‘lean_uint64_eq’ was here
 1316 | static inline bool lean_uint64_eq(uint64_t a, uint64_t b) {
      |                    ^~~~~~~~~~~~~~
../build/stage1/lib/temp/Init/Prelude.c:67:9: error: conflicting types for ‘lean_uint8_eq’
   67 | uint8_t lean_uint8_eq(uint8_t, uint8_t);
      |         ^~~~~~~~~~~~~
In file included from ../build/stage1/lib/temp/Init/Prelude.c:4:
/home/bollu/work/lean4/build/stage1/bin/../include/lean/lean.h:1325:20: note: previous definition of ‘lean_uint8_eq’ was here
 1325 | static inline bool lean_uint8_eq(uint8_t a, uint8_t b) {
      |                    ^~~~~~~~~~~~~
../build/stage1/lib/temp/Init/Prelude.c:77:9: error: conflicting types for ‘lean_usize_eq’
   77 | uint8_t lean_usize_eq(size_t, size_t);
      |         ^~~~~~~~~~~~~
In file included from ../build/stage1/lib/temp/Init/Prelude.c:4:
/home/bollu/work/lean4/build/stage1/bin/../include/lean/lean.h:1313:20: note: previous definition of ‘lean_usize_eq’ was here
 1313 | static inline bool lean_usize_eq(size_t a, size_t b) {
      |                    ^~~~~~~~~~~~~
../build/stage1/lib/temp/Init/Prelude.c:544:9: error: conflicting types for ‘lean_uint32_eq’
  544 | uint8_t lean_uint32_eq(uint32_t, uint32_t);
      |         ^~~~~~~~~~~~~~
In file included from ../build/stage1/lib/temp/Init/Prelude.c:4:
/home/bollu/work/lean4/build/stage1/bin/../include/lean/lean.h:1319:20: note: previous definition of ‘lean_uint32_eq’ was here
 1319 | static inline bool lean_uint32_eq(uint32_t a, uint32_t b) {
      |                    ^~~~~~~~~~~~~~
../build/stage1/lib/temp/Init/Prelude.c:732:9: error: conflicting types for ‘lean_uint16_eq’
  732 | uint8_t lean_uint16_eq(uint16_t, uint16_t);
      |         ^~~~~~~~~~~~~~
In file included from ../build/stage1/lib/temp/Init/Prelude.c:4:
/home/bollu/work/lean4/build/stage1/bin/../include/lean/lean.h:1322:20: note: previous definition of ‘lean_uint16_eq’ was here
 1322 | static inline bool lean_uint16_eq(uint16_t a, uint16_t b) {
      |                    ^~~~~~~~~~~~~~

/home/bollu/work/lean4/lean4-mode$ cp ~/work/lean4/src/include/lean/lean.h ~/work/lean4/build/stage0/include/lean/lean.h
/home/bollu/work/lean4/lean4-mode$ cp ~/work/lean4/src/include/lean/lean.h ~/work/lean4/build/stage1/include/lean/lean.h

//ERR: fnBody.vdecl (non-tail) call
// ERR: Expr.fap
%x_8 = x_6 + x_7;
//^^ ERR: ExternEntry.inline [pat: #1 + #2]
// ^^^ ERR: emitFullApp (Decl.extern)

| some (ExternEntry.inline _ pat)     => do 
       emit (expandExternPattern pat (toStringArgs ys)); emitLn ";"
       emitLn $ "//^^ ERR: ExternEntry.inline [pat: " ++ pat ++ "]"; 

/home/bollu/work/lean4$ ag -F "#1 + #2"        
stage0/src/Lean/Compiler/ExternAttr.lean
27:- `@[extern cpp inline "#1 + #2"]`
28:   encoding: ```.entries = [inline `cpp "#1 + #2"]```

stage0/src/Init/Data/UInt.lean
17:@[extern c inline "#1 + #2"]
82:@[extern c inline "#1 + #2"]
148:@[extern c inline "#1 + #2"]
200:@[extern c inline "#1 + #2"]
279:@[extern c inline "#1 + #2"]

stage0/src/Init/Data/Float.lean
35:@[extern c inline "#1 + #2"]  constant Float.add : Float → Float → Float

src/Lean/Compiler/ExternAttr.lean
27:- `@[extern cpp inline "#1 + #2"]`
28:   encoding: ```.entries = [inline `cpp "#1 + #2"]```

src/Init/Data/Float.lean
35:@[extern c inline "#1 + #2"]  constant Float.add : Float → Float → Float

src/Init/Data/UInt.lean
17:@[extern c inline "#1 + #2"]
82:@[extern c inline "#1 + #2"]
148:@[extern c inline "#1 + #2"]
200:@[extern c inline "#1 + #2"]
279:@[extern c inline "#1 + #2"]

tmp/PreludeNew.lean:@[extern c inline "lean_nat_sub(#1, lean_box(1))"]
tmp/PreludeNew.lean:@[extern c inline "#1 == #2"]
tmp/PreludeNew.lean:@[extern c inline "#1 == #2"]
tmp/PreludeNew.lean:@[extern c inline "#1 == #2"]
tmp/PreludeNew.lean:@[extern c inline "#1 == #2"]
tmp/PreludeNew.lean:@[extern c inline "#1 == #2"]
tmp/PreludeNew.lean:@[extern c inline "#3"]
tests/compiler/lazylist.lean:@[extern c inline "#2"]
src/Lean/Expr.lean:@[extern c inline "(uint8_t)((#1 << 24) >> 61)"]
src/Lean/Expr.lean:@[extern c inline "(uint64_t)#1"]
src/Lean/Util/Path.lean:@[extern c inline "LEAN_IS_STAGE0"]
src/Lean/Compiler/IR/Checker.lean:@[extern c inline "lean_box(LEAN_MAX_CTOR_FIELDS)"]
src/Lean/Compiler/IR/Checker.lean:@[extern c inline "lean_box(LEAN_MAX_CTOR_SCALARS_SIZE)"]
src/Lean/Compiler/IR/Checker.lean:@[extern c inline "lean_box(sizeof(size_t))"]
src/Init/Core.lean:@[extern c inline "#1 || #2"] def strictOr  (b₁ b₂ : Bool) := b₁ || b₂
src/Init/Core.lean:@[extern c inline "#1 && #2"] def strictAnd (b₁ b₂ : Bool) := b₁ && b₂
src/Init/Prelude.lean:@[extern c inline "lean_nat_sub(#1, lean_box(1))"]
src/Init/Prelude.lean:@[extern c inline "#1 == #2"]
src/Init/Prelude.lean:@[extern c inline "#1 == #2"]
src/Init/Prelude.lean:@[extern c inline "#1 == #2"]
src/Init/Prelude.lean:@[extern c inline "#1 < #2"]
src/Init/Prelude.lean:@[extern c inline "#1 <= #2"]
src/Init/Prelude.lean:@[extern c inline "#1 == #2"]
src/Init/Prelude.lean:@[extern c inline "#1 == #2"]
src/Init/Prelude.lean:@[extern c inline "#3"]
src/Init/Data/Float.lean:@[extern c inline "#1 + #2"]  constant Float.add : Float → Float → Float
src/Init/Data/Float.lean:@[extern c inline "#1 - #2"]  constant Float.sub : Float → Float → Float
src/Init/Data/Float.lean:@[extern c inline "#1 * #2"]  constant Float.mul : Float → Float → Float
src/Init/Data/Float.lean:@[extern c inline "#1 / #2"]  constant Float.div : Float → Float → Float
src/Init/Data/Float.lean:@[extern c inline "(- #1)"]   constant Float.neg : Float → Float
src/Init/Data/Float.lean:@[extern c inline "#1 == #2"] constant Float.beq (a b : Float) : Bool
src/Init/Data/Float.lean:@[extern c inline "#1 < #2"]   constant Float.decLt (a b : Float) : Decidable (a < b) :=
src/Init/Data/Float.lean:@[extern c inline "#1 <= #2"] constant Float.decLe (a b : Float) : Decidable (a ≤ b) :=
src/Init/Data/Float.lean:@[extern c inline "(uint8_t)#1"] constant Float.toUInt8 : Float → UInt8
src/Init/Data/Float.lean:@[extern c inline "(uint16_t)#1"] constant Float.toUInt16 : Float → UInt16
src/Init/Data/Float.lean:@[extern c inline "(uint32_t)#1"] constant Float.toUInt32 : Float → UInt32
src/Init/Data/Float.lean:@[extern c inline "(uint64_t)#1"] constant Float.toUInt64 : Float → UInt64
src/Init/Data/Float.lean:@[extern c inline "(size_t)#1"] constant Float.toUSize : Float → USize
src/Init/Data/UInt.lean:@[extern c inline "#1 + #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 - #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 * #2"]
src/Init/Data/UInt.lean:@[extern c inline "#2 == 0 ? 0 : #1 / #2"]
src/Init/Data/UInt.lean:@[extern c inline "#2 == 0 ? #1 : #1 % #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 & #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 | #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 ^ #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 << #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 >> #2"]
src/Init/Data/UInt.lean:@[extern c inline "~ #1"]
src/Init/Data/UInt.lean:@[extern c inline "#1 < #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 <= #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 + #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 - #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 * #2"]
src/Init/Data/UInt.lean:@[extern c inline "#2 == 0 ? 0 : #1 / #2"]
src/Init/Data/UInt.lean:@[extern c inline "#2 == 0 ? #1 : #1 % #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 & #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 | #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 ^ #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 << #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 >> #2"]
src/Init/Data/UInt.lean:@[extern c inline "~ #1"]
src/Init/Data/UInt.lean:@[extern c inline "#1 < #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 <= #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 + #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 - #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 * #2"]
src/Init/Data/UInt.lean:@[extern c inline "#2 == 0 ? 0 : #1 / #2"]
src/Init/Data/UInt.lean:@[extern c inline "#2 == 0 ? #1 : #1 % #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 & #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 | #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 ^ #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 << #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 >> #2"]
src/Init/Data/UInt.lean:@[extern c inline "((uint8_t)#1)"]
src/Init/Data/UInt.lean:@[extern c inline "((uint16_t)#1)"]
src/Init/Data/UInt.lean:@[extern c inline "((uint32_t)#1)"]
src/Init/Data/UInt.lean:@[extern c inline "~ #1"]
src/Init/Data/UInt.lean:@[extern c inline "#1 + #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 - #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 * #2"]
src/Init/Data/UInt.lean:@[extern c inline "#2 == 0 ? 0 : #1 / #2"]
src/Init/Data/UInt.lean:@[extern c inline "#2 == 0 ? #1 : #1 % #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 & #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 | #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 ^ #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 << #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 >> #2"]
src/Init/Data/UInt.lean:@[extern c inline "((uint8_t)#1)"]
src/Init/Data/UInt.lean:@[extern c inline "((uint16_t)#1)"]
src/Init/Data/UInt.lean:@[extern c inline "((uint32_t)#1)"]
src/Init/Data/UInt.lean:@[extern c inline "((uint64_t)#1)"]
src/Init/Data/UInt.lean:@[extern c inline "~ #1"]
src/Init/Data/UInt.lean:@[extern c inline "(uint64_t)#1"]
src/Init/Data/UInt.lean:@[extern c inline "#1 < #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 <= #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 + #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 - #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 * #2"]
src/Init/Data/UInt.lean:@[extern c inline "#2 == 0 ? 0 : #1 / #2"]
src/Init/Data/UInt.lean:@[extern c inline "#2 == 0 ? #1 : #1 % #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 & #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 | #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 ^ #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 << #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 >> #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1"]
src/Init/Data/UInt.lean:@[extern c inline "((size_t)#1)"]
src/Init/Data/UInt.lean:@[extern c inline "(uint32_t)#1"]
src/Init/Data/UInt.lean:@[extern c inline "~ #1"]
src/Init/Data/UInt.lean:@[extern c inline "#1 < #2"]
src/Init/Data/UInt.lean:@[extern c inline "#1 <= #2"]
src/Init/Meta.lean:@[extern c inline "lean_box(LEAN_VERSION_MAJOR)"]
src/Init/Meta.lean:@[extern c inline "lean_box(LEAN_VERSION_MINOR)"]
src/Init/Meta.lean:@[extern c inline "lean_box(LEAN_VERSION_PATCH)"]
src/Init/Meta.lean:-- @[extern c inline "lean_mk_string(LEAN_GITHASH)"]
src/Init/Meta.lean:@[extern c inline "LEAN_VERSION_IS_RELEASE"]
src/Init/Meta.lean:@[extern c inline "lean_mk_string(LEAN_SPECIAL_VERSION_DESC)"]
src/Init/Fix.lean:@[extern c inline "lean_fixpoint(#4, #5)"]
src/Init/Fix.lean:@[extern c inline "lean_fixpoint2(#5, #6, #7)"]
src/Init/Fix.lean:@[extern c inline "lean_fixpoint3(#6, #7, #8, #9)"]
src/Init/Fix.lean:@[extern c inline "lean_fixpoint4(#7, #8, #9, #10, #11)"]
src/Init/Fix.lean:@[extern c inline "lean_fixpoint5(#8, #9, #10, #11, #12, #13)"]
src/Init/Fix.lean:@[extern c inline "lean_fixpoint6(#9, #10, #11, #12, #13, #14, #15)"]

src/Init/Data/UInt.lean:@[extern c inline "#1 + #2"]

src/Init/Data/UInt.lean:@[extern c inline "add #1, #2"]

-- set_option bootstrap.genMatcherCode false in
-- @[extern c inline "#1 == #2"]

int foo(int x) {
    if (x == 1) { return -1; }
    if (x == 2) { return -2; }
    return -42;
}

%x = case v of alt0 -> { y0 }, alt1 -> { y1 }, alt2 -> { y2 }
%user = foo %x

^entry:
  switch v bb0 bb1 bb2

^bb0: br ^landingpad(y0)
^bb1: br ^landingpad(y1)
^bb2: br ^landingpad(y2)

^landingpad(%x):
  %user = foo %x

joinpoint @jp { ... }
{
    %wrench = jmp @jp
    %x = case v of alt0 -> { y0 }, alt1 -> { y1 }, alt2 -> { jmp @jp }
    %user = foo %x
}

Lean/Compiler/IR/Basic.lean
288:@[export lean_ir_mk_jmp] def mkJmp (j : JoinPointId) (ys : Array Arg) : FnBody := FnBody.jmp j ys

Lean/Elab/Do.lean
302:def mkJmp (ref : Syntax) (rs : NameSet) (val : Syntax) (mkJPBody : Syntax → MacroM Code) : StateRefT (Array JPDecl) TermElabM Code := do
325:  | rs, Code.«return» ref val      => mkJmp ref rs val (fun y => pure $ Code.«return» ref y)
330:      mkJmp ref rs y (fun yFresh => do pure $ Code.action (← `(Pure.pure $yFresh)))
978:def mkJmp (ref : Syntax) (j : Name) (args : Array Syntax) : Syntax :=
987:  | Code.jmp ref j args     => pure $ mkJmp ref j args
/home/bollu/work/lean4/src$ ag "lean_ir_mk_jmp"
Lean/Compiler/IR/Basic.lean
288:@[export lean_ir_mk_jmp] def mkJmp (j : JoinPointId) (ys : Array Arg) : FnBody := FnBody.jmp j ys

library/compiler/ir.cpp
39:extern "C" object * lean_ir_mk_jmp(object * j, object * ys);
87:    return fn_body(lean_ir_mk_jmp(j.to_obj_arg(), to_array(ys)));

Lean/Compiler/IR/OldFormatMLIR.lean:--   | FnBody.jmp j ys            => "jmp " ++ format j ++ formatArray ys
Lean/Compiler/IR/OldFormatMLIR.lean:--     | FnBody.jmp j ys            => (escape "lz.jump") ++ "("  ++ formatArray ys ++ ")"
Lean/Compiler/IR/ResetReuse.lean:       then it must also live in `b` since `j` is reachable from `b` with a `jmp`.
Lean/Compiler/IR/ResetReuse.lean:           since `instr` is not a `FnBody.jmp` (it is not a terminal) nor it is a `FnBody.jdecl`. -/
Lean/Compiler/IR/RC.lean:  | b@(FnBody.jmp j xs), ctx =>
Lean/Compiler/IR/EmitC.lean:  | FnBody.jmp j xs            => emitJmp j xs
Lean/Compiler/IR/Checker.lean:  | FnBody.jmp j ys         => checkJP j *> checkArgs ys
Lean/Compiler/IR/FreeVars.lean:  | FnBody.jmp j ys         => collectJP j >> collectArgs ys
Lean/Compiler/IR/FreeVars.lean:  | FnBody.jmp j ys         => collectJP j >> collectArgs ys
Lean/Compiler/IR/FreeVars.lean:  | FnBody.jmp j ys         => visitJP w j || visitArgs w ys
Lean/Compiler/IR/NormIds.lean:  | FnBody.jmp j ys        => return FnBody.jmp (← normJP j) (← normArgs ys)
Lean/Compiler/IR/NormIds.lean:  | FnBody.jmp j ys              => FnBody.jmp j (mapArgs f ys)
Lean/Compiler/IR/Boxing.lean:  | FnBody.jmp j ys          => do
Lean/Compiler/IR/Boxing.lean:    castArgsIfNeeded ys ps fun ys => pure $ FnBody.jmp j ys
Lean/Compiler/IR/Format.lean:  | FnBody.jmp j ys            => "jmp " ++ format j ++ formatArray ys
Lean/Compiler/IR/Format.lean:    | FnBody.jmp j ys            => "jmp " ++ format j ++ formatArray ys
Lean/Compiler/IR/LiveVars.lean:   jmp block_1 x
Lean/Compiler/IR/LiveVars.lean:  | FnBody.jmp j ys         => visitArgs w ys <||> do
Lean/Compiler/IR/LiveVars.lean:   `FnBody.jmp j ys` and `j` is not local. -/
Lean/Compiler/IR/LiveVars.lean:  | FnBody.jmp j xs,         m => collectJP m j ∘ collectArgs xs
Lean/Compiler/IR/EmitMLIR.lean:  | FnBody.jmp j xs            => do
Lean/Compiler/IR/EmitMLIR.lean:      emitLn "// ERR: FnBody.jmp"
Lean/Compiler/IR/Basic.lean:  | jmp (j : JoinPointId) (ys : Array Arg)
Lean/Compiler/IR/Basic.lean:@[export lean_ir_mk_jmp] def mkJmp (j : JoinPointId) (ys : Array Arg) : FnBody := FnBody.jmp j ys
Lean/Compiler/IR/Basic.lean:  | FnBody.jmp _ _       => true
Lean/Compiler/IR/Basic.lean:  | ρ, FnBody.jmp j₁ ys₁,             FnBody.jmp j₂ ys₂             => j₁ == j₂ && aeqv ρ ys₁ ys₂
Lean/Compiler/IR/ElimDeadBranches.lean:  | FnBody.jmp j xs => do
Lean/Compiler/IR/Borrow.lean:  | FnBody.jmp j ys      => do
library/compiler/ir.cpp:extern "C" object * lean_ir_mk_jmp(object * j, object * ys);
library/compiler/ir.cpp:fn_body mk_jmp(jp_id const & j, buffer<arg> const & ys) {
library/compiler/ir.cpp:    return fn_body(lean_ir_mk_jmp(j.to_obj_arg(), to_array(ys)));
library/compiler/ir.cpp:    static bool is_jmp(expr const & e) {
library/compiler/ir.cpp:        return is_llnf_jmp(get_app_fn(e));
library/compiler/ir.cpp:    ir::fn_body visit_jmp(expr const & e) {
library/compiler/ir.cpp:        return ir::mk_jmp(to_jp_id(jp), ir_args);
library/compiler/ir.cpp:        } else if (is_jmp(e)) {
library/compiler/ir.cpp:            return visit_jmp(e);
library/compiler/llnf.cpp:static expr * g_jmp         = nullptr;
library/compiler/llnf.cpp:/* The `_jmp` instruction is a "jump" to a join point. */
library/compiler/llnf.cpp:expr mk_llnf_jmp() { return *g_jmp; }
library/compiler/llnf.cpp:bool is_llnf_jmp(expr const & e) { return e == *g_jmp; }
library/compiler/llnf.cpp:        is_llnf_jmp(e)     ||
library/compiler/llnf.cpp:                return mk_app(mk_app(mk_llnf_jmp(), fn), args);
library/compiler/llnf.cpp:    g_jmp       = new expr(mk_constant("_jmp"));
library/compiler/llnf.cpp:    mark_persistent(g_jmp->raw());
library/compiler/llnf.cpp:    delete g_jmp;
library/compiler/cse.cpp:    expr replace_target(expr const & e, expr const & target, expr const & jmp) {
library/compiler/cse.cpp:                    return some_expr(jmp);
library/compiler/cse.cpp:        buffer<pair<expr, expr>> target_jmp_pairs;
library/compiler/cse.cpp:                expr jmp         = mk_app(new_fvar, unit_mk);
library/compiler/cse.cpp:                            target_jmp_pairs.emplace_back(target, jmp);
library/compiler/cse.cpp:                body = replace_target(body, target, jmp);
library/compiler/cse.cpp:        if (is_let && !target_jmp_pairs.empty()) {
library/compiler/cse.cpp:                    for (pair<expr, expr> const & p : target_jmp_pairs) {
library/compiler/llnf.h:bool is_llnf_jmp(expr const & e);
library/compiler/ir_interpreter.cpp:jp_id const & fn_body_jmp_jp(fn_body const & b) { lean_assert(fn_body_tag(b) == fn_body_kind::Jmp); return cnstr_get_ref_t<jp_id>(b, 0); }
library/compiler/ir_interpreter.cpp:array_ref<arg> const & fn_body_jmp_args(fn_body const & b) { lean_assert(fn_body_tag(b) == fn_body_kind::Jmp); return cnstr_get_ref_t<array_ref<arg>>(b, 1); }
library/compiler/ir_interpreter.cpp:                    fn_body const & jp = *m_jp_stack[get_frame().m_jp_bp + fn_body_jmp_jp(b).get_small_value()];
library/compiler/ir_interpreter.cpp:                    lean_assert(fn_body_jdecl_params(jp).size() == fn_body_jmp_args(b).size());
library/compiler/ir_interpreter.cpp:                        var(param_var(fn_body_jdecl_params(jp)[i])) = eval_arg(fn_body_jmp_args(b)[i]);
Lean/Elab/Do.lean:  - `jmp`       a goto to a join-point
Lean/Elab/Do.lean:  - For every `jmp ref j as` in `C`, there is a `joinpoint j ps b k` and `jmp ref j as` is in `k`, and
Lean/Elab/Do.lean:  | jmp          (ref : Syntax) (jpName : Name) (args : Array Syntax)
Lean/Elab/Do.lean:    | Code.jmp _ j xs             => m!"jmp {j.simpMacroScopes} {xs.toList}"
Lean/Elab/Do.lean:    | Code.jmp _ _ _          => false
Lean/Elab/Do.lean:/- Convert `action _ e` instructions in `c` into `let y ← e; jmp _ jp (xs y)`. -/
Lean/Elab/Do.lean:      let jmpArgs := xs.map $ mkIdentFrom ref
Lean/Elab/Do.lean:      let jmpArgs := jmpArgs.push y
Lean/Elab/Do.lean:      pure $ Code.jmp ref jp jmpArgs
Lean/Elab/Do.lean:    return Code.jmp ref jp #[unit]
Lean/Elab/Do.lean:    return Code.jmp ref jp (xs.map $ mkIdentFrom ref)
Lean/Elab/Do.lean:  pure $ Code.jmp ref jp args
Lean/Elab/Do.lean:  | rs, c@(Code.jmp _ _ _)         => pure c
Lean/Elab/Do.lean:jmp jp x
Lean/Elab/Do.lean:jmp jp x
Lean/Elab/Do.lean:jmp jp y x
Lean/Elab/Do.lean:   and replace the `return _ y` with `jmp us y`
Lean/Elab/Do.lean:   and replace the `break` with `jmp us`.
Lean/Elab/Do.lean:  | Code.jmp ref j args     => pure $ mkJmp ref j args

src/shell/lean
add_executable(lean lean.cpp)

Lean/Environment.lean
namespace Kernel
/- Kernel API -/

/--
  Kernel isDefEq predicate. We use it mainly for debugging purposes.
  Recall that the Kernel type checker does not support metavariables.
  When implementing automation, consider using the `MetaM` methods. -/
@[extern "lean_kernel_is_def_eq"]
constant isDefEq (env : Environment) (lctx : LocalContext) (a b : Expr) : Bool

/--
  Kernel WHNF function. We use it mainly for debugging purposes.
  Recall that the Kernel type checker does not support metavariables.
  When implementing automation, consider using the `MetaM` methods. -/
@[extern "lean_kernel_whnf"]
constant whnf (env : Environment) (lctx : LocalContext) (a : Expr) : Expr

end Kernel

/home/bollu/work/lean4/src$ ag "lean_kernel_"
Lean/Environment.lean
689:@[extern "lean_kernel_is_def_eq"]
696:@[extern "lean_kernel_whnf"]

kernel/type_checker.cpp
1019:extern "C" uint8 lean_kernel_is_def_eq(lean_object * env, lean_object * lctx, lean_object * a, lean_object * b) {
1023:extern "C" lean_object * lean_kernel_whnf(lean_object * env, lean_object * lctx, lean_object * a) {

%1 = "lz.project"(%arg1) {value = 0 : i64} : (!lz.value) -> !lz.value
%2 = "lz.project"(%arg1) {value = 1 : i64} : (!lz.value) -> !lz.value
"lz.joinpoint"() ( {
^bb0(%arg6: !lz.value):  // no predecessors
  // vvvvUSE of %2 inside the joinpoint BB. vvvv
  "lz.caseRet"(%2) ( { 
    %3 = "lz.papExtend"(%arg5, %arg0, %arg1) : (!lz.value, !lz.value, !lz.value) -> !lz.value
    lz.return %3 : !lz.value
  },  {
    %3 = "lz.project"(%2) {value = 0 : i64} : (!lz.value) -> !lz.value
    %4 = "lz.papExtend"(%arg3, %0, %1, %3) : (!lz.value, !lz.value, !lz.value, !lz.value) -> !lz.value
    lz.return %4 : !lz.value
  },  {
    %3 = "lz.papExtend"(%arg5, %arg0, %arg1) : (!lz.value, !lz.value, !lz.value) -> !lz.value
    lz.return %3 : !lz.value
  },  {
    %3 = "lz.papExtend"(%arg5, %arg0, %arg1) : (!lz.value, !lz.value, !lz.value) -> !lz.value
    lz.return %3 : !lz.value
  }) : (!lz.value) -> ()
},  {
  ...
}

def main._closed_1 : obj :=
  let x_1 : obj := 10;
  let x_2 : obj := 41;
  let x_3 : obj := ctor_0[Vec.VecNum] x_1 x_2;
  ret x_3
def main._closed_2 : obj :=
  let x_1 : obj := 10;
  let x_2 : obj := 1;
  let x_3 : obj := ctor_0[Vec.VecNum] x_1 x_2;
  ret x_3
def main._closed_3 : obj :=
  let x_1 : obj := main._closed_1;
  let x_2 : obj := main._closed_2;
  let x_3 : obj := ctor_1[Vec.VecAdd] x_1 x_2;
  ret x_3
def main._closed_4 : obj :=
  let x_1 : obj := main._closed_3;
  let x_2 : obj := ctor_2[Vec.VecSum] x_1;
  ret x_2
def main (x_1 : obj) (x_2 : obj) : obj :=
  let x_3 : obj := main._closed_4;
  let x_4 : obj := runvec x_3 x_2;
  ret x_4// Lean compiler output

set_option compiler.extract_closed false

/home/bollu/work/lean4/src$ ag "to_lcnf"
library/compiler/compiler.cpp
202:    ds = apply(to_lcnf, env, ds);

library/compiler/compiler.cpp
162 environment compile(environment const & env, options const & opts, names cs) {
202    ds = apply(to_lcnf, env, ds);
203    ds = apply(find_jp, env, ds);

library/compiler/compiler.cpp
extern "C" object * lean_compile_decl(object * env, object * opts, object * decl) {
    return catch_kernel_exceptions<environment>([&]() {
            return compile(environment(env), options(opts, true), get_decl_names_for_code_gen(declaration(decl, true)));
        });
}

library/compiler/compiler.h
environment compile(environment const & env, options const & opts, names cs);
inline environment compile(environment const & env, options const & opts, name const & c) {
    return compile(env, opts, names(c));
}

shell/lean.cpp

contents = read_file(mod_fn);
main_module_name = module_name_of_file(mod_fn, root_dir, /* optional */ !olean_fn && !c_output);

if (!main_module_name)
    main_module_name = name("_stdin");
pair_ref<environment, object_ref> r = run_new_frontend(contents, opts, mod_fn, *main_module_name);

if (run && ok) {
    uint32 ret = ir::run_main(env, opts, argc - optind, argv + optind);
    // environment_free_regions(std::move(env));
    return ret;
}

shell/lean.cpp
326:extern "C" object * lean_run_frontend(object * input, object * opts, object * filename, object * main_module_name, object * w);
329:        lean_run_frontend(mk_string(input), opts.to_obj_arg(), mk_string(file_name), main_module_name.to_obj_arg(), io_mk_world()));

Lean/Elab/Frontend.lean
91:@[export lean_run_frontend]

/home/bollu/work/lean4$ ag "lean_compile_decl"
...
stage0/src/Lean/Environment.lean
132:@[extern "lean_compile_decl"]

src/Lean/Environment.lean
133:@[extern "lean_compile_decl"]

src/library/compiler/compiler.cpp
261:extern "C" object * lean_compile_decl(object * env, object * opts, object * decl) {

stage0/src/library/compiler/compiler.cpp
262:extern "C" object * lean_compile_decl(object * env, object * opts, object * decl) {

src/lean/Environment.lean
namespace Environment

/- Type check given declaration and add it to the environment -/
@[extern "lean_add_decl"]
constant addDecl (env : Environment) (decl : @& Declaration) : Except KernelException Environment

/- Compile the given declaration, it assumes the declaration has already been added to the environment using `addDecl`. -/
@[extern "lean_compile_decl"]
constant compileDecl (env : Environment) (opt : @& Options) (decl : @& Declaration) : Except KernelException Environment

/home/bollu/work/lean4/src$ ag "compileDecl" --type-add "lean:*.lean" -t lean
Lean/Environment.lean
134:constant compileDecl (env : Environment) (opt : @& Options) (decl : @& Declaration) : Except KernelException Environment
138:  compileDecl env opt decl

Lean/MonadEnv.lean
133:def compileDecl [Monad m] [MonadEnv m] [MonadError m] [MonadOptions m] (decl : Declaration) : m Unit := do
134:  match (← getEnv).compileDecl (← getOptions) decl with
142:  compileDecl decl

Lean/Elab/Declaration.lean
86:        compileDecl decl

Lean/Elab/BuiltinNotation.lean
101:  compileDecl decl

Lean/Elab/PreDefinition/Basic.lean
113:      compileDecl decl
134:    compileDecl decl

Lean/Elab/Binders.lean
71:    compileDecl decl

Lean/Meta/Match/Match.lean
600:      compileDecl decl

Lean/Meta/Closure.lean
364:    compileDecl decl

src/Lean/Meta/Basic.lean
/-
This module provides four (mutually dependent) goodies that are needed for building the elaborator and tactic frameworks.
1- Weak head normal form computation with support for metavariables and transparency modes.
2- Definitionally equality checking with support for metavariables (aka unification modulo definitional equality).
3- Type inference.
4- Type class resolution.

They are packed into the MetaM monad.
-/

  --mlir-pretty-debuginfo                               - Print pretty debug info in MLIR output
  --mlir-print-debug-counter                            - Print out debug counter information after all counters have been accumulated
  --mlir-print-debuginfo                                - Print debug info in MLIR output

// lz: a4f28b4
$ /home/bollu/work/lz/test/lambdapure/simple$ cat run-lean.sh
#!/usr/bin/env bash

set -e
set -o xtrace

lean $1 -c exe.c 2>&1 | \
        hask-opt | tee exe.mlir | \
        hask-opt --lean-lower --ptr-lower | \
        mlir-translate --mlir-to-llvmir | tee exe.ll  | llc -filetype=obj -o exe.o

c++ -D LEAN_MULTI_THREAD -I/home/bollu/work/lean4/build/stage1/include \
    exe.o \
    /home/bollu/work/lz/lean-linking-incantations/lean-shell.o \
    /home/bollu/work/lz/lean-linking-incantations/lib-includes/library.o  \
    -no-pie -Wl,--start-group -lleancpp -lInit -lStd -lLean -Wl,--end-group \
    -L/home/bollu/work/lean4/build/stage1/lib/lean -lgmp -ldl -pthread \
    -Wno-unused-command-line-argument -o exe.out
./exe.out

// main-print.lean
set_option trace.compiler.ir.init true
def main (xs: List String) : IO Unit := IO.println (7.9)

/home/bollu/work/lz/test/lambdapure/simple$ ./run-lean.sh main-print.lean 2>/dev/null
7.900000

%c0 = lz.int(0): () -> !lz.value
%out = std.call @Nat.decEq(%c0, %c0) : (!lz.value, !lz.value) -> !lz.value

$ hask-opt lower-lz-and-affine.mlir --lz-worker-wrapper --affine-loop-fusion

func @main() -> i64 {
  %c1024 = constant 1024 : index
  %c0_i64 = constant 0 : i64
  %0 = memref.alloc(%c1024) : memref<?xi64>
  affine.for %arg0 = 0 to 1024 {
    %2 = index_cast %arg0 : index to i64
    affine.store %2, %0[%arg0] : memref<?xi64>
  }
  %1 = affine.for %arg0 = 0 to 1024 iter_args(%arg1 = %c0_i64) -> (i64) {
    %2 = affine.load %0[%arg0] : memref<?xi64>
    %3 = addi %arg1, %2 : i64
    affine.yield %3 : i64
  }
  call @printInt(%1) : (i64) -> ()
  return %c0_i64 : i64
}

********************
Failed Tests (4):
  HASK_OPT :: lambdapure/bench/const_fold.lean
  HASK_OPT :: lambdapure/bench/deriv.lean
  HASK_OPT :: lambdapure/bench/qsort.lean
  HASK_OPT :: lambdapure/bench/rbmap_checkpoint.lean


Testing Time: 2.38s
  Passed    : 4
  Unresolved: 9
  Failed    : 4

<stdin>:163:55: error: duplicate key 'alt3' in dictionary attribute
    "lz.return"(%x_8): (!lz.value) -> ()}){alt3=@"3", alt3=@default}:(!lz.value)->()

--
<stdin>:1939:78: error: duplicate key 'alt5' in dictionary attribute
    "lz.return"(%x_10): (!lz.value) -> ()}){alt0=@"0", alt1=@"1", alt5=@"5", alt5=@default}:(!lz.value)->()

--interpreting function:|UInt32.ofNat|--
<stdin>:16:1: error: incorrect number of arguments to region. Given: |1|.Expected: |0| 

func private@"UInt32.ofNat"(!lz.value)->(!lz.value)
^
hask-opt: ../hask-opt/Interpreter.cpp:941: llvm::Optional<InterpValue> Interpreter::interpretRegion(mlir::Region&, llvm::ArrayRef<InterpValue>, Env): Assertion `false && "unable to interpret region"' failed.

<stdin>:72:12: error: unregistered operation 'lz.sproj' found in dialect ('lz') that does not allow unknown operations
    %x_6 = "lz.sproj"(%x_1){ix=3, offset=0}:(!lz.value)->(!lz.value)
           ^

<stdin>:1008:3: error: unregistered operation 'lz.sset' found in dialect ('lz') that does not allow unknown operations
  "lz.sset"(%x_71,%x_70){ix=7, offset=0}:(!lz.value, !lz.value)->()
  ^

analyzing constructor: |
analyzing constructor: |%%51 =  = ""lzl.zc.ocnonssttrruucctt"("()) { {dataconstructordataconstructor =  = @"@"00""}} :  : (() -> ) -> !!lzlz.value.value|

func private@"Float.add"(!lz.value, !lz.value)->(!lz.value)
func private@"Float.div"(!lz.value, !lz.value)->(!lz.value)
func private@"Nat.decLe"(!lz.value, !lz.value)->(!lz.value)
func private@"IO.Prim.Handle.putStr"(!lz.value, !lz.value, !lz.value)->(!lz.value)
func private@"IO.Prim.fopenFlags"(!lz.value, !lz.value)->(!lz.value)
func private@"IO.Prim.Handle.mk"(!lz.value, !lz.value, !lz.value)->(!lz.value)
func private@"USize.decLt"(!lz.value, !lz.value)->(!lz.value)

private def compileAux (decls : Array Decl) : CompilerM Unit := do
  log (LogEntry.message "// compileAux")
  -- logDecls `init decls
  logPreamble (LogEntry.message mlirPreamble)
  -- logDeclsUnconditional decls
  checkDecls decls
  let decls ← elimDeadBranches decls
  logDecls `elim_dead_branches decls
  let decls := decls.map Decl.pushProj
  logDecls `push_proj decls
  --vvvvvv DISABLE THIS
  -- let decls := decls.map Decl.insertResetReuse
  -- logDecls `reset_reuse decls
  let decls := decls.map Decl.elimDead
  logDecls `elim_dead decls
  let decls := decls.map Decl.simpCase
  logDecls `simp_case decls
  let decls := decls.map Decl.normalizeIds
  logDeclsUnconditional decls <- CODEGEN HERE 

src/shell/lean.cpp
int main() { ...

/home/bollu/work/lean4/src$ ag initialize_compiler
library/compiler/compiler.cpp
267:void initialize_compiler() {

/home/bollu/work/lean4/src$ vim library/compiler/extern_attribute.cpp 
/home/bollu/work/lean4/src$ ag "lean_get_extern_attr_data"
Lean/Compiler/ExternAttr.lean
75:@[export lean_get_extern_attr_data]

library/compiler/extern_attribute.cpp
22:extern "C" object* lean_get_extern_attr_data(object* env, object* n);
25:    return to_optional<extern_attr_data_value>(lean_get_extern_attr_data(env.to_obj_arg(), fn.to_obj_arg()));

/home/bollu/work/lz/test/lambdapure/simple$ hask-opt error.mlir --lz-lazify
forcifying user: |%6 = call @Nat_dot_decEq(%arg0, %4) : (!lz.thunk<!lz.value>, !lz.value) -> !lz.value
        after: |%6 = call @Nat_dot_decEq(%5, %4) : (!lz.value, !lz.value) -> !lz.value

vvvvv:module:vvvvv
module  {
  func private @Nat_dot_sub(!lz.value, !lz.value) -> !lz.value
  func private @Nat_dot_decEq(!lz.value, !lz.value) -> !lz.value
  func @ackermann_dot_match_1_dot__rarg(%arg0: !lz.thunk<!lz.value>) {
    %0 = "lz.int"() {value = 0 : i64} : () -> !lz.value
    %1 = call @Nat_dot_decEq(%arg0, %0) : (!lz.thunk<!lz.value>, !lz.value) -> !lz.value
    %2 = "lz.tagget"(%1) : (!lz.value) -> i64
    %3 = "lz.case"(%2) ( {
      %4 = "lz.int"() {value = 1 : i64} : () -> !lz.value
      %5 = "lz.force"(%arg0) : (!lz.thunk<!lz.value>) -> !lz.value
      %6 = call @Nat_dot_decEq(%5, %4) : (!lz.value, !lz.value) -> !lz.value
      lz.return %6 : !lz.value
    }) {alt0 = @"0"} : (i64) -> !lz.value
    return %3 : !lz.value
  }
}

^^^^^^
error.mlir:6:10: error: 'std.call' op operand type mismatch: expected operand
type '!lz.value', but provided '!lz.thunk<!lz.value>' for operand number 0
    %1 = call @Nat_dot_decEq(%arg0, %0) : (!lz.value, !lz.value) -> !lz.value
         ^
error.mlir:6:10: note: see current operation:
%1 = "std.call"(%arg0, %0) {callee = @Nat_dot_decEq} : (!lz.thunk<!lz.value>, !lz.value) -> !lz.value

def mkRandomArray : Nat -> Array Nat -> Array Nat
...
| i+1, as => mkRandomArray i (as.push (i+1))

func @sumAux(%arg0: !lz.value, %arg1: !lz.value) -> !lz.value {
  ...
  %5 = call @Nat_dot_sub(%arg0, %4) : (!lz.value, !lz.value) -> !lz.value
  %6 = call @instInhabitedNat() : () -> !lz.value
  %7 = "lz.erasedvalue"() : () -> !lz.value
  %8 = call @Array_dot_get_bang_(%7, %6, %arg1, %5) : (!lz.value, !lz.value, !lz.value, !lz.value) -> !lz.value

test (object -> object -> -> object) x_1 x_2 

  Let object x_3 = 2
  Let int x_4 = Call Nat_dot_decLt x_1 x_3
  Case  on x_4 : 
      Let object x_5 = Call mkNodes x_1 x_2
      Case  on x_5 : 
          Let object x_6 = Proj[0] x_5

          Let object x_7 = Proj[1] x_5

          Case  on x_6 : 
              Let object x_8 = Proj[0] x_6

              Let object x_9 = Ctor 0 x_8
              Let object x_10 = Ctor 0 x_9 x_7
              return x_10

                Let object x_11 = 50000
                Let object x_12 = Call mergePack x_11 x_7
                Case  on x_12 : 
                    Let object x_13 = Proj[0] x_12

                    Let object x_14 = Proj[1] x_12

                    Case  on x_13 : 
                        Let object x_15 = Proj[0] x_13

                        Let object x_16 = Ctor 0 x_15
                        Let object x_17 = Ctor 0 x_16 x_14
                        return x_17

                          Let object x_18 = 10000
                          Let object x_19 = Call mergePack x_18 x_14
                          Case  on x_19 : 
                              Let object x_20 = Proj[0] x_19

                              Let object x_21 = Proj[1] x_19

                              Case  on x_20 : 
                                  Let object x_22 = Proj[0] x_20

                                  Let object x_23 = Ctor 0 x_22
                                  Let object x_24 = Ctor 0 x_23 x_21
                                  return x_24

                                    Let object x_25 = 5000
                                    Let object x_26 = Call mergePack x_25 x_21
                                    Case  on x_26 : 
                                        Let object x_27 = Proj[0] x_26

                                        Let object x_28 = Proj[1] x_26

                                        Case  on x_27 : 
                                            Let object x_29 = Proj[0] x_27

                                            Let object x_30 = Ctor 0 x_29
                                            Let object x_31 = Ctor 0 x_30 x_28
                                            return x_31

                                              Let object x_32 = 1000
                                              Let object x_33 = Call mergePack x_32 x_28
                                              Case  on x_33 : 
                                                  Let object x_34 = Proj[0] x_33

                                                  Let object x_35 = Proj[1] x_33

                                                  Case  on x_34 : 
                                                      Let object x_36 = Proj[0] x_34

                                                      Let object x_37 = Ctor 0 x_36
                                                      Let object x_38 = Ctor 0 x_37 x_35
                                                      return x_38

                                                        Let object x_39 = Call numEqs x_35
                                                        return x_39

                                                          Let object x_40 = Call test_dot__closed_2
                                                          Let object x_41 = Ctor 0 x_40 x_2
                                                          return x_41

def test (x_1 : obj) (x_2 : obj) : obj :=
  let x_3 : obj := 2;
  let x_4 : u8 := Nat.decLt x_1 x_3;
  case x_4 : obj of
  Bool.false →
    let x_5 : obj := mkNodes x_1 x_2;
    case x_5 : obj of
    Prod.mk →
      let x_6 : obj := proj[0] x_5;
      let x_7 : obj := proj[1] x_5;
      case x_6 : obj of
      Except.error →
        let x_8 : obj := proj[0] x_6;
        let x_9 : obj := ctor_0[Except.error] x_8;
        let x_10 : obj := ctor_0[Prod.mk] x_9 x_7;
        ret x_10
      Except.ok →
        let x_11 : obj := 50000;
        let x_12 : obj := mergePack x_11 x_7;
        case x_12 : obj of
        Prod.mk →
          let x_13 : obj := proj[0] x_12;
          let x_14 : obj := proj[1] x_12;
          case x_13 : obj of
          Except.error →
            let x_15 : obj := proj[0] x_13;
            let x_16 : obj := ctor_0[Except.error] x_15;
            let x_17 : obj := ctor_0[Prod.mk] x_16 x_14;
            ret x_17
          Except.ok →
            let x_18 : obj := 10000;
            let x_19 : obj := mergePack x_18 x_14;
            case x_19 : obj of
            Prod.mk →
              let x_20 : obj := proj[0] x_19;
              let x_21 : obj := proj[1] x_19;
              case x_20 : obj of
              Except.error →
                let x_22 : obj := proj[0] x_20;
                let x_23 : obj := ctor_0[Except.error] x_22;
                let x_24 : obj := ctor_0[Prod.mk] x_23 x_21;
                ret x_24
              Except.ok →
                let x_25 : obj := 5000;
                let x_26 : obj := mergePack x_25 x_21;
                case x_26 : obj of
                Prod.mk →
                  let x_27 : obj := proj[0] x_26;
                  let x_28 : obj := proj[1] x_26;
                  case x_27 : obj of
                  Except.error →
                    let x_29 : obj := proj[0] x_27;
                    let x_30 : obj := ctor_0[Except.error] x_29;
                    let x_31 : obj := ctor_0[Prod.mk] x_30 x_28;
                    ret x_31
                  Except.ok →
                    let x_32 : obj := 1000;
                    let x_33 : obj := mergePack x_32 x_28;
                    case x_33 : obj of
                    Prod.mk →
                      let x_34 : obj := proj[0] x_33;
                      let x_35 : obj := proj[1] x_33;
                      case x_34 : obj of
                      Except.error →
                        let x_36 : obj := proj[0] x_34;
                        let x_37 : obj := ctor_0[Except.error] x_36;
                        let x_38 : obj := ctor_0[Prod.mk] x_37 x_35;
                        ret x_38
                      Except.ok →
                        let x_39 : obj := numEqs x_35;
                        ret x_39
  Bool.true →
    let x_40 : obj := test._closed_2;
    let x_41 : obj := ctor_0[Prod.mk] x_40 x_2;
    ret x_41

def test (x_1 : obj) (x_2 : obj) : obj :=
  let x_3 : obj := 2;
  let x_4 : u8 := Nat.decLt x_1 x_3;
  case x_4 : obj of
  Bool.false →
    let x_5 : obj := mkNodes x_1 x_2;
    case x_5 : obj of
    ...
  Bool.true → <= MISSING
    let x_40 : obj := test._closed_2;
    let x_41 : obj := ctor_0[Prod.mk] x_40 x_2;
    ret x_41

// interesting: semantics of jump is determined by "enclosing block",
// something that regions help make precise!
if (auto jumpop = dyn_cast<standalone::HaskJumpOp>(op)) { }

-- encoding of OK
let x_4 : obj := ctor_0[EStateM.Result.ok] x_3 x_2;

********************
Failed Tests (4):
  HASK_OPT :: lambdapure/bench/const_fold.lean
  HASK_OPT :: lambdapure/bench/deriv.lean
  HASK_OPT :: lambdapure/bench/qsort.lean
  HASK_OPT :: lambdapure/bench/rbmap_checkpoint.lean


Testing Time: 5.72s
  Passed    : 13

Lean/Compiler/IR/Format.lean

private def formatExpr : Expr → Format
  | Expr.ctor i ys      => format i ++ formatArray ys
  | Expr.reset n x      => "reset[" ++ format n ++ "] " ++ format x
  | Expr.reuse x i u ys => "reuse" ++ (if u then "!" else "") ++ " " ++ format x ++ " in " ++ format i ++ formatArray ys
  | Expr.proj i x       => "proj[" ++ format i ++ "] " ++ format x
  | Expr.uproj i x      => "uproj[" ++ format i ++ "] " ++ format x
  | Expr.sproj n o x    => "sproj[" ++ format n ++ ", " ++ format o ++ "] " ++ format x
  | Expr.fap c ys       => format c ++ formatArray ys
  | Expr.pap c ys       => "pap " ++ format c ++ formatArray ys
  | Expr.ap x ys        => "app " ++ format x ++ formatArray ys
  | Expr.box _ x        => "box " ++ format x
  | Expr.unbox x        => "unbox " ++ format x
  | Expr.lit v          => format v
  | Expr.isShared x     => "isShared " ++ format x
  | Expr.isTaggedPtr x  => "isTaggedPtr " ++ format x

inductive LogEntry where
  | step (cls : Name) (decls : Array Decl)
  | message (msg : Format)

namespace LogEntry
protected def fmt : LogEntry → Format
  | step cls decls => Format.bracket "[" (format cls) "]" ++ decls.foldl (fun fmt decl => fmt ++ Format.line ++ format decl) Format.nil
  | message msg    => msg

Lean/Compiler/IR.lean
28:  logDecls `init decls

Lean/Compiler/IR/CompilerM.lean:

def tracePrefixOptionName := `trace.compiler.ir

private def isLogEnabledFor (opts : Options) (optName : Name) : Bool :=
  match opts.find optName with
  | some (DataValue.ofBool v) => v
  | other => opts.getBool tracePrefixOptionName

private def logDeclsAux (optName : Name) (cls : Name) (decls : Array Decl) : CompilerM Unit := do
  let opts ← read
  if isLogEnabledFor opts optName then
    log (LogEntry.step cls decls)

block_14 (x_24 : obj) :=
  case x_13 : obj of
  Expr.Var →
    let x_25 : obj := app x_6 x_1 x_2;
    ret x_25
  Expr.Val →
    let x_26 : obj := proj[0] x_13;
    let x_27 : obj := app x_4 x_8 x_12 x_26;
    ret x_27
  Expr.Add →
    let x_28 : obj := app x_6 x_1 x_2;
    ret x_28
  Expr.Mul →
    let x_29 : obj := app x_6 x_1 x_2;
    ret x_29;
case x_12 : obj of
Expr.Var →
  let x_15 : obj := ctor_0[PUnit.unit];
  jmp block_14 x_15

let x_18 : obj := prec(_)._closed_3;

def term↑__1._closed_1 : obj :=
  let x_1 : obj := "term↑__1";
  ret x_1

set_option trace.compiler.ir.init true

inductive L
| Nil
| Cons : Nat -> L -> L

open L
instance : Inhabited L := ⟨Nil⟩

def filter : L -> L
| Nil => Nil
| Cons n l => if n > 5 then filter l else Cons n (filter l)

partial def make' : Nat -> Nat -> L
| n,d =>
  if d = 0 then Cons n Nil
  else Cons (n-d) (make' n (d -1))                     

def make (n : Nat) : L := make' n n

unsafe def main : List String → IO UInt32
| _ => let x := make 100; pure 0


def main2 : L := make 100 

sed -i "s|runtime/lean.h|lean/lean.h|g"  out.cpp
sed -i "s|return 0;|main2(); return 0;|g" out.cpp
leanc out.cpp -o out

[Alt' idBnd idOcc dcOcc tcOcc]      -- The DEFAULT case is always *first*
                                     -- if it is there at all

bollu@cantordust:~/temp/ > cat foo.hs  
{-# LANGUAGE NoImplicitPrelude #-}
module Foo where

data Bar = MkBar

foo :: Bar
foo = MkBar


bollu@cantordust:~/temp/ > lsfoo  foo.ghc_stgapp  foo.hi  foo.hs  foo.o  foo.o_modpak
bollu@cantordust:~/temp/ > rm foo.hi foo.o_modpak foo.o foo.ghc_stgapp 
bollu@cantordust:~/temp/ > ~/work/ghc-whole-program-compiler-project/ghc-wpc/_build/stage1/bin/ghc foo.hs
[1 of 1] Compiling Foo              ( foo.hs, foo.o )
bollu@cantordust:~/temp/ > /home/bollu/work/ghc-whole-program-compiler-project/external-stg/dist-newstyle/build/x86_64-linux/ghc-8.8.3/external-stg-0.1.0.1/x/ext-stg/build/ext-stg/ext-stg show foo.o_modpak
{- stg -}
package main
module Foo where

using ghc-prim : GHC.Types
using main : Foo

externals
  (ghc-prim_GHC.Types.[] : LiftedRep (forall a. [a]))
  (ghc-prim_GHC.Types.krep$* : LiftedRep (KindRep))

type
  ghc-prim_GHC.Types.KindRep
    ghc-prim_GHC.Types.KindRepTyConApp :: AlgDataCon [LiftedRep,LiftedRep]
    ghc-prim_GHC.Types.KindRepVar :: AlgDataCon [IntRep]
    ghc-prim_GHC.Types.KindRepApp :: AlgDataCon [LiftedRep,LiftedRep]
    ghc-prim_GHC.Types.KindRepFun :: AlgDataCon [LiftedRep,LiftedRep]
    ghc-prim_GHC.Types.KindRepTYPE :: AlgDataCon [LiftedRep]
    ghc-prim_GHC.Types.KindRepTypeLitS :: AlgDataCon [LiftedRep,AddrRep]
    ghc-prim_GHC.Types.KindRepTypeLitD :: AlgDataCon [LiftedRep,LiftedRep]
  
  ghc-prim_GHC.Types.Module
    ghc-prim_GHC.Types.Module :: AlgDataCon [LiftedRep,LiftedRep]
  
  ghc-prim_GHC.Types.TrName
    ghc-prim_GHC.Types.TrNameS :: AlgDataCon [AddrRep]
    ghc-prim_GHC.Types.TrNameD :: AlgDataCon [LiftedRep]
  
  ghc-prim_GHC.Types.TyCon
    ghc-prim_GHC.Types.TyCon :: AlgDataCon [WordRep,WordRep,LiftedRep,LiftedRep,IntRep,LiftedRep]
  
  ghc-prim_GHC.Types.[]
    ghc-prim_GHC.Types.[] :: AlgDataCon []
    ghc-prim_GHC.Types.: :: AlgDataCon [LiftedRep,LiftedRep]
  
  main_Foo.Bar
    main_Foo.MkBar :: AlgDataCon []
  

(main_Foo.MkBar : LiftedRep (Bar)) =
  main_Foo.MkBar :: AlgDataCon [] 

(main_Foo.$tc'MkBar1 : AddrRep (Addr#)) =
  "'MkBar"

(main_Foo.$tc'MkBar2 : LiftedRep (TrName)) =
  ghc-prim_GHC.Types.TrNameS :: AlgDataCon [AddrRep] main_Foo.$tc'MkBar1

(main_Foo.$tcBar1 : AddrRep (Addr#)) =
  "Bar"

(main_Foo.$tcBar2 : LiftedRep (TrName)) =
  ghc-prim_GHC.Types.TrNameS :: AlgDataCon [AddrRep] main_Foo.$tcBar1

(main_Foo.$trModule3 : AddrRep (Addr#)) =
  "Foo"

(main_Foo.$trModule4 : LiftedRep (TrName)) =
  ghc-prim_GHC.Types.TrNameS :: AlgDataCon [AddrRep] main_Foo.$trModule3

(main_Foo.$trModule1 : AddrRep (Addr#)) =
  "main"

(main_Foo.$trModule2 : LiftedRep (TrName)) =
  ghc-prim_GHC.Types.TrNameS :: AlgDataCon [AddrRep] main_Foo.$trModule1

(main_Foo.$trModule : LiftedRep (Module)) =
  ghc-prim_GHC.Types.Module :: AlgDataCon [LiftedRep,LiftedRep] main_Foo.$trModule2 main_Foo.$trModule4

(main_Foo.$tcBar : LiftedRep (TyCon)) =
  ghc-prim_GHC.Types.TyCon :: AlgDataCon [WordRep,WordRep,LiftedRep,LiftedRep,IntRep,LiftedRep] #Word#9087065647546038855 #Word#17224336406314564570 main_Foo.$trModule main_Foo.$tcBar2 #Int#0 ghc-prim_GHC.Types.krep$*

(main_Foo.$krep : LiftedRep (KindRep)) =
  ghc-prim_GHC.Types.KindRepTyConApp :: AlgDataCon [LiftedRep,LiftedRep] main_Foo.$tcBar ghc-prim_GHC.Types.[]

(main_Foo.$tc'MkBar : LiftedRep (TyCon)) =
  ghc-prim_GHC.Types.TyCon :: AlgDataCon [WordRep,WordRep,LiftedRep,LiftedRep,IntRep,LiftedRep] #Word#3328458281052523173 #Word#5691101527919328307 main_Foo.$trModule main_Foo.$tc'MkBar2 #Int#0 main_Foo.$krep

(main_Foo.foo : LiftedRep (Bar)) =
  main_Foo.MkBar :: AlgDataCon [] 

foreign stub C header {

}
foreign stub C source {

}
foreign files

testsuite/tests/stranal
testsuite/tests/cpranal
testsuite/tests/arityanal

commit 9eb3e564d3b1c772a64eef6ecaa3b1705d065218
Author: Chris Lattner <[email protected]>
Date:   Wed Dec 23 18:13:39 2020 -0800

    [ODS] Make the getType() method on a OneResult instruction return a specific type.

/home/bollu/work/mlir/llvm-project/build/lib/libMLIRTargetLLVMIR.so.12git: undefined reference to `mlir::LLVM::LLVMType::getFunctionParamType(unsigned int)'
/home/bollu/work/mlir/llvm-project/build/lib/libMLIRTargetLLVMIR.so.12git: undefined reference to `mlir::MutableDictionaryAttr::set(mlir::Identifier, mlir::Attribute)'
/home/bollu/work/mlir/llvm-project/build/lib/libMLIRTargetLLVMIR.so.12git: undefined reference to `mlir::LLVM::LLVMType::getVectorElementCount()'
/home/bollu/work/mlir/llvm-project/build/lib/libMLIRTargetLLVMIR.so.12git: undefined reference to `mlir::LLVM::LLVMType::getVectorElementType()'
/home/bollu/work/mlir/llvm-project/build/lib/libMLIRTargetLLVMIR.so.12git: undefined reference to `mlir::LLVM::LLVMType::getIntegerBitWidth()'
/home/bollu/work/mlir/llvm-project/build/lib/libMLIRTargetLLVMIR.so.12git: undefined reference to `mlir::LLVM::LLVMType::isArrayTy()'
/home/bollu/work/mlir/llvm-project/build/lib/libMLIRTargetLLVMIR.so.12git: undefined reference to `mlir::LLVM::LLVMType::isVectorTy()'
/home/bollu/work/mlir/llvm-project/build/lib/libMLIRTargetLLVMIR.so.12git: undefined reference to `mlir::IntegerType::get(unsigned int, mlir::MLIRContext*)'
/home/bollu/work/mlir/llvm-project/build/lib/libMLIRTargetLLVMIR.so.12git: undefined reference to `mlir::LLVM::LLVMType::getArrayNumElements()'
/home/bollu/work/mlir/llvm-project/build/lib/libMLIRTargetLLVMIR.so.12git: undefined reference to `mlir::LLVM::LLVMFuncOp::build(mlir::OpBuilder&, mlir::OperationState&, llvm::StringRef, mlir::LLVM::LLVMType, mlir::LLVM::Linkage, llvm::Ar
te> >, llvm::ArrayRef<mlir::MutableDictionaryAttr>)'
/home/bollu/work/mlir/llvm-project/build/lib/libMLIRTargetLLVMIR.so.12git: undefined reference to `mlir::NamedAttrList::append(mlir::Identifier, mlir::Attribute)'
/home/bollu/work/mlir/llvm-project/build/lib/libMLIRTargetLLVMIR.so.12git: undefined reference to `mlir::LLVM::LLVMType::getArrayElementType()'
clang: error: linker command failed with exit code 1 (use -v to see invocation)
ninja: build stopped: subcommand failed.

0.	Program arguments: hask-opt lower-ap.mlir --lz-lower --ptr-lower
 #0 0x000000000046dceb backtrace (/home/bollu/work/mlir/lz/build/bin/hask-opt+0x46dceb)
 #1 0x0000000000632c6c llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) (/home/bollu/work/mlir/lz/build/bin/hask-opt+0x632c6c)
 #2 0x0000000000630844 llvm::sys::RunSignalHandlers() (/home/bollu/work/mlir/lz/build/bin/hask-opt+0x630844)
 #3 0x00000000006309b3 SignalHandler(int) (/home/bollu/work/mlir/lz/build/bin/hask-opt+0x6309b3)
 #4 0x00007f9f79ee0980 __restore_rt (/lib/x86_64-linux-gnu/libpthread.so.0+0x12980)
 #5 0x00007f9f7892ffb7 raise /build/glibc-S7xCS9/glibc-2.27/signal/../sysdeps/unix/sysv/linux/raise.c:51:0
 #6 0x00007f9f78931921 abort /build/glibc-S7xCS9/glibc-2.27/stdlib/abort.c:81:0
 #7 0x00007f9f7892148a __assert_fail_base /build/glibc-S7xCS9/glibc-2.27/assert/assert.c:89:0
 #8 0x00007f9f78921502 (/lib/x86_64-linux-gnu/libc.so.6+0x30502)
 #9 0x0000000000985f8a mlir::detail::Interface<mlir::OffsetSizeAndStrideOpInterface, mlir::Operation*, mlir::detail::OffsetSizeAndStrideOpInterfaceInterfaceTraits, mlir::Op<mlir::OffsetSizeAndStrideOpInterface>, mlir::OpTrait::TraitBase>::Interface(mlir::Operation*) (/home/bollu/work/mlir/lz/build/bin/hask-opt+0x985f8a)
#10 0x0000000000985de0 mlir::OpInterface<mlir::OffsetSizeAndStrideOpInterface, mlir::detail::OffsetSizeAndStrideOpInterfaceInterfaceTraits>::OpInterface(mlir::Operation*) (/home/bollu/work/mlir/lz/build/bin/hask-opt+0x985de0)
#11 0x000000000097cf40 mlir::OffsetSizeAndStrideOpInterface::OffsetSizeAndStrideOpInterface(mlir::Operation*) (/home/bollu/work/mlir/lz/build/bin/hask-opt+0x97cf40)
#12 0x000000000097b767 LowerPointerPass::runOnOperation() (/home/bollu/work/mlir/lz/build/bin/hask-opt+0x97b767)
#13 0x0000000000a9eda1 mlir::detail::OpToOpPassAdaptor::run(mlir::Pass*, mlir::Operation*, mlir::AnalysisManager, bool) (/home/bollu/work/mlir/lz/build/bin/hask-opt+0xa9eda1)
#14 0x0000000000a9f051 mlir::detail::OpToOpPassAdaptor::runPipeline(llvm::iterator_range<llvm::pointee_iterator<std::unique_ptr<mlir::Pass, std::default_delete<mlir::Pass> >*, mlir::Pass> >, mlir::Operation*, mlir::AnalysisManager, bool) (/home/bollu/work/mlir/lz/build/bin/hask-opt+0xa9f051)
#15 0x0000000000aa1a11 mlir::PassManager::run(mlir::ModuleOp) (/home/bollu/work/mlir/lz/build/bin/hask-opt+0xaa1a11)
#16 0x00000000009d5525 performActions(llvm::raw_ostream&, bool, bool, llvm::SourceMgr&, mlir::MLIRContext*, mlir::PassPipelineCLParser const&) (.constprop.101) (/home/bollu/work/mlir/lz/build/bin/hask-opt+0x9d5525)
#17 0x00000000009d5a97 processBuffer(llvm::raw_ostream&, std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, bool, bool, bool, bool, mlir::PassPipelineCLParser const&, mlir::DialectRegistry&) (/home/bollu/work/mlir/lz/build/bin/hask-opt+0x9d5a97)
#18 0x00000000009d5c66 mlir::MlirOptMain(llvm::raw_ostream&, std::unique_ptr<llvm::MemoryBuffer, std::default_delete<llvm::MemoryBuffer> >, mlir::PassPipelineCLParser const&, mlir::DialectRegistry&, bool, bool, bool, bool, bool) (/home/bollu/work/mlir/lz/build/bin/hask-opt+0x9d5c66)
#19 0x00000000009d60ad mlir::MlirOptMain(int, char**, llvm::StringRef, mlir::DialectRegistry&, bool) (/home/bollu/work/mlir/lz/build/bin/hask-opt+0x9d60ad)
#20 0x00000000004db274 main (/home/bollu/work/mlir/lz/build/bin/hask-opt+0x4db274)
#21 0x00007f9f78912bf7 __libc_start_main /build/glibc-S7xCS9/glibc-2.27/csu/../csu/libc-start.c:344:0
#22 0x00000000004373fa _start (/home/bollu/work/mlir/lz/build/bin/hask-opt+0x4373fa)
fish: Job 1, 'hask-opt lower-ap.mlir --lz-l...' terminated by signal SIGABRT (Abort)

fails with:

//===-------------------------------------------===//

because for whatever reason, `LLVM::UndefOp` can only take a 

but succeeds with:

```cpp
auto undef = rewriter.create<HaskUndefOp>(
  rewriter.getUnknownLoc(),
  typeConverter->convertType(caseop.getResult().getType()));

===
"func"() ( {
^bb0(%arg0: !ptr.void, %arg1: !ptr.void):  // no predecessors
  %0 = "lz.force"(<<UNKNOWN SSA VALUE>>) : (!lz.thunk<i64>) -> i64
  %1 = "lz.force"(<<UNKNOWN SSA VALUE>>) : (!lz.thunk<i64>) -> i64
  "std.return"(%0) : (i64) -> ()
}) {sym_name = "f", type = (!ptr.void, !ptr.void) -> !ptr.void} : () -> ()
===

    // vvv HACK: I shouldn't have to call this manually?!
    typeConverter->materializeSourceConversion(builder, out.getLoc(), )

** Insert  : 'ptr.ptrtoint'(0x60c0000040c0)
hask-opt: /usr/local/include/mlir/IR/Builders.h:400: OpTy mlir::OpBuilder::create(mlir::Location, Args &&...) [OpTy = mlir::ptr::PtrPtrToIntOp, Args = <mlir::Value, mlir::IntegerType &>]: Assertion `result && "builder didn't return the right type"' failed.

lower-case-single-alt-no-args.mlir:9:10: error: 'scf.if' op expects region #0 to have 0 or 1 blocks
    %y = lz.case @Maybe %boxedx
         ^
lower-case-single-alt-no-args.mlir:9:10: note: see current operation: %8 = "scf.if"(%7) ( {
^bb1:  // no predecessors
  %9 = "llvm.mlir.addressof"() {global_name = @Nothing} : () -> !llvm.ptr<array<7 x i8>>
  %10 = "llvm.mlir.constant"() {value = 0 : index} : () -> !llvm.i64
  %11 = "llvm.getelementptr"(%9, %10, %10) : (!llvm.ptr<array<7 x i8>>, !llvm.i64, !llvm.i64) -> !llvm.ptr<i8>
  %12 = "llvm.call"(%11) {callee = @mkConstructor0} : (!llvm.ptr<i8>) -> !llvm.ptr<i8>
  "scf.yield"(%12) : (!llvm.ptr<i8>) -> ()
},  {
}) : (!llvm.i1) -> !llvm.ptr<i8>

module {
func @main() -> i1 {
    %foo = constant 1 : i1
    lz.return %foo : i1
}
}

module {
  func @main() {
    %y = constant 42 : i64
    %boxy = lz.construct(@Just, %y: i64) // check box of i64
    return
  }
}

    Legalizing operation : 'scf.if'(0x60f0000009a8) {
      * Fold {
      } -> FAILURE : unable to fold

      * Pattern : 'scf.if -> ()' {
        ** Insert  : 'std.br'(0x60c0000046c0)
        ** Insert  : 'std.br'(0x60e000000820)
        ** Erase   : 'lz.return'(0x60c000004480)

Error: KNOWN NON TERMINATOR:%14 = scf.if %13 -> (!lz.value) {
^bb1(%15: i64):  // no predecessors
  %c1_i64 = constant 1 : i64
  %16 = addi %15, %c1_i64 : i64
  %17 = "lz.construct"(%16) {dataconstructor = @Just} : (i64) -> !lz.value
  lz.return %17 : !lz.value
}

ERROR IN OPERATION:
%9 = scf.if %6 -> (!lz.value) {
} else {
  %10 = llvm.mlir.addressof @Just : !llvm.ptr<array<4 x i8>>
  %11 = llvm.mlir.constant(0 : index) : !llvm.i64
  %12 = llvm.getelementptr %10[%11, %11] : (!llvm.ptr<array<4 x i8>>, !llvm.i64, !llvm.i64) -> !llvm.ptr<i8>
  %13 = llvm.call @isConstructorTagEq(%1, %12) : (!lz.value, !llvm.ptr<i8>) -> !llvm.i1
  %14 = scf.if %13 -> (!lz.value) {
  ^bb1(%15: i64):  // no predecessors
    %c1_i64 = constant 1 : i64
    %16 = addi %15, %c1_i64 : i64
    %17 = "lz.construct"(%16) {dataconstructor = @Just} : (i64) -> !lz.value
    lz.return %17 : !lz.value
  }
}

Error: EMPTY BB!

ERROR IN OPERATION:
%7 = "scf.if"(%6) ( {
^bb1:  // no predecessors
  %8 = "lz.construct"() {dataconstructor = @Nothing} : () -> !lz.value
  "lz.return"(%8) : (!lz.value) -> ()
},  {
}) : (!llvm.i1) -> !lz.value
hask-opt: /home/bollu/work/mlir/llvm-project/mlir/lib/IR/Block.cpp:231: mlir::Operation* mlir::Block::getTerminator(): Assertion `!empty() && !back().isKnownNonTerminator()' faile

lower-case.mlir:6:15: error: 'llvm.call' op operand type mismatch for operand 1: '!llvm.i64' != '!llvm.ptr<i8>'
    %boxedx = lz.construct(@Just, %x: i64)
              ^
lower-case.mlir:6:15: note: see current operation: %4 = "llvm.call"(%3, %0) {callee = @mkConstructor1} : (!llvm.ptr<i8>, !llvm.i64) -> !llvm.ptr<i8>
===Hask -> LLVM lowering failed===
module  {
  llvm.mlir.global internal constant @Nothing("Nothing")
  llvm.func @isConstructorTagEq(!llvm.ptr<i8>, !llvm.ptr<i8>) -> !llvm.i1
  llvm.mlir.global internal constant @Just("Just")
  llvm.func @mkConstructor1(!llvm.ptr<i8>, !llvm.ptr<i8>) -> !llvm.ptr<i8>
  llvm.func @main() -> !llvm.ptr<i8> {
    %0 = llvm.mlir.constant(42 : i64) : !llvm.i64
    %1 = llvm.mlir.addressof @Just : !llvm.ptr<array<4 x i8>>
    %2 = llvm.mlir.constant(0 : index) : !llvm.i64
    %3 = llvm.getelementptr %1[%2, %2] : (!llvm.ptr<array<4 x i8>>, !llvm.i64, !llvm.i64) -> !llvm.ptr<i8>
    %4 = llvm.call @mkConstructor1(%3, %0) : (!llvm.ptr<i8>, !llvm.i64) -> !llvm.ptr<i8>
    %5 = llvm.mlir.addressof @Nothing : !llvm.ptr<array<7 x i8>>
    %6 = llvm.mlir.constant(0 : index) : !llvm.i64
    %7 = llvm.getelementptr %5[%6, %6] : (!llvm.ptr<array<7 x i8>>, !llvm.i64, !llvm.i64) -> !llvm.ptr<i8>
    %8 = llvm.call @isConstructorTagEq(%4, %7) : (!llvm.ptr<i8>, !llvm.ptr<i8>) -> !llvm.i1
    llvm.cond_br %8, ^bb1, ^bb3
  ^bb1:  // pred: ^bb0
  ^bb2:  // no predecessors
    %9 = "lz.construct"() {dataconstructor = @Nothing} : () -> !lz.value
    %10 = llvm.inttoptr %9 : !lz.value to !llvm.ptr<i8>
    llvm.br ^bb8(%10 : !llvm.ptr<i8>)
  ^bb3:  // pred: ^bb0
    %11 = llvm.mlir.addressof @Just : !llvm.ptr<array<4 x i8>>
    %12 = llvm.mlir.constant(0 : index) : !llvm.i64
    %13 = llvm.getelementptr %11[%12, %12] : (!llvm.ptr<array<4 x i8>>, !llvm.i64, !llvm.i64) -> !llvm.ptr<i8>
    %14 = llvm.call @isConstructorTagEq(%4, %13) : (!llvm.ptr<i8>, !llvm.ptr<i8>) -> !llvm.i1
    llvm.cond_br %14, ^bb4, ^bb6
  ^bb4:  // pred: ^bb3
  ^bb5(%15: !llvm.i64):  // no predecessors
    %c1_i64 = constant 1 : i64
    %16 = "std.addi"(%15, %c1_i64) : (!llvm.i64, i64) -> i64
    %17 = "lz.construct"(%16) {dataconstructor = @Just} : (i64) -> !lz.value
    %18 = llvm.inttoptr %17 : !lz.value to !llvm.ptr<i8>
    llvm.br ^bb6(%18 : !llvm.ptr<i8>)
  ^bb6(%19: !llvm.ptr<i8>):  // 2 preds: ^bb3, ^bb5
    llvm.br ^bb7
  ^bb7:  // pred: ^bb6
    %20 = llvm.inttoptr %19 : !llvm.ptr<i8> to !llvm.ptr<i8>
    llvm.br ^bb8(%20 : !llvm.ptr<i8>)
  ^bb8(%21: !llvm.ptr<i8>):  // 2 preds: ^bb2, ^bb7
    llvm.br ^bb9
  ^bb9:  // pred: ^bb8
    llvm.return %21 : !llvm.ptr<i8>
  }
}

lower-linalg.mlir:14:3: error: failed to legalize operation 'func'
  func @sum(%buffert: !lz.thunk<memref<?xi64>>) -> i64 {

//foo.mlir
module {
  func @main () -> i64 {
    %size = std.constant 1024 : i64
    return %size : i64
  }
}

[I] /home/bollu/work/mlir/lz/test/ToLLVM > ninja -C ~/work/mlir/lz/build/ &&  hask-opt --lz-lower-to-llvm foo.mlir
module  {
  llvm.func @main() -> !llvm.i64 {
    %0 = llvm.mlir.constant(1024 : i64) : !llvm.i64
    llvm.return %0 : !llvm.i64
  }
}

[I] /home/bollu/work/mlir/lz/test/ToLLVM > ninja -C ~/work/mlir/lz/build/ &&  hask-opt --lz-lower-to-llvm foo.mlir

foo.mlir:6:3: error: failed to legalize operation 'func'
  func @main (%x: !lz.thunk<i64>) -> i64 {
  ^
foo.mlir:6:3: note: see current operation: "func"() ( {
^bb0(%arg0: !lz.thunk<i64>):  // no predecessors
  %c1024_i64 = "std.constant"() {value = 1024 : i64} : () -> i64
  "std.return"(%c1024_i64) : (i64) -> ()
}) {sym_name = "main", type = (!lz.thunk<i64>) -> i64} : () -> ()
===Hask -> LLVM lowering failed===
module  {
  func @main(%arg0: !lz.thunk<i64>) -> i64 {
    %c1024_i64 = constant 1024 : i64
    return %c1024_i64 : i64
  }
}

// lower-linalg.mlir
lower-linalg.mlir:17:10: error: failed to legalize operation 'std.dim'
    %N = dim %buffer, %c0 : memref<?xi64>
         ^
lower-linalg.mlir:17:10: note: see current operation: %3 = "std.dim"(%1, %c0) : (memref<?xi64>, index) -> index

module  {
  func @sum(%arg0: !lz.thunk<memref<?xi64>>) -> i64 {
    %0 = "lz.force"(%arg0) : (!lz.thunk<memref<?xi64>>) -> memref<?xi64>
    %c0 = constant 0 : index
    %1 = dim %0, %c0 : memref<?xi64>
    %c0_i64 = constant 0 : i64
    %2 = affine.for %arg1 = 0 to %1 iter_args(%arg2 = %c0_i64) -> (i64) {
      %3 = affine.load %0[%arg1] : memref<?xi64>
      %4 = addi %arg2, %3 : i64
      affine.yield %4 : i64
    }
    return %2 : i64
  }
  func @seq(%arg0: i64) -> memref<?xi64> {
    %0 = index_cast %arg0 : i64 to index
    %1 = alloc(%0) : memref<?xi64>
    affine.for %arg1 = 0 to %0 {
      %2 = index_cast %arg1 : index to i64
      affine.store %2, %1[%arg1] : memref<?xi64>
    }
    return %1 : memref<?xi64>
  }
  func @main() -> i64 {
    %f = constant @seq : (i64) -> memref<?xi64>
    %c1024_i64 = constant 1024 : i64
    %0 = "lz.ap"(%f, %c1024_i64) : ((i64) -> memref<?xi64>, i64) -> !lz.thunk<memref<?xi64>>
    %f_0 = constant @sum : (!lz.thunk<memref<?xi64>>) -> i64
    %1 = "lz.ap"(%f_0, %0) : ((!lz.thunk<memref<?xi64>>) -> i64, !lz.thunk<memref<?xi64>>) -> !lz.thunk<i64>
    %2 = "lz.force"(%1) : (!lz.thunk<i64>) -> i64
    return %2 : i64
  }
}

    mlir::FuncOp outlinedFn = parentfn.clone();
    outlinedFn.setName(outlinedFnName);
    outlinedFn.setType(outlinedFnty);

"module"() ( {
  "func"() ( {
  ^bb0(%arg0: !lz.value):  // no predecessors
    %c42_i64 = "std.constant"() {value = 42 : i64} : () -> i64
    %c1_i64 = "std.constant"() {value = 1 : i64} : () -> i64
    %f = "std.constant"() {value = @f_outline_case_arg} : () -> ((i64) -> !lz.value)
    %0 = "lz.case"(%arg0) ( {
    ^bb0(%arg1: i64):  // no predecessors
      %1 = "lz.caseint"(%arg1) ( {
        %2 = "lz.construct"(%c42_i64) {dataconstructor = @SimpleInt} : (i64) -> !lz.value
        "lz.return"(%2) : (!lz.value) -> ()
      },  {
        %2 = "std.subi"(%arg1, %c1_i64) : (i64, i64) -> i64
        %3 = "lz.apEager"(%f, %2) : ((i64) -> !lz.value, i64) -> !lz.value
        "lz.return"(%3) : (!lz.value) -> ()
      }) {alt0 = 0 : i64, alt1 = @default} : (i64) -> !lz.value
      "lz.return"(%1) : (!lz.value) -> ()
    }) {alt0 = @SimpleInt, constructorName = @SimpleInt} : (!lz.value) -> !lz.value
    "std.return"(%0) : (!lz.value) -> ()
  }) {sym_name = "f", type = (!lz.value) -> !lz.value} : () -> ()
  "func"() ( {
    %c3_i64 = "std.constant"() {value = 3 : i64} : () -> i64
    %f = "std.constant"() {value = @f} : () -> ((!lz.value) -> !lz.value)
    %0 = "lz.construct"(%c3_i64) {dataconstructor = @SimpleInt} : (i64) -> !lz.value
    %1 = "lz.apEager"(%f, %0) : ((!lz.value) -> !lz.value, !lz.value) -> !lz.value
    "std.return"(%1) : (!lz.value) -> ()
  }) {sym_name = "main", type = () -> !lz.value} : () -> ()
  "func"() ( {
  ^bb0(%arg0: !lz.value):  // no predecessors
    %0 = "lz.construct"(%arg0) {dataconstructor = @SimpleInt} : (!lz.value) -> !lz.value
    %1 = "lz.case"(%0) ( {
    ^bb0(%arg1: i64):  // no predecessors
      %2 = "lz.caseint"(%arg1) ( {
        %c42_i64 = "std.constant"() {value = 42 : i64} : () -> i64
        %3 = "lz.construct"(%c42_i64) {dataconstructor = @SimpleInt} : (i64) -> !lz.value
        "lz.return"(%3) : (!lz.value) -> ()
      },  {
        %c1_i64 = "std.constant"() {value = 1 : i64} : () -> i64
        %3 = "std.subi"(%arg1, %c1_i64) : (i64, i64) -> i64
        %f = "std.constant"() {value = @f_outline_case_arg} : () -> ((i64) -> !lz.value)
        %4 = "lz.apEager"(%f, %3) : ((i64) -> !lz.value, i64) -> !lz.value
        "lz.return"(%4) : (!lz.value) -> ()
      }) {alt0 = 0 : i64, alt1 = @default} : (i64) -> !lz.value
      "lz.return"(%2) : (!lz.value) -> ()
    }) {alt0 = @SimpleInt, constructorName = @SimpleInt} : (!lz.value) -> !lz.value
    "std.return"(%1) : (!lz.value) -> ()
  }) {sym_name = "f_outline_case_arg", type = (i64) -> !lz.value} : () -> ()
  "module_terminator"() : () -> ()
}) : () -> ()

%a = ... 

%b = f(%a) {
    g(%a)
  }

main
  = GHC.IO.Handle.Text.hPutStr'
      GHC.IO.Handle.FD.stdout
      GHCMaybeIntNonTailRecursive.main1
      GHC.Types.True

GHCMaybeIntNonTailRecursive.main1
  = case GHCMaybeIntNonTailRecursive.main_$sf 100# of {
      JustHash b1_aLr ->
        ++
          @ Char
          GHCMaybeIntNonTailRecursive.$fShowMaybeHash6
          (case GHC.Show.$wshowSignedInt
                  0# b1_aLr GHCMaybeIntNonTailRecursive.$fShowMaybeHash8
           of
           { (# ww5_a1RD, ww6_a1RE #) ->
           GHC.Types.: @ Char ww5_a1RD ww6_a1RE
           });
      NothingHash -> GHCMaybeIntNonTailRecursive.$fShowMaybeHash3
    }

GHCMaybeIntNonTailRecursive.main_$sf [Occ=LoopBreaker]
  :: Int# -> MaybeHash
[GblId, Arity=1, Caf=NoCafRefs, Str=<S,1*U>, Unf=OtherCon []]
GHCMaybeIntNonTailRecursive.main_$sf
  = \ (sc_s1X4 :: Int#) ->
      case sc_s1X4 of ds_d1IV {
        __DEFAULT ->
          case GHCMaybeIntNonTailRecursive.main_$sf (-# ds_d1IV 1#) of {
            JustHash j#_aHM ->
              GHCMaybeIntNonTailRecursive.JustHash (+# j#_aHM 7#);
            NothingHash -> GHCMaybeIntNonTailRecursive.NothingHash
          };
        0# -> lvl_r1XW
      }

  func @factorial(%arg0: !lz.thunk<!lz.value>) -> !lz.value {
    %0 = "lz.caseint"(%arg1) ( {
      %c1_i64 = constant 1 : i64
      %2 = "lz.construct"(%c1_i64) {dataconstructor = @SimpleInt} : (i64) -> !lz.value
      return %2 : !lz.value
    },  {
      %c1_i64 = constant 1 : i64
      %2 = subi %arg1, %c1_i64 : i64
      %3 = "lz.ref"() {sym_name = "factorial"} : () -> !lz.fn<(i64) -> i64>
      %4 = "lz.ap"(%3, %2) : (!lz.fn<(i64) -> i64>, i64) -> !lz.thunk<i64>
      %5 = "lz.force"(%4) : (!lz.thunk<i64>) -> i64
      %6 = "lz.ref"() {sym_name = "mulSimpleInt"} : () -> !lz.fn<(i64, i64) -> i64>
      %7 = "lz.ap"(%6, %arg1, %5) : (!lz.fn<(i64, i64) -> i64>, i64, i64) -> !lz.thunk<i64>
      return %7 : !lz.thunk<i64>
    }) {alt0 = 0 : i64, alt1 = @default} : (i64) -> i64
    return %0 : i64
    %1 = "lz.caseint"(%arg0) ( {
    ^bb0(%arg1: i64):  // no predecessors
    }) {alt0 = @SimpleInt} : (!lz.thunk<!lz.value>) -> i64
    return %1 : i64
}

unable to find key: |<block argument>|

owning block:
^bb0(%arg1: i64):  // no predecessors

owning op:
%1 = "lz.caseint"(%arg0) ( {
^bb0(%arg1: i64):  // no predecessors
}) {alt0 = @SimpleInt} : (!lz.thunk<!lz.value>) -> i64

data X = X1 !Int | X2 !Char
foo :: X -> X;
foo x = case x of X1 i -> X1 (i * 2); X2 c = X2 (c + 'a')


(%x1, %x2) = lz.variant(%x)
%x1_plus_1 = add(%x1, 1)
%y1 = lz.construct(@X1, %x1_plus_1)

%x2_plus_a = add(%x1, 97) -- ord(a) = 97
%y2 = lz.construct(@X2, %x2_plus_a)
%out = lz.union(%y1, %y2)

module {

  hask.func @two () -> !hask.adt<@SimpleInt>  {
     %v = hask.make_i64(2)
     %boxed = hask.construct(@SimpleInt, %v:!hask.value) : !hask.adt<@SimpleInt> 
     hask.return(%boxed): !hask.adt<@SimpleInt> 
  }

  hask.func @main (%v: !hask.adt<@SimpleInt>, %wt: !hask.thunk<!hask.adt<@SimpleInt>>) -> !hask.adt<@SimpleInt> {
      %number = hask.make_i64(0 : i64)
      %reti = hask.case @SimpleInt %v 
           [@SimpleInt -> { ^entry(%ival: !hask.value):
              %w = hask.force(%wt):!hask.adt<@SimpleInt>
               %number43 = hask.make_i64(43 : i64)
               hask.return(%number43):!hask.value
            }]
            [@default -> { 
               ^entry:
                   %number42 = hask.make_i64(42 : i64)
                   hask.return(%number42):!hask.value

            }]
      %two = hask.ref(@two):  !hask.fn<() -> !hask.adt<@SimpleInt>>
      %twot = hask.ap(%two :  !hask.fn<() -> !hask.adt<@SimpleInt>> )
      hask.return(%reti) : !hask.value
  }
}

module {
  "hask.func"() ( {
    %0 = "hask.make_i64"() {value = 2 : i64} : () -> !hask.value
    %1 = "hask.construct"(%0) {dataconstructor = @SimpleInt} : (!hask.value) -> !hask.adt<@SimpleInt>
    "hask.return"(%1) : (!hask.adt<@SimpleInt>) -> ()
  }) {retty = !hask.adt<@SimpleInt>, sym_name = "two"} : () -> ()

  "hask.func"() ( {
  ^bb0(%arg0: !hask.adt<@SimpleInt>, %arg1: !hask.thunk<!hask.adt<@SimpleInt>>):  // no predecessors
    %0 = "hask.make_i64"() {value = 0 : i64} : () -> !hask.value
    %1 = "hask.case"(%arg0) ( {
    ^bb0(%arg2: !hask.value):  // no predecessors
      %4 = "hask.force"(%arg1) : (!hask.thunk<!hask.adt<@SimpleInt>>) -> !hask.adt<@SimpleInt>
      %5 = "hask.make_i64"() {value = 43 : i64} : () -> !hask.value
      "hask.return"(%5) : (!hask.value) -> ()
    },  {
      %4 = "hask.make_i64"() {value = 42 : i64} : () -> !hask.value
      "hask.return"(%4) : (!hask.value) -> ()
    }) {alt0 = @SimpleInt, alt1 = @default, constructorName = @SimpleInt} : (!hask.adt<@SimpleInt>) -> !hask.value
    %2 = "hask.ref"() {sym_name = "two"} : () -> !hask.fn<() -> !hask.adt<@SimpleInt>>
    %3 = "hask.ap"(%2) : (!hask.fn<() -> !hask.adt<@SimpleInt>>) -> !hask.thunk<!hask.adt<@SimpleInt>>
    "hask.return"(%1) : (!hask.value) -> ()
  }) {retty = !hask.adt<@SimpleInt>, sym_name = "main"} : () -> ()
}

%1 = hask.case @Maybe %0 [@Nothing ->  {
  %3 = hask.make_i64(0 : i64)
  hask.return(%3) : !hask.value
}]
 [@Just ->  {
^bb0(%arg1: !hask.value):  // no predecessors
  %3 = hask.make_i64(1 : i64)
  hask.return(%3) : !hask.value
}]

!hask.adt<@Maybe>

====
hask.func @f {
^bb0(%arg0: !hask.thunk<!hask.adt<@SimpleInt>>):  // no predecessors
  %0 = hask.force(%arg0):!hask.adt<@SimpleInt>
  %1 = hask.case @SimpleInt %0 [@SimpleInt ->  {
  ^bb0(%arg1: !hask.value):  // no predecessors
    %2 = hask.caseint %arg1 [0 : i64 ->  {
      %3 = hask.make_i64(5 : i64)
      %4 = hask.construct(@SimpleInt, %3 : !hask.value) : !hask.adt<@SimpleInt>
      hask.return(%4) : !hask.adt<@SimpleInt>
    }]
 [@default ->  {
      %3 = hask.make_i64(1 : i64)
      %4 = hask.primop_sub(%arg1,%3)
      %5 = hask.construct(@SimpleInt, %4 : !hask.value) : !hask.adt<@SimpleInt>
      %6 = hask.thunkify(%5 :!hask.adt<@SimpleInt>):!hask.thunk<!hask.adt<@SimpleInt>>
      %7 = hask.ref(@f) : !hask.fn<(!hask.thunk<!hask.adt<@SimpleInt>>) -> !hask.adt<@SimpleInt>>
      %8 = hask.apEager(%7 :!hask.fn<(!hask.thunk<!hask.adt<@SimpleInt>>) -> !hask.adt<@SimpleInt>>, %6)
      %9 = hask.ap(%7 :!hask.fn<(!hask.thunk<!hask.adt<@SimpleInt>>) -> !hask.adt<@SimpleInt>>, %6)
      %10 = hask.case @SimpleInt %8 [@SimpleInt ->  {
      ^bb0(%arg2: !hask.value):  // no predecessors
        %11 = hask.make_i64(1 : i64)
        %12 = hask.primop_add(%arg2,%11)
        %13 = hask.construct(@SimpleInt, %12 : !hask.value) : !hask.adt<@SimpleInt>
        hask.return(%13) : !hask.adt<@SimpleInt>
      }]

      hask.return(%10) : !hask.adt<@SimpleInt>
    }]

    hask.return(%2) : !hask.adt<@SimpleInt>
  }]

  hask.return(%1) : !hask.adt<@SimpleInt>
}

0x00005555565c4854 in mlir::Block::getParentOp() ()
(gdb) bt
#0  0x00005555565c4854 in mlir::Block::getParentOp() ()
#1  0x00005555565b5da6 in mlir::Operation::print(llvm::raw_ostream&, mlir::OpPrintingFlags) ()
#2  0x0000555556437dd7 in mlir::OpState::print (this=0x7fffffffd728, os=..., flags=...) at /usr/local/include/mlir/IR/OpDefinition.h:127
#3  0x0000555556437e34 in mlir::operator<< (os=..., op=...) at /usr/local/include/mlir/IR/OpDefinition.h:265
#4  0x0000555556454911 in mlir::standalone::OutlineUknownForcePattern::matchAndRewrite (this=0x555558f95bd0, force=..., rewriter=...)
    at /home/bollu/work/mlir/coremlir/lib/Hask/WorkerWrapperPass.cpp:127
#5  0x00005555564597ec in mlir::OpRewritePattern<mlir::standalone::ForceOp>::matchAndRewrite (this=0x555558f95bd0, op=0x555558f918a0, rewriter=...)
    at /usr/local/include/mlir/IR/PatternMatch.h:213
#6  0x000055555662c27b in mlir::PatternApplicator::matchAndRewrite(mlir::Operation*, mlir::RewritePattern const&, mlir::PatternRewriter&, llvm::function_ref<bool (mlir::RewritePattern const&)>, llvm::function_ref<void (mlir::RewritePattern const&)>, llvm::function_ref<mlir::LogicalResult (mlir::RewritePattern const&)>) ()
#7  0x000055555662c58f in mlir::PatternApplicator::matchAndRewrite(mlir::Operation*, mlir::PatternRewriter&, llvm::function_ref<bool (mlir::RewritePattern const&)>, llvm::function_ref<void (mlir::RewritePattern const&)>, llvm::function_ref<mlir::LogicalResult (mlir::RewritePattern const&)>) ()
#8  0x0000555556785f6c in mlir::applyPatternsAndFoldGreedily(llvm::MutableArrayRef<mlir::Region>, mlir::OwningRewritePatternList const&) ()
#9  0x000055555645532a in mlir::standalone::WorkerWrapperPass::runOnOperation (this=0x555558f189e0)
    at /home/bollu/work/mlir/coremlir/lib/Hask/WorkerWrapperPass.cpp:223
#10 0x000055555667f0a2 in mlir::Pass::run(mlir::Operation*, mlir::AnalysisManager) ()
#11 0x000055555667f182 in mlir::OpPassManager::run(mlir::Operation*, mlir::AnalysisManager) ()
#12 0x0000555556687a96 in mlir::PassManager::run(mlir::ModuleOp) ()
#13 0x0000555555881eae in main (argc=4, argv=0x7fffffffe4e8) at /home/bollu/work/mlir/coremlir/hask-opt/hask-opt.cpp:157
(gdb) Quit

hask-opt: /usr/local/include/llvm/Support/Casting.h:269: typename llvm::cast_retty<X, Y*>::ret_type llvm::cast(Y*) [with X = mlir::standalone::ApEagerOp; Y = mlir::Operation; typename llvm::cast_retty<X,
) argument of incompatible type!"' failed.

Program received signal SIGABRT, Aborted.
__GI_raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:51
51	../sysdeps/unix/sysv/linux/raise.c: No such file or directory.
(gdb) bt
#0  __GI_raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:51
#1  0x00007ffff661a8b1 in __GI_abort () at abort.c:79
#2  0x00007ffff660a42a in __assert_fail_base (fmt=0x7ffff6791a38 "%s%s%s:%u: %s%sAssertion `%s' failed.\n%n", assertion=assertion@entry=0x555557fd6198 "isa<X>(Val) && \"cast<Ty>() argument of incompatible
    file=file@entry=0x555557fd6168 "/usr/local/include/llvm/Support/Casting.h", line=line@entry=269,
    function=function@entry=0x555557fd85e0 <llvm::cast_retty<mlir::standalone::ApEagerOp, mlir::Operation*>::ret_type llvm::cast<mlir::standalone::ApEagerOp, mlir::Operation>(mlir::Operation*)::__PRETTY_F
ir::standalone::ApEagerOp; Y = mlir::Operation; typename llvm::cast_retty<X, Y*>::ret_type = mlir::standalone::ApEagerOp]") at assert.c:92
#3  0x00007ffff660a4a2 in __GI___assert_fail (assertion=0x555557fd6198 "isa<X>(Val) && \"cast<Ty>() argument of incompatible type!\"", file=0x555557fd6168 "/usr/local/include/llvm/Support/Casting.h", line
    function=0x555557fd85e0 <llvm::cast_retty<mlir::standalone::ApEagerOp, mlir::Operation*>::ret_type llvm::cast<mlir::standalone::ApEagerOp, mlir::Operation>(mlir::Operation*)::__PRETTY_FUNCTION__> "typ
:ApEagerOp; Y = mlir::Operation; typename llvm::cast_retty<X, Y*>::ret_type = mlir::standalone::ApEagerOp]") at assert.c:101
#4  0x0000555556418afd in llvm::cast<mlir::standalone::ApEagerOp, mlir::Operation> (Val=0x555558f1adf0) at /usr/local/include/llvm/Support/Casting.h:269
#5  0x0000555556459e0d in mlir::OpRewritePattern<mlir::standalone::ApEagerOp>::matchAndRewrite (this=0x555558f98a50, op=0x555558f1adf0, rewriter=...) at /usr/local/include/mlir/IR/PatternMatch.h:213
#6  0x000055555662ca4b in mlir::PatternApplicator::matchAndRewrite(mlir::Operation*, mlir::RewritePattern const&, mlir::PatternRewriter&, llvm::function_ref<bool (mlir::RewritePattern const&)>, llvm::func
lt (mlir::RewritePattern const&)>) ()
#7  0x000055555662cd5f in mlir::PatternApplicator::matchAndRewrite(mlir::Operation*, mlir::PatternRewriter&, llvm::function_ref<bool (mlir::RewritePattern const&)>, llvm::function_ref<void (mlir::RewriteP
t&)>) ()
#8  0x000055555678673c in mlir::applyPatternsAndFoldGreedily(llvm::MutableArrayRef<mlir::Region>, mlir::OwningRewritePatternList const&) ()
#9  0x00005555564558aa in mlir::standalone::WorkerWrapperPass::runOnOperation (this=0x555558f189e0) at /home/bollu/work/mlir/coremlir/lib/Hask/WorkerWrapperPass.cpp:316
#10 0x000055555667f872 in mlir::Pass::run(mlir::Operation*, mlir::AnalysisManager) ()
#11 0x000055555667f952 in mlir::OpPassManager::run(mlir::Operation*, mlir::AnalysisManager) ()
#12 0x0000555556688266 in mlir::PassManager::run(mlir::ModuleOp) ()
#13 0x0000555555881eae in main (argc=4, argv=0x7fffffffe4e8) at /home/bollu/work/mlir/coremlir/hask-opt/hask-opt.cpp:157

LogicalResult matchAndRewrite(Operation *op,
                              PatternRewriter &rewriter) const final {
  return matchAndRewrite(cast<SourceOp>(op), rewriter);
}

f 0 slot = 0
f n slot = f (n - 1) (slot + n*n)

let j1 () = BIG1; j2 () = BIG2
in case xs of
    [] -> case T of T -> j1 (); F -> j2 ()
    _ -> case F of T -> j1 (); F -> j2 ()

let j1 () = BIG11; j2 x = BIG2 x
in case (case xs of [] -> Nothing; (p:ps) -> Just p) of
     Nothing -> j1; Just x -> j2 x

%0 = hask.lambda(%arg0:!hask.value) {
  %1 = hask.transmute(%arg0 :!hask.value):i64
  %2 = hask.caseint %1 [0 : i64 ->  {
  ^bb0(%arg1: i64):  // no predecessors
    %3 = hask.transmute(%1 :i64):!hask.value
    hask.return(%3) : !hask.value
  }]
  ...
running TransmuteOpConversionPattern on: hask.transmute | loc("./case-int-roundtrip.mlir":7:12)
transmute:%0 = hask.transmute(<<UNKNOWN SSA VALUE>> :!hask.value):i64
in: <block argument>
inRemapped: <block argument>
inType:!hask.value

newBB: <<UNLINKED BLOCK>>

case-int.mlir:10:14: error: failed to materialize conversion for result #0 of operation 'hask.transmute' that remained live after conversion
     %ival = hask.transmute(%ihash : !hask.value): i64
             ^
case-int.mlir:10:14: note: see current operation: %1 = "hask.transmute"(<<UNKNOWN SSA VALUE>>) : (!hask.value) -> i64
case-int.mlir:10:14: note: see existing live user here: %6 = llvm.inttoptr %1 : i64 to !llvm.ptr<i8>

---materialization %0 = hask.make_i64(42 : i64) ->  pointer
running TransmuteOpConversionPattern on: hask.transmute | loc("playground.mlir":9:17)
transmute:%2 = hask.transmute(%0 :!hask.value):i64
in: %0 = hask.make_i64(42 : i64)
inRemapped: %0 = hask.make_i64(42 : i64)
inType:!hask.value
convert(inType):!llvm.ptr<i8>
retty:i64
rettyRemapped:!llvm.i64
---materialization %0 = hask.make_i64(42 : i64) ->  int
ret: %2 = llvm.ptrtoint %0 : !hask.value to !llvm.i64
===mod:==
llvm.func @main() -> !llvm.ptr<i8> {
  %0 = hask.make_i64(42 : i64)
  %1 = llvm.inttoptr %0 : !hask.value to !llvm.ptr<i8>
  %2 = llvm.ptrtoint %0 : !hask.value to !llvm.i64
  %3 = hask.transmute(%0 :!hask.value):i64
  hask.return(%3) : i64
}
playground.mlir:9:17: error: failed to materialize conversion for result #0 of operation 'hask.transmute' that remained live after conversion
        %ival = hask.transmute(%lit_42 : !hask.value): i64
                ^
playground.mlir:9:17: note: see current operation: %3 = "hask.transmute"(%0) : (!hask.value) -> i64
playground.mlir:10:9: note: see existing live user here: hask.return(%3) : i64
        hask.return(%ival) : i64

#0  __GI_raise (sig=sig@entry=6) at ../sysdeps/unix/sysv/linux/raise.c:51
#1  0x00007ffff661a8b1 in __GI_abort () at abort.c:79
#2  0x00007ffff660a42a in __assert_fail_base (fmt=0x7ffff6791a38 "%s%s%s:%u: %s%sAssertion `%s' failed.\n%n", assertion=assertion@entry=0x555557e44738 "false && \"want to see backtrace\"",
    file=file@entry=0x555557e44048 "/home/bollu/work/mlir/coremlir/lib/Hask/HaskOps.cpp", line=line@entry=1182,
    function=function@entry=0x555557e4d200 <mlir::standalone::HaskToLLVMTypeConverter::HaskToLLVMTypeConverter(mlir::MLIRContext*)::{lambda(mlir::OpBuilder&, mlir::LLVM::LLVMPointerType, mlir::ValueRange, mlir::Location)#5}::operator()(mlir::OpBuilder&, mlir::LLVM::LLVMPointerType, mlir::ValueRange, mlir::Location) const::__PRETTY_FUNCTION__> "mlir::standalone::HaskToLLVMTypeConverter::HaskToLLVMTypeConverter(mlir::MLIRContext*)::<lambda(mlir::OpBuilder&, mlir::LLVM::LLVMPointerType, mlir::ValueRange, mlir::Location)>") at assert.c:92
#3  0x00007ffff660a4a2 in __GI___assert_fail (assertion=0x555557e44738 "false && \"want to see backtrace\"", file=0x555557e44048 "/home/bollu/work/mlir/coremlir/lib/Hask/HaskOps.cpp",
    line=1182,
    function=0x555557e4d200 <mlir::standalone::HaskToLLVMTypeConverter::HaskToLLVMTypeConverter(mlir::MLIRContext*)::{lambda(mlir::OpBuilder&, mlir::LLVM::LLVMPointerType, mlir::ValueRange,
mlir::Location)#5}::operator()(mlir::OpBuilder&, mlir::LLVM::LLVMPointerType, mlir::ValueRange, mlir::Location) const::__PRETTY_FUNCTION__> "mlir::standalone::HaskToLLVMTypeConverter::HaskToLLVMTypeConverter(mlir::MLIRContext*)::<lambda(mlir::OpBuilder&, mlir::LLVM::LLVMPointerType, mlir::ValueRange, mlir::Location)>") at assert.c:101
#4  0x0000555556398f10 in mlir::standalone::HaskToLLVMTypeConverter::HaskToLLVMTypeConverter(mlir::MLIRContext*)::{lambda(mlir::OpBuilder&, mlir::LLVM::LLVMPointerType, mlir::ValueRange, mlir::Location)#5}::operator()(mlir::OpBuilder&, mlir::LLVM::LLVMPointerType, mlir::ValueRange, mlir::Location) const (__closure=0x7fffffffd440, builder=..., ptrty=..., vals=..., loc=...)
    at /home/bollu/work/mlir/coremlir/lib/Hask/HaskOps.cpp:1182
#5  0x00005555563a5948 in std::function<llvm::Optional<mlir::Value> (mlir::OpBuilder&, mlir::Type, mlir::ValueRange, mlir::Location)> mlir::TypeConverter::wrapMaterialization<mlir::LLVM::LLVMPointerType, mlir::standalone::HaskToLLVMTypeConverter::HaskToLLVMTypeConverter(mlir::MLIRContext*)::{lambda(mlir::OpBuilder&, mlir::LLVM::LLVMPointerType, mlir::ValueRange, mlir::Location)#5}>(mlir::standalone::HaskToLLVMTypeConverter::HaskToLLVMTypeConverter(mlir::MLIRContext*)::{lambda(mlir::OpBuilder&, mlir::LLVM::LLVMPointerType, mlir::ValueRange, mlir::Location)#5}&&)::{lambda(mlir::OpBuilder&, llvm::Optional<mlir::Value>, mlir::ValueRange, mlir::Location)#1}::operator()(mlir::OpBuilder&, llvm::Optional<mlir::Value>, mlir::ValueRange, mlir::Location) const
    (__closure=0x7fffffffd440, builder=..., resultType=..., inputs=..., loc=...) at /usr/local/include/mlir/Transforms/DialectConversion.h:288
#6  0x00005555563adfa5 in std::_Function_handler<llvm::Optional<mlir::Value> (mlir::OpBuilder&, mlir::Type, mlir::ValueRange, mlir::Location), std::function<llvm::Optional<mlir::Value> (mlir::OpBuilder&, mlir::Type, mlir::ValueRange, mlir::Location)> mlir::TypeConverter::wrapMaterialization<mlir::LLVM::LLVMPointerType, mlir::standalone::HaskToLLVMTypeConverter::HaskToLLVMTypeConverter(mlir::MLIRContext*)::{lambda(mlir::OpBuilder&, mlir::LLVM::LLVMPointerType, mlir::ValueRange, mlir::Location)#5}>(mlir::standalone::HaskToLLVMTypeConverter::HaskToLLVMTypeConverter(mlir::MLIRContext*)::{lambda(mlir::OpBuilder&, mlir::LLVM::LLVMPointerType, mlir::ValueRange, mlir::Location)#5}&&)::{lambda(mlir::OpBuilder&, mlir::Type, mlir::ValueRange, mlir::Location)#1}>::_M_invoke(std::_Any_data const&, mlir::OpBuilder&, mlir::Type&&, mlir::ValueRange&&, mlir::Location&&) (__functor=..., __args#0=..., __args#1=..., __args#2=..., __args#3=...)
    at /usr/include/c++/7/bits/std_function.h:302
#7  0x0000555556617c0b in mlir::TypeConverter::materializeConversion(llvm::MutableArrayRef<std::function<llvm::Optional<mlir::Value> (mlir::OpBuilder&, mlir::Type, mlir::ValueRange, mlir::Location)> >, mlir::OpBuilder&, mlir::Location, mlir::Type, mlir::ValueRange) ()
#8  0x000055555661e482 in mlir::detail::ConversionPatternRewriterImpl::remapValues(mlir::Location, mlir::PatternRewriter&, mlir::TypeConverter*, mlir::OperandRange, llvm::SmallVectorImpl<mlir::Value>&) ()
#9  0x000055555661e712 in mlir::ConversionPattern::matchAndRewrite(mlir::Operation*, mlir::PatternRewriter&) const ()
#10 0x000055555658668b in mlir::PatternApplicator::matchAndRewrite(mlir::Operation*, mlir::RewritePattern const&, mlir::PatternRewriter&, llvm::function_ref<bool (mlir::RewritePattern const&)>, llvm::function_ref<void (mlir::RewritePattern const&)>, llvm::function_ref<mlir::LogicalResult (mlir::RewritePattern const&)>) ()
#11 0x000055555658699f in mlir::PatternApplicator::matchAndRewrite(mlir::Operation*, mlir::PatternRewriter&, llvm::function_ref<bool (mlir::RewritePattern const&)>, llvm::function_ref<void (mlir::RewritePattern const&)>, llvm::function_ref<mlir::LogicalResult (mlir::RewritePattern const&)>) ()
#12 0x0000555556624e54 in (anonymous namespace)::OperationLegalizer::legalize(mlir::Operation*, mlir::ConversionPatternRewriter&) ()
#13 0x0000555556627c3e in (anonymous namespace)::OperationConverter::convertOperations(llvm::ArrayRef<mlir::Operation*>) ()
#14 0x000055555662a074 in mlir::applyPartialConversion(llvm::ArrayRef<mlir::Operation*>, mlir::ConversionTarget&, mlir::OwningRewritePatternList const&, llvm::DenseSet<mlir::Operation*, llvm::DenseMapInfo<mlir::Operation*> >*) ()
#15 0x000055555662a1a1 in mlir::applyPartialConversion(mlir::Operation*, mlir::ConversionTarget&, mlir::OwningRewritePatternList const&, llvm::DenseSet<mlir::Operation*, llvm::DenseMapInfo<mlir::Operation*> >*) ()
#16 0x000055555639409c in mlir::standalone::(anonymous namespace)::LowerHaskToStandardPass::runOnOperation (this=0x555559096370) at /home/bollu/work/mlir/coremlir/lib/Hask/HaskOps.cpp:2251
#17 0x00005555565d9472 in mlir::Pass::run(mlir::Operation*, mlir::AnalysisManager) ()
#18 0x00005555565d9552 in mlir::OpPassManager::run(mlir::Operation*, mlir::AnalysisManager) ()
#19 0x00005555565e1e66 in mlir::PassManager::run(mlir::ModuleOp) ()
#20 0x00005555557ef47e in main (argc=4, argv=0x7fffffffdd18) at /home/bollu/work/mlir/coremlir/hask-opt/hask-opt.cpp:408

  hask.func @plus {
    %lam = hask.lambdaSSA(%i : !hask.thunk, %j: !hask.thunk) {
      %icons = hask.force(%i: !hask.thunk): !hask.value
      %reti = hask.caseSSA %icons 
           [@MkSimpleInt -> { ^entry(%ival: !hask.value):
              %jcons = hask.force(%j: !hask.thunk):!hask.value
              %retj = hask.caseSSA %jcons 
                  [@MkSimpleInt -> { ^entry(%jval: !hask.value):
                        %sum_v = hask.primop_add(%ival, %jval)
                        %boxed = hask.construct(@MkSimpleInt, %sum_v)
                        // do we return the box?
                        hask.return(%boxed) :!hask.thunk
                        // or do we return a closure that holds the box?
                        // this matters to callees. In one case, they can
                        // `case` case on the box. In the other case, they need
                        // to `force`, and then `case`.
                        hask.suspend(%boxed) :!hask.thunk

                  }]
              hask.return(%retj):!hask.thunk
           }]
      hask.return(%reti): !hask.thunk
    }
    hask.return(%lam): !hask.fn<!hask.thunk, !hask.fn<!hask.thunk, !hask.thunk>>
  }

module {
  // k x y = x
  hask.func @k {
    %lambda = hask.lambdaSSA(%x: !hask.thunk, %y: !hask.thunk) {
      hask.return(%x) : !hask.thunk
    }
    hask.return(%lambda) :!hask.fn<!hask.thunk, !hask.fn<!hask.thunk, !hask.thunk>>
  }

  // loop a = loop a
  hask.func @loop {
    %lambda = hask.lambdaSSA(%a: !hask.thunk) {
      %loop = hask.ref(@loop) : !hask.fn<!hask.thunk, !hask.thunk>
      %out_t = hask.apSSA(%loop : !hask.fn<!hask.thunk, !hask.thunk>, %a)
      // HACK! This will emit an `evalClosure` though it is nowhere 
      // reachable from hask.return (%out_t).
      // We need to rework the type system...
      %out_v = hask.force(%out_t)
      hask.return(%out_t) : !hask.thunk
    }
    hask.return(%lambda) : !hask.fn<!hask.thunk, !hask.thunk>
  }

  hask.adt @X [#hask.data_constructor<@MkX []>]

  // k (x:X) (y:(loop X)) = x
  // main = 
  //     let y = loop x -- builds a closure.
  //     in k x y
  hask.func @main {
    %lambda = hask.lambdaSSA(%_: !hask.thunk) {
      %x = hask.construct(@X)
      %k = hask.ref(@k) : !hask.fn<!hask.thunk, !hask.fn<!hask.thunk, !hask.thunk>>
      %loop = hask.ref(@loop) :  !hask.fn<!hask.thunk, !hask.thunk>
      %y = hask.apSSA(%loop : !hask.fn<!hask.thunk, !hask.thunk>, %x)
      %out_t = hask.apSSA(%k: !hask.fn<!hask.thunk, !hask.fn<!hask.thunk, !hask.thunk>>, %x, %y)
      %out = hask.force(%out_t)
      hask.return(%out) : !hask.value
    }
    hask.return(%lambda) :!hask.fn<!hask.thunk, !hask.value>
  }
}

declare i8* @malloc(i64)
declare void @free(i8*)
declare i8* @mkClosure_capture0_args2(i8*, i8*, i8*)
declare i8* @malloc__(i32)
declare i8* @evalClosure(i8*)
declare i8* @mkClosure_capture0_args1(i8*, i8*)

define i64 @k(i64 %0, i64 %1) !dbg !3 {
  ret i64 %0, !dbg !7
}

define i64 @loop(i64 %0) !dbg !9 {
  %2 = inttoptr i64 %0 to i8*, !dbg !10
  %3 = call i8* @mkClosure_capture0_args1(i8* bitcast (i64 (i64)* @loop to i8*), i8* %2), !dbg !10
  %4 = call i8* @evalClosure(i8* %3), !dbg !12
  ret i8* %3, !dbg !13
}

define i64 @main(i64 %0) !dbg !14 {
  %2 = call i8* @malloc__(i32 4200), !dbg !15
  %3 = ptrtoint i8* %2 to i64, !dbg !15
  %4 = inttoptr i64 %3 to i8*, !dbg !17
  %5 = call i8* @mkClosure_capture0_args1(i8* bitcast (i64 (i64)* @loop to i8*), i8* %4), !dbg !17
  %6 = inttoptr i64 %3 to i8*, !dbg !18
  %7 = call i8* @mkClosure_capture0_args2(i8* bitcast (i64 (i64, i64)* @k to i8*), i8* %6, i8* %5), !dbg !18
  %8 = call i8* @evalClosure(i8* %7), !dbg !19
  ret i8* %8, !dbg !20
}

  // loop a = loop a
  hask.func @loop {
    %lambda = hask.lambdaSSA(%a: !hask.thunk) {
      %loop = hask.ref(@loop) : !hask.fn<!hask.thunk, !hask.thunk>
      %out_t = hask.apSSA(%loop : !hask.fn<!hask.thunk, !hask.thunk>, %a)
      // HACK! This will emit an `evalClosure` though it is nowhere 
      // reachable from hask.return (%out_t).
      // We need to rework the type system...
      %out_v = hask.force(%out_t)
      hask.return(%out_t) : !hask.thunk
    }
    hask.return(%lambda) : !hask.fn<!hask.thunk, !hask.thunk>
  }

f :: Int -> Int -> Int
f = plus x y

fn @f = lambda (%x) {
  return lambda (%y) {
    %plus_ref = ref(@plus)
    %x_plus = ap(%plus_ref, %x)
    %x_plus_y = ap(%x_plus, %y)
    return %x_plus_y

  }
}

global @g {
  %f = ref(@f)
  %one = ref(@one)
  %two = ref(@two)
  %fx = ap(%f, %one)
  %fxy = ap(fx, %two)
  %fxy_val = force(%fxy) //value is forced here
  case %fxy_val {
    ...
  }
}

f: 
  x = pop(); y = pop();
  push(y); push(x); enter(plus)

g: 
  push(two); push(one);
  enter(f);
  // assumes control flow returns here: this is another "?". Compiling naively
  // like this may not work, because stack space is too small is the STG wisdom.
  fxy_val = pop();
  case(fxy_val, ... )

fn @f = lambda (%x) {
  return lambda (%y) {
    %plus_ref = ref(@plus)
    %x_plus = ap(%plus_ref, %x)
    %x_plus_y = ap(%x_plus, %y)
    return %x_plus_y

  }
}


fn @h = lambda (%x) {
  %f = ref(@f)
  %fortytwo = ref(@fortytwo)
  %fx = ap(%f, %x)
  %fx42 = ap(%x, %x, %fortytwo) // this is a value, not a thunk (?)
  return %fx42
}

global @g2 {
  %h = ref(@h)
  %one = ref(@one)
  %hone = ap(%h, %one)
  %honeval = force(%hone) //value is forced here
  case %honeval {
    ...
  }
}

f: 
  x = pop(); y = pop();
  push(y); push(x); enter(plus)

h:
  x = pop()
  push(fortytwo)
  push(x)
  enter(f)

g2:
  push(one)
  enter(h)
  honeval = pop()
  case(honeval, ... )

fn @fstrict = lambda (%x) {
  return lambda (%y) {
    %plus#_ref = ref(@plus#)
    %x_plus# = ap(%plus#_ref, %x)
    %x_plus#_y = ap(%x_plus#, %y) <- VALUE COMPUTED HERE
    return %x_plus_y

  }
}

%x_plus#_y = ap(%x_plus#, %y) <- VALUE COMPUTED HERE

f:
  x = pop(); y = pop();
  z = x + y;
  push(z) 

fn @h = lambda (%x) {
  %plus# = ref(@plus#)
  %fortytwo = ref(@fortytwo)
  %fx = ap(%plus#, %x)
  %fx42 = ap(%x, %x, %fortytwo) // this is a value, not a thunk (?)
  return %fx42
}

global @g2 {
  %h = ref(@h)
  %one = ref(@one)
  %hone = ap(%h, %one) // <- should the value be computed here? automatically?
  %honeval = force(%hone) // <- or should the value be computed here?
  case %honeval {
    ...
  }

%hone = ap(%h, %one)

%honeval = force(%hone) // <- or should the value be computed here?

hask.func @minus {
%lami = hask.lambdaSSA(%i: !hask.thunk) {
     %lamj = hask.lambdaSSA(%j :!hask.thunk) {
          %icons = hask.force(%i)
          %reti = hask.caseSSA %icons 
               [@SimpleInt -> { ^entry(%ival: !hask.value):
                  %jcons = hask.force(%j)
                  %retj = hask.caseSSA %jcons 
                      [@SimpleInt -> { ^entry(%jval: !hask.value):
                            %minus_hash = hask.ref (@"-#") : !hask.fn<!hask.value, !hask.fn<!hask.value, !hask.thunk>>
                            %i_sub = hask.apSSA(%minus_hash : !hask.fn<!hask.value, !hask.fn<!hask.value, !hask.thunk>>, %ival)
                            %i_sub_j_thunk = hask.apSSA(%i_sub : !hask.fn<!hask.value, !hask.thunk>, %jval)
                            %i_sub_j = hask.force(%i_sub_j_thunk)
                            %mk_simple_int = hask.ref (@MkSimpleInt) :!hask.fn<!hask.value, !hask.thunk>
                            %boxed = hask.apSSA(%mk_simple_int:!hask.fn<!hask.value, !hask.thunk>, %i_sub_j)
                            hask.return(%boxed) :!hask.thunk
                      }]
                  hask.return(%retj) :!hask.thunk
               }]
          hask.return(%reti):!hask.thunk
      }
      hask.return(%lamj): !hask.fn<!hask.thunk, !hask.thunk>
}
hask.return(%lami): !hask.fn<!hask.thunk, !hask.fn<!hask.thunk, !hask.thunk>>
}

data X = MkX Int
f :: Int -> X; f = MkX 
o :: Int; o = 1
x :: X; x = f o

 %cons = hask.ref(@Constructor)
 %result = hask.apSSA(%cons, %v1, ..., %vn)

 %result = hask.construct(@Constructor, %v1, ..., %vn)

%mk_simple_int = hask.ref (@MkSimpleInt)
// what do now?
%boxed = hask.apSSA(%mk_simple_int, %i_sub_j)
hask.return(%boxed) :!hask.thunk

hask.force: (box: hask.thunk) -> hask.value
hask.case<T>: (scrutinee: hask.value) -> T. All the pattern matches have to return the same value.
hask.ap: (fn: hask.func<A, B>) * (param: A) -> B
hask.return: (retval: T) -> void
hask.lambda: (param: A) * (region with return: B) -> hask.func<A, B>
hask.ref<T>: (refname: Symbol) -> T

* a8c43a4 76 seconds ago Siddharth Bhat (HEAD -> master, origin/master) get first cut of type system working
|
|  8 files changed, 201 insertions(+), 125 deletions(-)
* 490c3af 3 hours ago Siddharth Bhat get hask.func to round-trip
|
|  4 files changed, 20 insertions(+), 14 deletions(-)
* ce64e16 4 hours ago Siddharth Bhat get angle bracket based fn type parsing working
|
|  2 files changed, 13 insertions(+), 1 deletion(-)
* 1ce1810 4 hours ago Siddharth Bhat add a HaskFunctionType that's not hooked in anywhere
|
|  2 files changed, 39 insertions(+), 1 deletion(-)
* ad0d367 5 hours ago Siddharth Bhat add appel paper on SSA v/s functional code
|
|  1 file changed, 6515 insertions(+)
* 50a656a 5 hours ago Siddharth Bhat Spring cleaning: rename ops from XSSAOp -> XOp
|
|  3 files changed, 44 insertions(+), 44 deletions(-)
* d4dda1a 6 hours ago Siddharth Bhat need function types. Scott be blessed.
|
|  9 files changed, 213 insertions(+), 216 deletions(-)
* 53bc03c 8 hours ago Siddharth Bhat started migrating to new normalization
|
|  8 files changed, 328 insertions(+), 83 deletions(-)

//unique:rza
//name: ConcreteProd
//|data constructors|
  dcName: MkConcreteProd
  dcOrigTyCon: ConcreteProd
  dcFieldLabels: []
  dcRepType: Int# -> Int# -> ConcreteProd
  constructor types: [Int#, Int#]
  result type: ConcreteProd
  ---
  dcSig: ([], [], [Int#, Int#], ConcreteProd)
  dcFullSig: ([], [], [], [], [Int#, Int#], ConcreteProd)
  dcUniverseTyVars: []
  dcArgs: [Int#, Int#]
  dcOrigArgTys: [Int#, Int#]
  dcOrigResTy: ConcreteProd
  dcRepArgTys: [Int#, Int#]

//unique:rz7
//name: ConcreteSum
//|data constructors|
  dcName: ConcreteLeft
  dcOrigTyCon: ConcreteSum
  dcFieldLabels: []
  dcRepType: Int# -> ConcreteSum
  constructor types: [Int#]
  result type: ConcreteSum
  ...

  dcName: ConcreteRight
  dcOrigTyCon: ConcreteSum
  dcFieldLabels: []
  dcRepType: Int# -> ConcreteSum
  constructor types: [Int#]
  result type: ConcreteSum
  ...
//----

//unique:rz2
//name: ConcreteRecSum
//|data constructors|
  dcName: ConcreteRecSumCons
  dcOrigTyCon: ConcreteRecSum
  dcFieldLabels: []
  dcRepType: Int# -> ConcreteRecSum -> ConcreteRecSum
  constructor types: [Int#, ConcreteRecSum]
  result type: ConcreteRecSum
  ...

data ConcreteSum = ConcreteLeft Int# | ConcreteRight Int#
hask.make_algebraic_data_type @ConcreteSum  -- name of the ADT
  [@ConcreteLeft"[@"Int#"], # constructor1: Int# -> ConcreteSum
   @ConcreteRight[@"Int#"]] # constructor2: Int# -> ConcreteSum

# data ConcreteProd = MkConcreteProd Int# Int#
hask.make_algebraic_data_type @ConcreteProd 
 [@MkConcreteProd [@"Int#", @"Int#"]] 

# data ConcreteRec = MkConcreteRec Int# ConcreteRec
hask.make_algebraic_data_type @ConcreteRec 
 [@MkConcreteRec [@"Int#", @ConcreteRec]] 

array-attribute ::= `[` (attribute-value (`,` attribute-value)*)? `]`

playground.mlir
module {
  hask.adt @SimpleInt [#hask.data_constructor<@MkSimpleInt, [@"Int#"]>]
}

Error can't load file ./playground.mlir

/usr/local/include/mlir/IR/OpDefinition.h: In instantiation of ‘static bool mlir::Op<ConcreteType, Traits>::hasTrait(mlir::TypeID) [with ConcreteType = mlir::standalone::HaskADTOp; Traits = {}]’:
/usr/local/include/mlir/IR/OperationSupport.h:156:12:   required from ‘static mlir::AbstractOperation mlir::AbstractOperation::get(mlir::Dialect&) [with T = mlir::standalone::HaskADTOp]’
/usr/local/include/mlir/IR/Dialect.h:154:54:   required from ‘void mlir::Dialect::addOperations() [with Args = {mlir::standalone::HaskADTOp}]’
/home/bollu/mlir/coremlir/lib/Hask/HaskDialect.cpp:40:28:   required from here
/usr/local/include/mlir/IR/OpDefinition.h:1357:49: error: no matching function for call to ‘makeArrayRef(<brace-enclosed initializer list>)’
     return llvm::is_contained(llvm::makeArrayRef({TypeID::get<Traits>()...}),

c7370bf 25 minutes ago Siddharth Bhat (HEAD -> master, origin/master) add legalizer data

 1 file changed, 18 insertions(+)
4abfd7a 38 minutes ago Siddharth Bhat It appears my attribute is created correctly. We print:

 2 files changed, 3 insertions(+), 2 deletions(-)
3261975 71 minutes ago Siddharth Bhat [WIP] getting there... can now store the data

 1 file changed, 8 insertions(+), 4 deletions(-)
f803c15 2 hours ago Siddharth Bhat [WIP] Playing with template errors, trying to figure out how to store attributes

 4 files changed, 119 insertions(+), 6 deletions(-)
cc6145a 2 hours ago Siddharth Bhat FUCK ME, I forgot to return x(

 1 file changed, 1 insertion(+), 1 deletion(-)
91d4b4e 3 hours ago Siddharth Bhat FFS, do NOT define classof() unless you know what you're doing

 2 files changed, 36 insertions(+), 6 deletions(-)
ff05162 3 hours ago Siddharth Bhat [WIP] I am literally unable to add an attribute...

 3 files changed, 9 insertions(+), 4 deletions(-)
dc4fec5 4 hours ago Siddharth Bhat [WIP] attr parsing

 6 files changed, 39 insertions(+), 17 deletions(-)
df17693 4 hours ago Siddharth Bhat add current status of getting attributes up

 12 files changed, 235 insertions(+), 272 deletions(-)
6ba2990 4 hours ago Siddharth Bhat add README documenting that we do in fact have attribute lists.

 1 file changed, 40 insertions(+)
4e16ba8 4 hours ago Siddharth Bhat [SIDEQUEST] Fuck this, let's just reboot hask98 from scratch on the weekend

 4 files changed, 14 insertions(+)
266201e 10 hours ago Siddharth Bhat add the exploration of data constructors here

 10 files changed, 2012 insertions(+), 551 deletions(-)

/tmp/ghc1433_0/ghc_2.s:194:0: error:
     Error: symbol `Main_MkSimpleInt_info' is already defined
    |
194 | Main_MkSimpleInt_info:
    | ^

/tmp/ghc1433_0/ghc_2.s:214:0: error:
     Error: symbol `Main_MkSimpleInt_closure' is already defined
    |
214 | Main_MkSimpleInt_closure:
    | ^

tomlir-fib.pass-0000.mlir:82:39: error: expected SSA operand
        %app_24 = hask.apSSA(%app_23, @one)

DEF-MUTUAL-RECURSIVE
   BLOCKING----------->
     | USE-MUTUAL-RECURSIVE
     |
     v

BLOCKING----------->
|DEF-MUTUAL-RECURSIVE
|   USE-MUTUAL-RECURSIVE
|    
v    

rec { -- BLOCKING
  fib :: Int -> Int
  
  {- Core Size{terms=23 types=6 cos=0 vbinds=0 jbinds=0} -}
  fib = -- DEF-MUTUAL-RECURSIVE
    λ i →
       ...
      (APP(Main.fib i)) -- USE-MUTUAL-RECURSIVE
      ...
}

%app_100  =  hask.apSSA(%-#, %i_s1wH)

tomlir-fibstrict.pass-0000.mlir:12:56: error: use of undeclared SSA value name
                                 %app_0  =  hask.apSSA(%var_minus_hash_99, %var_i_a12E)
                                                       ^
tomlir-fibstrict.pass-0000.mlir:12:76: error: use of undeclared SSA value name
                                 %app_0  =  hask.apSSA(%var_minus_hash_99, %var_i_a12E)
                                                                           ^
tomlir-fibstrict.pass-0000.mlir:25:72: error: use of undeclared SSA value name
                                                 %app_5  =  hask.apSSA(%var_plus_hash_98, %var_wild_X5)
                                                                       ^
tomlir-fibstrict.pass-0000.mlir:49:29: error: use of undeclared SSA value name
      %app_1  =  hask.apSSA(%var_TrNameS_ra, %lit_0)
                            ^
tomlir-fibstrict.pass-0000.mlir:50:29: error: use of undeclared SSA value name
      %app_2  =  hask.apSSA(%var_Module_r7, %app_1)
                            ^
tomlir-fibstrict.pass-0000.mlir:59:29: error: use of undeclared SSA value name
      %app_1  =  hask.apSSA(%var_fib_rwj, %lit_0)
                            ^
tomlir-fibstrict.pass-0000.mlir:65:37: error: use of undeclared SSA value name
              %app_3  =  hask.apSSA(%var_return_02O, %type_2)
                                    ^
tomlir-fibstrict.pass-0000.mlir:66:45: error: use of undeclared SSA value name
              %app_4  =  hask.apSSA(%app_3, %var_$fMonadIO_rob)
                                            ^
tomlir-fibstrict.pass-0000.mlir:69:45: error: use of undeclared SSA value name
              %app_7  =  hask.apSSA(%app_6, %var_unit_tuple_71)
                                            ^
tomlir-fibstrict.pass-0000.mlir:77:29: error: use of undeclared SSA value name
      %app_1  =  hask.apSSA(%var_runMainIO_01E, %type_0)
                            ^
makefile:4: recipe for target 'fibstrict' failed
make: *** [fibstrict] Error 1

-- | generated from fibstrict.hs
==================== Desugar (after optimization) ====================
2020-07-08 16:31:29.998915479 UTC
...

-- RHS size: {terms: 7, types: 3, coercions: 0, joins: 0/0}
main :: IO ()
[LclIdX]
main
  = case fib 10# of { __DEFAULT ->
    return @ IO GHC.Base.$fMonadIO @ () GHC.Tuple.()
    }

-- | what is this :Main.main?
-- RHS size: {terms: 2, types: 1, coercions: 0, joins: 0/0}
:Main.main :: IO ()
[LclIdX]
:Main.main = GHC.TopHandler.runMainIO @ () main

-- ***GHC file fibstrict.dump-ds***
-- RHS size: {terms: 2, types: 1, coercions: 0, joins: 0/0}
:Main.main :: IO ()
[LclIdX]
:Main.main = GHC.TopHandler.runMainIO @ () main

-- ***my MLIR file with the Core appended to the end as a comment***
-- RHS size: {terms: 2, types: 1, coercions: 0, joins: 0/0}
main :: IO ()
[LclIdX]
main = runMainIO @ () main

compiler/GHC/Tc/Module.hs
-- See Note [Root-main Id]
-- Construct the binding
--      :Main.main :: IO res_ty = runMainIO res_ty main
; run_main_id <- tcLookupId runMainIOName
; let { root_main_name =  mkExternalName rootMainKey rOOT_MAIN
                   (mkVarOccFS (fsLit "main"))
                   (getSrcSpan main_name)
; root_main_id = Id.mkExportedVanillaId root_main_name
                                      (mkTyConApp ioTyCon [res_ty])

Note [Root-main Id]
~~~~~~~~~~~~~~~~~~~
The function that the RTS invokes is always :Main.main, which we call
root_main_id.  (Because GHC allows the user to have a module not
called Main as the main module, we can't rely on the main function
being called "Main.main".  That's why root_main_id has a fixed module
":Main".)

This is unusual: it's a LocalId whose Name has a Module from another
module. Tiresomely, we must filter it out again in GHC.Iface.Make, less we
get two defns for 'main' in the interface file!

{-# LANGUAGE MagicHash #-}
import GHC.Prim
fib :: Int# -> Int#
fib i = case i of 0# ->  i; 1# ->  i; _ ->  (fib i) +# (fib (i -# 1#))

main :: IO (); main = let x = fib 10# in return ()

// Main
// Core2MLIR: GenMLIR BeforeCorePrep
hask.module {
    %plus_hash = hask.make_data_constructor<"+#">
    %minus_hash = hask.make_data_constructor<"-#">
    %unit_tuple = hask.make_data_constructor<"()">
  hask.func @fib {
  %lambda_0 = hask.lambdaSSA(%i_a12E) {
    %case_1 = hask.caseSSA  %i_a12E
    ["default" ->
    {
    ^entry(%ds_d1jZ: !hask.untyped):
      # app_2 = (-# i_a123)
      %app_2 = hask.apSSA(%minus_hash, %i_a12E)
      # lit_3 = 1
      %lit_3 = hask.make_i32(1)
      # app_4 = (-# i_a123 1)
      %app_4 = hask.apSSA(%app_2, %lit_3)
      # app_5 = fib (-# i_a123 1)
      %app_5 = hask.apSSA(@fib, %app_4)
      # wild_00 = force(fib(-# i_a123 1))
      %wild_00 = hask.force (%app_5)
      # app_7 = fib(i)
      %app_7 = hask.apSSA(@fib, %i_a12E)
      # wild_X5 = force(fib(i))
      %wild_X5 = hask.force (%app_7)
      # app_7 = (+# force(fib(i)))
      %app_9 = hask.apSSA(%plus_hash, %wild_X5)
      # app_10 = (+# force(fib(i)) fib(-# i_a123 1))
      %app_10 = hask.apSSA(%app_9, %wild_00)
    hask.return(%app_10)
    }
    ]
    [0 ->
    {
    ^entry(%ds_d1jZ: !hask.untyped):
    hask.return(%i_a12E)
    }
    ]
    [1 ->
    {
    ^entry(%ds_d1jZ: !hask.untyped):
    hask.return(%i_a12E)
    }
    ]
    hask.return(%case_1)
  }
  hask.return(%lambda_0)
  }
hask.dummy_finish
}
// ============ Haskell Core ========================
//Rec {
//-- RHS size: {terms: 21, types: 4, coercions: 0, joins: 0/0}
//main:Main.fib [Occ=LoopBreaker]
//  :: ghc-prim-0.5.3:GHC.Prim.Int# -> ghc-prim-0.5.3:GHC.Prim.Int#
//[LclId]
//main:Main.fib
//  = \ (i_a12E :: ghc-prim-0.5.3:GHC.Prim.Int#) ->
//      case i_a12E of {
//        __DEFAULT ->
//          case main:Main.fib (ghc-prim-0.5.3:GHC.Prim.-# i_a12E 1#)
//          of wild_00
//          { __DEFAULT ->
//          (case main:Main.fib i_a12E of wild_X5 { __DEFAULT ->
//           ghc-prim-0.5.3:GHC.Prim.+# wild_X5
//           })
//            wild_00
//          };
//        0# -> i_a12E;
//        1# -> i_a12E
//      }
//end Rec }
//
//-- RHS size: {terms: 5, types: 0, coercions: 0, joins: 0/0}
//main:Main.$trModule :: ghc-prim-0.5.3:GHC.Types.Module
//[LclIdX]
//main:Main.$trModule
//  = ghc-prim-0.5.3:GHC.Types.Module
//      (ghc-prim-0.5.3:GHC.Types.TrNameS "main"#)
//      (ghc-prim-0.5.3:GHC.Types.TrNameS "Main"#)
//
//-- RHS size: {terms: 7, types: 3, coercions: 0, joins: 0/0}
//main:Main.main :: ghc-prim-0.5.3:GHC.Types.IO ()
//[LclIdX]
//main:Main.main
//  = case main:Main.fib 10# of { __DEFAULT ->
//    base-4.12.0.0:GHC.Base.return
//      @ ghc-prim-0.5.3:GHC.Types.IO
//      base-4.12.0.0:GHC.Base.$fMonadIO
//      @ ()
//      ghc-prim-0.5.3:GHC.Tuple.()
//    }
//
//-- RHS size: {terms: 2, types: 1, coercions: 0, joins: 0/0}
//main::Main.main :: ghc-prim-0.5.3:GHC.Types.IO ()
//[LclIdX]
//main::Main.main
//  = base-4.12.0.0:GHC.TopHandler.runMainIO @ () main:Main.main
//

// Main
// Core2MLIR: GenMLIR BeforeCorePrep
hask.module {
    %plus_hash = hask.make_data_constructor<"+#">
    %minus_hash = hask.make_data_constructor<"-#">
    %unit_tuple = hask.make_data_constructor<"()">
  hask.func @fib {
    %lambda = hask.lambdaSSA(%i) {
      %retval = hask.caseSSA  %i
      ["default" -> { ^entry(%default_random_name: !hask.untyped): // todo: remove this defult
        %i_minus = hask.apSSA(%minus_hash, %i)
        %lit_one = hask.make_i32(1)
        %i_minus_one = hask.apSSA(%i_minus, %lit_one)
        %fib_i_minus_one = hask.apSSA(@fib, %i_minus_one)
        %force_fib_i_minus_one = hask.force (%fib_i_minus_one) // todo: this is extraneous!
        %fib_i = hask.apSSA(@fib, %i)
        %force_fib_i = hask.force (%fib_i) // todo: this is extraneous!
        %plus_force_fib_i = hask.apSSA(%plus_hash, %force_fib_i)
        %fib_i_plus_fib_i_minus_one = hask.apSSA(%plus_force_fib_i, %force_fib_i_minus_one)
        hask.return(%fib_i_plus_fib_i_minus_one) }]
      [0 -> { ^entry(%default_random_name: !hask.untyped):
        hask.return(%i) }]
      [1 -> { ^entry(%default_random_name: !hask.untyped):
        hask.return(%i) }]
      hask.return(%retval)
    }
    hask.return(%lambda)
  }
hask.dummy_finish
}

./fib-strict.mlir:4:18: error: block with no terminator
    %plus_hash = hask.make_data_constructor<"+#">

(gdb) run
The program being debugged has been started already.
Start it from the beginning? (y or n) y
Starting program: /home/bollu/work/mlir/coremlir/build/bin/hask-opt ./fib-strict.mlir
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
- parse:197attribute: "+#"
- parse:198attribute ty: none
- parse:197attribute: "-#"
- parse:198attribute ty: none
- parse:197attribute: "()"
- parse:198attribute ty: none
-parse:454:%i
parse:396
parse:398
parse:413
parse:417
parse:420
parse:423
Module (no optimization):

module {
  hask.module {
    %0 = hask.make_data_constructor<"+#">
    %1 = hask.make_data_constructor<"-#">
    %2 = hask.make_data_constructor<"()">
    hask.func @fib {
      %3 = hask.lambdaSSA(%arg0) {
        %4 = hask.caseSSA %arg0 ["default" ->  {
        ^bb0(%arg1: !hask.untyped):  // no predecessors
          %5 = hask.apSSA(%5,hask-opt: /home/bollu/work/mlir/llvm-project/mlir/lib/IR/Value.cpp:22: mlir::Value::Value(mlir::Operation*, unsigned int): Assertion `op->getNumResults() > resultNo && "invalid result number"' failed.

Module (+optimization):

module {
  hask.module {
    %0 = hask.make_data_constructor<"+#">
    %1 = hask.make_data_constructor<"-#">
    %2 = hask.make_data_constructor<"()">
    hask.func @fib {
      %3 = hask.lambdaSSA(%arg0) {
        %4 = hask.caseSSA %arg0 ["default" ->  {
        ^bb0(%arg1: !hask.untyped):  // no predecessors
          %5 = hask.apSSA(%1, %arg0) // <- dead!
          %6 = hask.make_i32(1 : i64)
          %7 = hask.apSSA(%1, %arg0, %6)
          %8 = hask.apSSA(@fib, %7)
          %9 = hask.force(%8)
          %10 = hask.apSSA(@fib, %arg0)
          %11 = hask.force(%10)
          %12 = hask.apSSA(%0, %11) // <- dead!
          %13 = hask.apSSA(%0, %11, %9)
          hask.return(%13)
        }]
 [0 : i64 ->  {
        ^bb0(%arg1: !hask.untyped):  // no predecessors
          hask.return(%arg0)
        }]
 [1 : i64 ->  {
        ^bb0(%arg1: !hask.untyped):  // no predecessors
          hask.return(%arg0)
        }]

        hask.return(%4)
      }
      hask.return(%3)
    }
    hask.dummy_finish
  }
}

Module (no optimization):hask-opt: /home/bollu/work/mlir/llvm-project/mlir/lib/Pass/Pass.cpp:275:
mlir::OpPassManager::OpPassManager(mlir::OperationName, bool):
Assertion `name.getAbstractOperation()->hasProperty( OperationProperty::IsolatedFromAbove) &&
"OpPassManager only supports operating on operations marked as " "'IsolatedFromAbove'"' failed.
Aborted (core dumped)
../build/bin/hask-opt ./fib-strict-roundtrip.mlir
Module (no optimization):

module {
}hask-opt: /home/bollu/work/mlir/llvm-project/mlir/lib/Pass/Pass.cpp:275:
mlir::OpPassManager::OpPassManager(mlir::OperationName, bool):
Assertion `name.getAbstractOperation()->hasProperty( OperationProperty::IsolatedFromAbove) &&
"OpPassManager only supports operating on operations marked as " "'IsolatedFromAbove'"' failed.

Module (no optimization):Module: lowering to standard+SCF...hask-opt:
/home/bollu/work/mlir/llvm-project/mlir/lib/Transforms/DialectConversion.cpp:1504:
mlir::LogicalResult
  {anonymous}::OperationLegalizer
  ::legalizePatternResult(mlir::Operation*,
      const mlir::RewritePattern&,
      mlir::ConversionPatternRewriter&,
      {anonymous}::RewriterState&):
  Assertion `(replacedRoot || updatedRootInPlace()) &&
  "expected pattern to replace the root operation"' failed.

Module (no optimization):Module: lowering to standard+SCF...
hask-opt: /home/bollu/work/mlir/llvm-project/mlir/lib/IR/PatternMatch.cpp:142:
void mlir::PatternRewriter::replaceOpWithResultsOfAnotherOp(mlir::Operation*, mlir::Operation*):
Assertion `op->getNumResults() == newOp->getNumResults() &&
"replacement op doesn't match results of original op"' failed.

vvvvvvvvvvvvvvvvvvvvvvvvvvvv
Module (+optimization), lowered to Standard+SCF:


module {
  module {
    hask.module {
      %0 = hask.make_data_constructor<"+#">
      %1 = hask.make_data_constructor<"-#">
      %2 = hask.make_data_constructor<"()">
      hask.func @fib {
        %3 = hask.lambdaSSA(%arg0) {
          %4 = hask.caseSSA %arg0 ["default" ->  {
          ^bb0(%arg1: !hask.untyped):  // no predecessors
            %5 = hask.make_i32(1 : i64)
            %6 = hask.apSSA(%1, %arg0, %5)
            %7 = hask.apSSA(@fib, %6)
            %8 = hask.force(%7)
            %9 = hask.apSSA(@fib, %arg0)
            %10 = hask.force(%9)
            %11 = hask.apSSA(%0, %10, %8)
            hask.return(%11)
          }]
 [0 : i64 ->  {
          ^bb0(%arg1: !hask.untyped):  // no predecessors
            hask.return(%arg0)
          }]
 [1 : i64 ->  {
          ^bb0(%arg1: !hask.untyped):  // no predecessors
            hask.return(%arg0)
          }]

          hask.return(%4)
        }
        hask.return(%3)
      }
      hask.dummy_finish
    }
  }
  module {
    hask.module {
      %0 = hask.make_data_constructor<"+#">
      %1 = hask.make_data_constructor<"-#">
      %2 = hask.make_data_constructor<"()">
      hask.func @fib {
        %3 = hask.lambdaSSA(%arg0) {
          %4 = hask.caseSSA %arg0 ["default" ->  {
          ^bb0(%arg1: !hask.untyped):  // no predecessors
            %5 = hask.make_i32(1 : i64)
            %6 = hask.apSSA(%1, %arg0, %5)
            %7 = hask.apSSA(@fib, %6)
            %8 = hask.force(%7)
            %9 = hask.apSSA(@fib, %arg0)
            %10 = hask.force(%9)
            %11 = hask.apSSA(%0, %10, %8)
            hask.return(%11)
          }]
 [0 : i64 ->  {
          ^bb0(%arg1: !hask.untyped):  // no predecessors
            hask.return(%arg0)
          }]
 [1 : i64 ->  {
          ^bb0(%arg1: !hask.untyped):  // no predecessors
            hask.return(%arg0)
          }]

          hask.return(%4)
        }
        hask.return(%3)
      }
      hask.dummy_finish
    }
  }
}^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

// Input
// Debugging file: Can do anything here.
hask.module {
    %plus_hash = hask.make_data_constructor<"+#">
    %minus_hash = hask.make_data_constructor<"-#">
    %unit_tuple = hask.make_data_constructor<"()">
  hask.func @fib {
    %lambda = hask.lambdaSSA(%i) {
      hask.return(%unit_tuple)
    }
    hask.return(%lambda)
  }
  hask.dummy_finish
}

// Output
module {
  hask.module {
    %0 = hask.make_data_constructor<"+#">
    %1 = hask.make_data_constructor<"-#">
    %2 = hask.make_data_constructor<"()">
    hask.dummy_finish
  }
}

// INPUT
hask.module {
    %plus_hash = hask.make_data_constructor<"+#">
    %minus_hash = hask.make_data_constructor<"-#">
    %unit_tuple = hask.make_data_constructor<"()">
  hask.func @fib {
    %lambda = hask.lambdaSSA(%i) {
      hask.return(%unit_tuple)
    }
    hask.return(%lambda)
  }
  hask.dummy_finish
}

// LOWERED
module {
  hask.module {
    %0 = hask.make_data_constructor<"+#">
    %1 = hask.make_data_constructor<"-#">
    %2 = hask.make_data_constructor<"()">
    func @fib_lowered()
    hask.dummy_finish
  }
}

hask.module {
    hask.make_data_constructor @"+#"
    hask.make_data_constructor @"-#"
    hask.make_data_constructor @"()"

  hask.func @fib {
    %lambda = hask.lambdaSSA(%i) {
      // %foo_ref = constant @XXXX : () -> ()
      %f = hask.ref(@"+#")
      hask.return(%f)
    }
    hask.return(%lambda)
  }
  hask.dummy_finish
}

module {
  hask.module {
    hask.make_data_constructor +#
    hask.make_data_constructor -#
    hask.make_data_constructor ()
    vvv is a std func with a real argument.
    func @fib_lowered(%arg0: !hask.untyped) {
      %0 = hask.ref (@"+#")
      hask.return(%0)
    }
    hask.dummy_finish
  }
}                                                                                                                                      

hask.func @fib {
  %lambda = hask.lambdaSSA(%i) {
      ...
      %fib_i = hask.apSSA(@fib, %i)
      ...
  }
}

func @fib_lowered(%arg0: !hask.untyped) {
      ...
      %fib_i = hask.apSSA(@fib, %i) <- still called fib!
      ...
  }
}

./playground.mlir:14:28: error: 'std.call' op 'fib' does not reference a valid function
        %fib_i_minus_one = hask.apSSA(@fib, %i_minus_one)
                           ^
./playground.mlir:14:28: note: see current operation: %1 = "std.call"(%0) {callee = @fib} : (i32) -> i32
===Lowering failed.===
===Incorrectly lowered Module to Standard+SCF:===


module {
  hask.module {
    hask.make_data_constructor @"+#"
    hask.make_data_constructor @"-#"
    hask.make_data_constructor @"()"
    func @fib_lowered(%arg0: i32) {
      %c1_i32 = constant 1 : i32
      %0 = subi %arg0, %c1_i32 : i32
      %1 = call @fib(%0) : (i32) -> i32
      %2 = call @fib(%arg0) : (i32) -> i32
      %3 = addi %2, %1 : i32
      return %3 : i32
    }
    hask.dummy_finish
  }
}

git log --pretty='%C(yellow)%h %C(cyan)%ad %Cgreen%an%C(cyan)%d %Creset%s' --date=relative --date-order --graph --shortstat