improved IR

NEWS.md

@@ -47,6 +47,13 @@ Compiler/Runtime improvements
 Breaking changes
 ----------------
 
+  * Local variables and arguments are represented in lowered code as numbered `Slot`
+    objects instead of as symbols ([#15609]).
+
+  * The information that used to be in the `ast` field of the `LambdaStaticData` type
+    is now divided among the fields `code`, `slotnames`, `slottypes`, `slotflags`,
+    `gensymtypes`, `rettype`, `nargs`, and `isva` in the `LambdaInfo` type ([#15609]).
+
 Library improvements
 --------------------
 
@@ -173,3 +180,4 @@ Deprecated or removed
 [#15242]: https://github.com/JuliaLang/julia/issues/15242
 [#15258]: https://github.com/JuliaLang/julia/issues/15258
 [#15550]: https://github.com/JuliaLang/julia/issues/15550
+[#15609]: https://github.com/JuliaLang/julia/issues/15609

base/boot.jl

@@ -139,8 +139,8 @@ export
     InterruptException, OutOfMemoryError, ReadOnlyMemoryError, OverflowError,
     StackOverflowError, SegmentationFault, UndefRefError, UndefVarError, TypeError,
     # AST representation
-    Expr, GotoNode, LabelNode, LineNumberNode, QuoteNode, SymbolNode, TopNode,
-    GlobalRef, NewvarNode, GenSym,
+    Expr, GotoNode, LabelNode, LineNumberNode, QuoteNode, TopNode,
+    GlobalRef, NewvarNode, GenSym, Slot,
     # object model functions
     fieldtype, getfield, setfield!, nfields, throw, tuple, is, ===, isdefined, eval,
     # sizeof    # not exported, to avoid conflicting with Base.sizeof
@@ -217,12 +217,6 @@ type TypeError <: Exception
     got
 end
 
-type SymbolNode
-    name::Symbol
-    typ
-    SymbolNode(name::Symbol, t::ANY) = new(name, t)
-end
-
 abstract DirectIndexString <: AbstractString
 
 immutable ASCIIString <: DirectIndexString
@@ -283,11 +277,13 @@ _new(typ::Symbol, argty::Symbol) = eval(:((::Type{$typ})(n::$argty) = $(Expr(:ne
 _new(:LabelNode, :Int)
 _new(:GotoNode, :Int)
 _new(:TopNode, :Symbol)
-_new(:NewvarNode, :Symbol)
+_new(:NewvarNode, :Slot)
 _new(:QuoteNode, :ANY)
 _new(:GenSym, :Int)
 eval(:((::Type{LineNumberNode})(f::Symbol, l::Int) = $(Expr(:new, :LineNumberNode, :f, :l))))
 eval(:((::Type{GlobalRef})(m::Module, s::Symbol) = $(Expr(:new, :GlobalRef, :m, :s))))
+eval(:((::Type{Slot})(n::Int) = $(Expr(:new, :Slot, :n, Any))))
+eval(:((::Type{Slot})(n::Int, t::ANY) = $(Expr(:new, :Slot, :n, :t))))
 
 Module(name::Symbol=:anonymous, std_imports::Bool=true) = ccall(:jl_f_new_module, Any, (Any, Bool), name, std_imports)::Module
 

base/essentials.jl

@@ -125,6 +125,10 @@ function precompile(f::ANY, args::Tuple)
     ccall(:jl_compile_hint, Void, (Any,), Tuple{Core.Typeof(f), args...})
 end
 
+function precompile(argt::Type)
+    ccall(:jl_compile_hint, Void, (Any,), argt)
+end
+
 esc(e::ANY) = Expr(:escape, e)
 
 macro boundscheck(blk)

base/expr.jl

@@ -35,16 +35,16 @@ copy(e::Expr) = (n = Expr(e.head);
                  n.args = astcopy(e.args);
                  n.typ = e.typ;
                  n)
-copy(s::SymbolNode) = SymbolNode(s.name, s.typ)
+copy(s::Slot) = Slot(s.id, s.typ)
 
 # copy parts of an AST that the compiler mutates
-astcopy(x::Union{SymbolNode,Expr}) = copy(x)
+astcopy(x::Union{Slot,Expr}) = copy(x)
 astcopy(x::Array{Any,1}) = Any[astcopy(a) for a in x]
 astcopy(x) = x
 
 ==(x::Expr, y::Expr) = x.head === y.head && x.args == y.args
 ==(x::QuoteNode, y::QuoteNode) = x.value == y.value
-==(x::SymbolNode, y::SymbolNode) = x.name === y.name && x.typ === y.typ
+==(x::Slot, y::Slot) = x.id === y.id && x.typ === y.typ
 
 expand(x) = ccall(:jl_expand, Any, (Any,), x)
 macroexpand(x) = ccall(:jl_macroexpand, Any, (Any,), x)
@@ -133,7 +133,7 @@ end
 
 function popmeta!(body::Expr, sym::Symbol)
     body.head == :block || return false, []
-    found, metaex = findmeta_block(body)
+    found, metaex = findmeta_block(body.args)
     if !found
         return false, []
     end
@@ -151,23 +151,29 @@ function popmeta!(body::Expr, sym::Symbol)
     false, []
 end
 popmeta!(arg, sym) = (false, [])
+function popmeta!(body::Array{Any,1}, sym::Symbol)
+    ex = Expr(:block); ex.args = body
+    popmeta!(ex, sym)
+end
 
 function findmeta(ex::Expr)
     if ex.head == :function || (ex.head == :(=) && typeof(ex.args[1]) == Expr && ex.args[1].head == :call)
         body::Expr = ex.args[2]
         body.head == :block || error(body, " is not a block expression")
-        return findmeta_block(ex)
+        return findmeta_block(ex.args)
     end
     error(ex, " is not a function expression")
 end
 
-function findmeta_block(ex::Expr)
-    for a in ex.args
+findmeta(ex::Array{Any,1}) = findmeta_block(ex)
+
+function findmeta_block(exargs)
+    for a in exargs
         if isa(a, Expr)
             if (a::Expr).head == :meta
                 return true, a::Expr
             elseif (a::Expr).head == :block
-                found, exb = findmeta_block(a)
+                found, exb = findmeta_block(a.args)
                 if found
                     return found, exb
                 end

base/hashing.jl

@@ -63,7 +63,7 @@ else
 end
 
 hash(x::QuoteNode, h::UInt) = hash(x.value, hash(QuoteNode, h))
-hash(x::SymbolNode, h::UInt) = hash(x.name, hash(x.typ, hash(SymbolNode, h)))
+hash(x::Slot, h::UInt) = hash(x.id, hash(x.typ, hash(Slot, h)))
 
 # hashing ranges by component at worst leads to collisions for very similar ranges
 const hashr_seed = UInt === UInt64 ? 0x80707b6821b70087 : 0x21b70087