# 使用 Meta.parse 获取 AST
expr = Meta.parse("x + 2 * y")
println(expr)

# 输出：
# x + 2 * y
# 也就是 Expr(:call, :+, :x, Expr(:call, :*, 2, :y))

# dump 查看完整结构
dump(Meta.parse("x + 2 * y"))
# Expr
#   head: Symbol call
#   args: Array{Any}((3,))
#     1: Symbol +
#     2: Symbol x
#     3: Expr
#       head: Symbol call
#       args: Array{Any}((3,))
#         1: Symbol *
#         2: Int64 2
#         3: Symbol y

# 方式一：quote 块
ex = quote
    function add(a, b)
        return a + b
    end
end

# 方式二：手动构造
ex = Expr(:call, :+, :a, :b)
eval(ex)  # 需要 a, b 在作用域内

# 方式三：使用 esc 和 Expr 在宏中构造
macro make_adder(name)
    fname = esc(name)
    quote
        function $fname(a, b)
            return a + b
        end
    end
end

@make_adder my_add
println(my_add(3, 4))  # 7

# 简单函数的类型推断
function add_numbers(a, b)
    return a + b
end

# 查看推断结果
@code_warntype add_numbers(1, 2)
# 注意输出中变量的类型标注：
# - 如果显示具体类型（如 Int64），表示推断成功
# - 如果显示红色的 Union{...} 或 Any，表示推断不够精确

# ✅ 类型稳定 — 返回类型可从输入类型推断
function stable_func(x::Float64)
    if x > 0
        return x * 2.0    # Float64
    else
        return x + 1.0    # Float64
    end
end

# ❌ 类型不稳定 — 返回类型取决于运行时值
function unstable_func(x::Float64)
    if x > 0
        return x           # Float64
    else
        return "negative"  # String — 类型冲突！
    end
end

@code_warntype stable_func(1.0)
@code_warntype unstable_func(-1.0)

# 当推断失败时，类型回退到 Any
function mystery(x)
    return x.foo   # 编译器不知道 x 的类型
end

# 使用 @code_warntype 可以看到 BODY 中的红色 Any 标记
struct MyType
    foo::Int
end

@code_warntype mystery(MyType(42))

function process(x)
    return x^2 + 1
end

# 编译器为每种调用类型生成独立方法
process(2)       # 生成 process(::Int64) 的机器码
process(2.0)     # 生成 process(::Float64) 的机器码
process(2 + 3im) # 生成 process(::Complex{Int64}) 的机器码

# 查看已特化的方法
methods(process)

# ⚠️ 当参数类型过多时，特化会导致编译时间和内存膨胀
function generic_process(x)
    # 对 x 做复杂操作
    return x
end

# 每种类型都会触发一次编译
for T in [Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64,
          Float16, Float32, Float64]
    generic_process(T(1))
end
# 生成了 11 个特化版本！

# 💡 使用抽象类型约束可减少特化
function constrained_process(x::Number)
    return x
end

function compute(x, y)
    z = x + y
    if z > 0
        return sqrt(z)
    else
        return 0.0
    end
end

@code_warntype compute(3.0, 4.0)

@code_lowered compute(3.0, 4.0)
# 展示 Julia 层面的中间表示（SSA 形式）
# 此阶段还没有类型信息

@code_typed compute(3.0, 4.0)
# 展示经过类型推断和优化后的 IR
# 变量已携带具体类型

@code_llvm compute(3.0, 4.0)
# 展示生成的 LLVM 中间表示
# 可以看到实际的浮点运算指令

@code_native compute(3.0, 4.0)
# 展示目标平台的汇编代码
# x86_64 上会看到 xmm 寄存器、addsd 等指令

# Julia 对象的内存布局
struct Point
    x::Float64
    y::Float64
end

p = Point(1.0, 2.0)

# 查看内存大小
sizeof(p)      # 16 字节 (2 × 8 字节 Float64)

# 字段偏移
fieldoffset(Point, 1)  # 0 — x 从偏移 0 开始
fieldoffset(Point, 2)  # 8 — y 从偏移 8 开始

# Julia 遵循平台的对齐规则
struct Mixed
    a::UInt8    # 1 字节
    b::UInt32   # 4 字节
    c::UInt8    # 1 字节
end

sizeof(Mixed)           # 可能是 12 而非 6（因为对齐填充）
fieldoffset(Mixed, 1)   # 0
fieldoffset(Mixed, 2)   # 4 (对齐到 4 字节边界)
fieldoffset(Mixed, 3)   # 8

# 抽象类型字段会导致"装箱"
struct BadWrapper
    data::Number  # 抽象类型 — 值会被装箱
end

struct GoodWrapper{T<:Number}
    data::T  # 参数化类型 — 无装箱
end

bw = BadWrapper(42)
gw = GoodWrapper(42)

sizeof(bw)  # 8（指针大小，值在堆上）
sizeof(gw)  # 8（Int64 直接内联，无额外开销）

# 首次调用需要编译，会明显较慢
function heavy_computation(n)
    s = 0.0
    for i in 1:n
        s += sin(i) * cos(i)
    end
    return s
end

# 首次调用 — 包含编译时间
@time heavy_computation(1_000_000)   # 编译 + 执行

# 后续调用 — 仅执行时间
@time heavy_computation(1_000_000)   # 纯执行

# 使用 @elapsed 精确测量
compile_time = @elapsed heavy_computation(1_000_000)
run_time = @elapsed heavy_computation(1_000_000)

println("编译时间: $(compile_time * 1000) ms")
println("执行时间: $(run_time * 1000) ms")

# 使用 @nospecialize 减少不必要的特化
function log_message(@nospecialize(msg))
    println("[LOG]: ", msg)
end

# 只会为 Any 类型编译一次
log_message("hello")
log_message(42)
log_message([1, 2, 3])

# 在包的主模块中声明预编译
module MyPackage

# Julia 1.8+ 自动启用预编译
# 也可以手动触发
function __init__()
    # 运行时初始化代码（不被预编译）
    println("Package loaded!")
end

end

using PrecompileTools

module MyPackage

@compile_workload begin
    # 这段代码在预编译时执行，结果会被缓存
    result = heavy_setup()
    process(result)
end

# 更精确的控制
@setup_workload begin
    config = load_config()

    @compile_workload begin
        compute(config, 100)
        compute(config, 200.0)
    end
end

end

using SnoopCompile

# 记录编译事件
tinf = @snoop_inference begin
    using MyPackage
    my_function(1, 2.0)
    my_function("hello", [1, 2])
end

# 分析哪些调用触发了编译
@show tinf
# 可以自动生成 precompile 语句

using PackageCompiler

# 创建包含常用包的系统镜像
create_sysimage(
    [:Plots, :DataFrames, :CSV],
    sysimage_path = "my_sysimage.so",
    precompile_execution_file = "precompile_workload.jl"
)

# 启动 Julia 时加载自定义镜像
# julia --sysimage my_sysimage.so

# 获取特化后的方法实例
f(x) = x^2
mi = first(methods(f))
println(mi)  # f(x) in Main at REPL[1]:1

# 查看方法的所有特化实例
# 需要在 Julia 调试版本中使用

using InteractiveUtils

# 列出所有已加载的方法
methodswith(String)

# 查看类型层次
typeof(1.0)
supertype(Float64)       # AbstractFloat
subtypes(AbstractFloat)  # [BigFloat, Float16, Float32, Float64]

# 查看变量占用的内存
x = rand(1000, 1000)
Base.summarysize(x)  # 8000000 字节 (约 7.6 MB)

# 查看全局变量的类型（全局变量性能杀手）
@code_warntype eval(:(global_var + 1))