x = 1  
x + 1 # <- 絶対 `Int`

name = readline()         # <- String
msg  = "Hello, $(name)!"  # <- String

if x isa Number              # <- `x` の値の型は `Number` 型の子か?
    println("数字:", x)     
elseif x isa AbstractString  # <- `x` の値の型は `AbstractString` 型の子か?
    println("文字列:", x)  
end 

add(a::Int, b::Int) = a + b

struct MyInt
    v::Int
end


add(a::MyInt, b::MyInt) = MyInt((a.v + b.v) * 100)

a = MyInt(1)
b = MyInt(1)
add(a, b)　# => MyInt(200)

f(x::Real, y::Real) = add_with_error_handle(x, y)
f(x::Int, y::Int) = x + y

function call_generic(fname, args)
    argtypes = typeof.(args)                         # (1) 引数の値の型チェック
    matched = lookup(methodtable, fname, argtypes)   # (2) マッチするメソッドを検索
    invoke(matched, args)                            # (3) 実行
end 

julia> a = [1, 2, 3]
3-element Vector{Int64}:
 1
 2
 3

julia> const b = [1, 2, 3]
3-element Vector{Int64}:
 1
 2
 3

julia> function f(c)
           d = c * a
           return sum(d)
       end
f (generic function with 1 method)

julia> function g(c)
           d = c * b
           return sum(d)
       end
g (generic function with 1 method)

julia> @code_typed f(1)
# CodeInfo(
# 1 ─ %1 = Main.a::Any         # <- Any と推論されている
# │   %2 = (c * %1)::Any       # <- それとの積は `Any` 
# │   %3 = Main.sum(%2)::Any   # <- `sum` という generics 呼び出しのまま
# └──      return %3
# ) => Any                     # <- `f(1)` 自体も `Any` と推論

julia> @code_typed g(1)
# CodeInfo(
# 1 ── %1   = invoke Main.:*(c::Int64, Main.b::Vector{Int64})::Vector{Int64}
#                ...
# 9 ┄─ %28  = Base.getfield(%1, :ref)::MemoryRef{Int64}
# │    %29  = Base.memoryrefnew(%28, 1, false)::MemoryRef{Int64}
# │    %30  = Base.memoryrefget(%29, :not_atomic, false)::Int64
# └───        goto #10
# 10 ─        goto #32
# 11 ─ %33  = Base.slt_int(%8, 16)::Bool
# └───        goto #31 if not %33
#               ...
# 31 ─ %98  = invoke Base.mapreduce_impl(%4::typeof(identity),  %5::typeof(Base.add_sum), %1::Vector{Int64}, 1::Int64, %8::Int64, 1024::Int64)::Int64
# └───        goto #32
# 32 ┄ %100 = φ (#3 => 0, #10 => %30, #30 => %72, #31 => %98)::Int64
#                ...
# │    %118 = Base.not_int(%117)::Bool
# └───        goto #46 if not %118
# 45 ─        goto #2
# 46 ─        return %110
# ) => Int64

julia> @benchmark f(1)
BenchmarkTools.Trial: 10000 samples with 994 evaluations per sample.
 Range (min … max):  30.978 ns …  2.146 μs  ┊ GC (min … max): 0.00% … 97.90%
 Time  (median):     33.284 ns              ┊ GC (median):    0.00%
 Time  (mean ± σ):   36.100 ns ± 46.637 ns  ┊ GC (mean ± σ):  7.44% ±  6.10%

  ▁▂▁▁▇▇▅▃▂▅██▄▃▅▃▂▁ ▁▃▃▁                                     ▂
  ███████████████████████▇▇▇▇▆▇▇▆▆▅▅▆▅▆▆▂▅▅▅▅▆▇▄▅▆▅▅▅▄▅▅▄▅▅▅▆ █
  31 ns        Histogram: log(frequency) by time        44 ns <

 Memory estimate: 80 bytes, allocs estimate: 2.

julia> @benchmark g(1)
BenchmarkTools.Trial: 10000 samples with 998 evaluations per sample.
 Range (min … max):  15.281 ns …  1.825 μs  ┊ GC (min … max):  0.00% … 98.33%
 Time  (median):     15.949 ns              ┊ GC (median):     0.00%
 Time  (mean ± σ):   18.962 ns ± 52.555 ns  ┊ GC (mean ± σ):  13.34% ±  4.96%

   ▄▆▆██▇▆▅▄▄▂▃▃▃▂▂▂▁ ▁ ▁▁▂▁▁ ▁    ▁▂▁▁                       ▂
  ███████████████████████████████▇██████▇▆▇▇▆▅▅▆▅▆▆▆▅▅▆▅▆▃▆▇▇ █
  15.3 ns      Histogram: log(frequency) by time        22 ns <

 Memory estimate: 80 bytes, allocs estimate: 2.

myadd(a::Int, b::Int) = a + b

function main()
    println("Start to execute main~~")
    myadd(0.2, 0.3)  # <- `myadd` は (Float64, Float64) に対しては実装がない
end

main()

# ↓
# ↓
# julia> include("no_method.jl")
# Start to execute main~~
# ERROR: LoadError: MethodError: no method matching myadd(::Float64, ::Float64)
# The function `myadd` exists, but no method is defined for this combination of argument types.
# 
# Closest candidates are:
#   myadd(::Int64, ::Int64)
#    @ Main ~/Desktop/mu/no_method.jl:1

julia> using JET

julia> myadd(a::Int, b::Int) = a + b
myadd (generic function with 1 method)

julia> function main()
           println("Start to execute main~~")
           myadd(0.2, 0.3)  
       end
main (generic function with 1 method)

julia> @report_call main()
═════ 1 possible error found ═════         # <-  no method を発見
┌ main() @ Main ./REPL[3]:3
│ no matching method found `myadd(::Float64, ::Float64)`: myadd(0.2, 0.3)
└────────────────────

julia> lowered_ir = Meta.lower(Main, 
                  quote
                      for i in 1:10
                          println(i)
                      end
                  end
              )
              
# :($(Expr(:thunk, CodeInfo(
#    @ REPL[23]:3 within `top-level scope`
# 1 ─ %1  = :
# │   %2  = (%1)(1, 10)
# │         #s2 = Base.iterate(%2)         
# │   %4  = #s2
# │   %5  = %4 === nothing
# │   %6  = Base.not_int(%5)
# └──       goto #4 if not %6                # <- goto が生えてる
# 2 ┄ %8  = #s2
# │         i = Core.getfield(%8, 1)
# │   %10 = Core.getfield(%8, 2)
# │   @ REPL[23]:4 within `top-level scope`
# │   %11 = i
# │         println(%11)
# │   @ REPL[23]:5 within `top-level scope`
# │         #s2 = Base.iterate(%2, %10)
# │   %14 = #s2
# │   %15 = %14 === nothing
# │   %16 = Base.not_int(%15)
# └──       goto #4 if not %16                # <- goto が生えてる
# 3 ─       goto #2                           # <- goto が生えてる
# 4 ┄       return nothing
# ))))

julia> lowered_ir.args[1].code[1:10]
10-element Vector{Any}:
 :(Core.get_binding_type(Main, :i))
 :(_1 = 0)
 :(_1)
 :(%3 isa %1)
 :(goto %7 if not %4)
 :(goto %9)
 :(_1)
 :(_1 = Base.convert(%1, %7))
 :(_1)
 :(i = %9)

if cond
    x = 1
else
    x = 2
end

y = 2 * x

y 

x? <= 未定義
y? <= 未定義

if cond
    x = 奇数
else
    x = 偶数
end

x? <= (奇数 または 偶数)

y = 偶数 * (奇数 または 偶数)

y? <=  偶数

function f(x::Int, y::Int){
    return complex_function(x, y)
}

function f(x::Real, y::Real){
    _check_calcuable(x, y)
    return complex_function(x, y)
}

function main(){
    f(1, 2) # => complex_function(1, 2)
    f(1.0, 2.0) # => _check_calcuable(1.0, 2.0); complex_function(1.0, 2.0)
}

function f(x)
    if x > 0
        return 1
    else 
      return 1.0    
    end
end   # => Union{Int, Float64}

Union{Vector{Int, 1}} 
<: Union{Array{Int, 1}, Array{Int, 2}} 
<: Union{Array{Int, 1}, Array{Int, 2}, Array{Int, 3}} 
<: Union{Array{Int, 1}, Array{Int, 2}, Array{Int, 3}, Array{Int, 4}} 
...

function abstract_interpret(I::Program, abstract_semantics::Function, a₀::AbstractState)::Vector{AbstractState}
    n = length(I)
    inputs = [copy(a₀) for _ in 1:n]
    outputs = [copy(a₀) for _ in 1:n]
    pred = build_pred(I) 

    while true
        change = false

        for i in 1:n
            current_input = inputs[i]
            current_output = outputs[i]

            new_input = reduce(⊓, outputs[j] for j in pred[i]; init=copy(a₀))
            new_output = abstract_semantics(I[i])(new_input)

            inputs[i] = new_input
            outputs[i] = new_output
            
            if (current_input != new_input) || (current_output != new_output)
                change = true
            end
        end


        if !change
            break
        end
    end           


    return [inputs; outputs[end]]
end

-function abstract_interpret(I::Program, abstract_semantics::Function, a₀::AbstractState)::Vector{AbstractState}
+function abstract_interpret(I::Program, abstract_semantics::Function, a₀::AbstractState, ∇::Function)::Vector{AbstractState}
     n = length(I)
     inputs = [copy(a₀) for _ in 1:n]
     outputs = [copy(a₀) for _ in 1:n]
@@ -99,7 +99,7 @@ function abstract_interpret(I::Program, abstract_semantics::Function, a₀::Abst
             new_output = abstract_semantics(I[i])(new_input)
 
             inputs[i] = new_input
-            outputs[i] = new_output
+            outputs[i] = ∇(new_output, current_output)
             
             if (current_input != new_input) || (current_output != new_output)
                 change = true

@enum ExprHead begin
    GCALL # Generic function call
    BCALL # Builtin function call
    ASSIGN     # Assignment

    IFELSE     # If-else statement
    IF         # If statement
    WHILE      # While statement

    PROGRAM    # Special type to represent the whole program
    BLOCK      # Block to group multiple expressions

    FUNCTION   # For function definition
    FORMALARGS # |  Formal arguments for function definition
    TYPEDIDENT # |  Typed identifier. e.g. `a::Array{Int, 2}`
    TYPE       # |  Type. e.g. `Array{Int, 2}`
    RETURN     # |  Return statement

    GOTO         #  Goto label without condition        |
    GOTOIFNOT    #  Goto label if condition is false    | ==> These are for IR.
    LABEL        #  Label for goto                      |     Result of `parse` function will not have these.
end

struct Expr <: AbstractSyntaxNode
    head::ExprHead
    args::Vector{Any} # It is not avoidable to use `Any` here.
end

function main(){
    x = [1, 2, 3]
    n = 100

    i = 0

    while (i < n){
        x = expanddims(x)
        i = i + 1
    }

    return x
}

julia> mu.MuCore.parse(TESTCASE6) |> dump
# mu.MuCore.MuAST.Expr
#  head: mu.MuCore.MuAST.ExprHead mu.MuCore.MuAST.PROGRAM
#  args: Array{Any}((1,))
#    1: mu.MuCore.MuAST.Expr
#      head: mu.MuCore.MuAST.ExprHead mu.MuCore.MuAST.FUNCTION
#      args: Array{Any}((3,))
#  ... 長いので省略 ...
#                2: Int64 0
#            4: mu.MuCore.MuAST.Expr
#              head: mu.MuCore.MuAST.ExprHead mu.MuCore.MuAST.WHILE
#              args: Array{Any}((2,))
#                1: mu.MuCore.MuAST.Expr
#                2: mu.MuCore.MuAST.Expr
#            5: mu.MuCore.MuAST.Expr
#              head: mu.MuCore.MuAST.ExprHead mu.MuCore.MuAST.RETURN
#              args: Array{Any}((1,))
#                1: mu.MuCore.MuAST.Ident

@enum InstrType begin
    ASSIGN           # Assignment
    GOTO             # Goto label without condition
    GOTOIFNOT        # Goto label if condition is false.  
    LABEL            # Label for goto
    RETURN           # Return statement
end

struct Instr
    instrtype::InstrType
    expr::MuAST.Expr
end

# Representation of program after lowering.
struct CodeInfo
    instrs::Vector{Instr}
    typed::Bool
    varnames::Vector{MuAST.Ident}
    vartypes::Vector{Union{DataType,Nothing}}
    function CodeInfo()
        return new(Instr[], false, MuAST.Ident[], Union{DataType,Nothing}[])
    end
end

# Information of each **method**.
struct MethodInfo
    id::Int                         # id of the method (unique)
    name::MuAST.Ident               # Name of the method (not unique) 
    argname::Vector{MuAST.Ident}    # Argument names (e.g. [`a`, `b`, `c`])
    signature::MuTypes.Signature    # Signature of the method. All elements must be MuTypes.
    ci::CodeInfo                    # IR of the method
end

        ...
        
    elseif expr.head == MuAST.WHILE
        # while (cond) 
        #     body
        #
        # ↓
        # label cond_label
        # goto end_label if not cond
        # body
        # goto cond_label
        # label end_label

        cond, body = expr.args

        cond_label_id = label_gen()
        end_label_id = label_gen()

        pushlabel!(ir, cond_label_id)
        pushgotoifnot!(ir, end_label_id, cond)
        append!(ir, _lowering(body))
        pushgoto!(ir, cond_label_id)
        pushlabel!(ir, end_label_id)
    else
        ...

while (cond) {
    body
}

label cond_label
goto end_label if not cond
body
goto cond_label
label end_label

y = 3 * x + 4

julia> mu.MuCore.parse("y = 3 * x + 4")
(PROGRAM

    (ASSIGN y (GCALL add (GCALL mul 3 x) 4))
)

%1 = (CALL mul 3 x)
y  = (CALL add %1 4)

julia> mu.MuCore.lowering(ast)
# 1-element Vector{mu.MuCore.MuIR.MethodInstance}:
# function main()
#
# | idx |  instrtype | instr
# | --- | ---------- | ----------------------------------------
# |   1 |     ASSIGN | x = [1, 2, 3]
# |   2 |     ASSIGN | n = 100
# |   3 |     ASSIGN | i = 0
# |   4 |      LABEL | LABEL #29
# |   5 |     ASSIGN | %32 = (GCALL lt i n)
# |   6 |  GOTOIFNOT | GOTO #30 IF NOT %32
# |   7 |     ASSIGN | x = (GCALL expanddims x)
# |   8 |     ASSIGN | i = (GCALL add i 1)
# |   9 |       GOTO | GOTO #29
# |  10 |      LABEL | LABEL #30
# |  11 |     ASSIGN | %ret = x
# |  12 |       GOTO | GOTO RETURN
# |  13 |      LABEL | LABEL RETURN
# |  14 |     RETURN | RETURN %ret
#
# end

function f(){
    if (true){
        if (true){
            return 1
            } else {
                return 1.0
            }
        } else {
            return "hello"
        }
    }
}

julia> ast = MuCore.parse(src);   # パース

julia> lowerd = MuCore.lowering(ast);   # lowering

julia> mt = MuBase.load_base(); # 標準ライブラリの入ったメソッドテーブルを用意

julia> MuCore.MuInterpreter.load!(mt, lowerd); # メソッドテーブルに src をロード

julia> MuTypeInf.return_type(lowerd[end], argtypes=[], mt=mt)  # 推論！
mu.MuCore.MuTypes.Union{mu.MuCore.MuTypes.Union{mu.MuCore.MuTypes.Int, mu.MuCore.MuTypes.Float}, mu.MuCore.MuTypes.String}

function expanddims(arr::AbstractArray){
    result_size = append(size(arr), 1)
    return reshape(arr, result_size)
}

function main(){
    x = [1, 2, 3]
    n = 100

    i = 0

    while (i < n){
        x = expanddims(x)
        i = i + 1
    }

    return x
}

julia> ast  = MuCore.parse(src);

julia> lowerd = MuCore.lowering(ast);

julia> mt = MuBase.load_base();

julia> MuCore.MuInterpreter.load!(mt, lowerd);

julia> MuTypeInf.return_type(lowerd[end], argtypes=[], mt=mt)
mu.MuCore.MuTypes.AbstractArray