avoid making variables for constant numbers

CSEin constants makes variables much more connected to each other than they are in reality making it harder to decouplt them into e.g. separate functions at a later stage

Author: KristofferC

src/faster_code.jl

@@ -56,7 +56,7 @@ mutable struct CodegenState{T}
     In such a case, if we assume that the index of `x + y` in `ir` is `4`, then
     `cache[4] == Symbol("%3")`.
     """
-    const cache::Dictionary{Int32, Symbol}
+    const cache::Dictionary{Int32, Union{Symbol, Int, Float64, Float32}}
     """
     Rewrite rules, similar to `NameState`.
     """
@@ -78,7 +78,7 @@ written to `block` and `ir` is the underlying `IRStructure`. Rewrite rules can o
 be supplied as the last argument.
 """
 function CodegenState(expr::Expr, block::Expr, ir::IRStructure{T}, rewrites = Dict()) where {T}
-    CodegenState{T}(expr, block, ir, Dictionary{Int32, Symbol}(), rewrites, 0)
+    CodegenState{T}(expr, block, ir, Dictionary{Int32, Union{Symbol, Int, Float64, Float32}}(), rewrites, 0)
 end
 
 """
@@ -199,7 +199,7 @@ function enter_scope(cs::CodegenState{T}) where {T}
     new_scope = Expr(:block)
     bm = bookmark(cs)
     scoped_cs = CodegenState{T}(new_scope, new_scope, cs.ir, cs.cache, cs.rewrites, cs.misc_idx)
-    
+
     return scoped_cs, bm
 end
 
@@ -312,7 +312,10 @@ end
 function fast_toexpr(sym::CodegenPrimitive, ir::IRStructure{T}, rewrites::Dict{Any, Any}) where {T}
     expr = block = Expr(:block)
     state = CodegenState(expr, block, ir, rewrites)
-    lhs = state(sym)::Symbol
+    lhs = state(sym)
+    if !(lhs isa Symbol)
+        return lhs
+    end
     for line in expr.args
         if Meta.isexpr(line, :(=)) && line.args[1] === lhs
             return line.args[2]
@@ -535,7 +538,7 @@ function codegen_function!(::Type{ArrayMaker{T}}, cs::CodegenState{T}, expr::Bas
         end
         return declare!(cs, get_misc_identifier(cs), result)
     end
-    
+
     if _allocator !== zeros && !__allocator_is_returns_expr(T, _allocator) &&
             isequal(regions[1], sh) && __is_fill_zero(cs.ir[first(values_exprs_idxs)])
         output_buffer = codegen_allocator_call!(
@@ -853,7 +856,7 @@ end
 
 function codegen_ir!(cs::CodegenState{T}, idx::Integer) where {T}
     cached = get(cs.cache, idx, nothing)
-    if cached isa Symbol
+    if cached !== nothing
         return cached
     end
     ir = cs.ir
@@ -875,6 +878,9 @@ function codegen_ir!(cs::CodegenState{T}, idx::Integer) where {T}
     @match sym begin
         BSImpl.Const(; val) => if val isa CodegenPrimitive
             return cs(val)
+        elseif val isa Union{Int, Float64, Float32}
+            insert!(cs.cache, idx, val)
+            return val
         else
             return codegen!(cs, idx, val)
         end
@@ -933,10 +939,13 @@ function (cs::CodegenState)(@nospecialize(thing))
     if uthing !== thing
         return cs(uthing)
     end
+    if thing isa Union{Int, Float64, Float32}
+        return thing
+    end
     return declare!(cs, get_misc_identifier(cs), thing)
 end
 
-function (cs::CodegenState)(expr::BasicSymbolic{T})::Symbol where {T}
+function (cs::CodegenState)(expr::BasicSymbolic{T}) where {T}
     idx = populate_ir!(cs.ir, expr)
     codegen_ir!(cs, idx)
 end
@@ -1070,9 +1079,9 @@ function (cs::CodegenState{T})(fn::Func) where {T}
 end
 
 function (cs::CodegenState)(ex::SetArray)
-    arr = cs(ex.arr)::Symbol
+    arr = cs(ex.arr)::Union{Symbol, Int, Float64, Float32}
     lhss = []
-    rhss = Symbol[]
+    rhss = Union{Symbol, Int, Float64, Float32}[]
     for (i, elem) in enumerate(ex.elems)
         if elem isa AtIndex
             push!(lhss, cs(elem.i))