fix: tweak type handling to work on 1.12

Author: pfitzseb

src/bindings.jl

@@ -19,7 +19,7 @@ Binding(name, val, type, refs) = Binding(name, val, type, refs, false)
 function Base.show(io::IO, b::Binding)
     printstyled(io, " Binding(", to_codeobject(b.name),
         b.is_public ? "ᵖ" : "",
-        b.type === nothing ? "" : "::($(b.type))",
+        b.type === nothing ? "" : "::($(b.type.name))",
         b.refs isa Vector ? " ($(length(b.refs)) refs))" : ")", color=:blue)
 end
 

src/linting/checks.jl

@@ -431,15 +431,15 @@ end
 
 function check_nothing_equality(x::EXPR, env::ExternalEnv)
     if isbinarycall(x) && length(x.args) == 3
-        nothings = (getsymbols(env)[:Core][:nothing], getsymbols(env)[:Base][:nothing])
+        _nothing = getsymbols(env)[:Core][:nothing]
         if valof(x.args[1]) == "==" && (
-                (valof(x.args[2]) == "nothing" && refof(x.args[2]) in nothings) ||
-                (valof(x.args[3]) == "nothing" && refof(x.args[3]) in nothings)
+                (valof(x.args[2]) == "nothing" && refof(x.args[2]) == _nothing) ||
+                (valof(x.args[3]) == "nothing" && refof(x.args[3]) == _nothing)
             )
             seterror!(x.args[1], NothingEquality)
         elseif valof(x.args[1]) == "!=" && (
-                (valof(x.args[2]) == "nothing" && refof(x.args[2]) in nothings) ||
-                (valof(x.args[3]) == "nothing" && refof(x.args[3]) in nothings)
+                (valof(x.args[2]) == "nothing" && refof(x.args[2]) == _nothing) ||
+                (valof(x.args[3]) == "nothing" && refof(x.args[3]) == _nothing)
             )
             seterror!(x.args[1], NothingNotEq)
         end
@@ -512,7 +512,9 @@ function is_never_datatype(b::Binding, env::ExternalEnv)
     elseif CoreTypes.isdatatype(b.type)
         return false
     elseif b.type !== nothing
-        return true
+        if !any(x -> x isa SymbolServer.DataTypeStore, get_eventual_datatype(ref, env) for ref in b.refs)
+            return true
+        end
     end
     return false
 end
@@ -878,7 +880,7 @@ UInt64, UInt128`.
 """
 function check_kw_default(x::EXPR, env::ExternalEnv)
     if headof(x) == :kw && isdeclaration(x.args[1]) && CSTParser.isliteral(x.args[2]) && hasref(x.args[1].args[2])
-        decl_T = refof(x.args[1].args[2])
+        decl_T = get_eventual_datatype(refof(x.args[1].args[2]), env)
         rhs = x.args[2]
         rhsval = valof(rhs)
         if decl_T == getsymbols(env)[:Core][:String] && !CSTParser.isstringliteral(rhs)

src/type_inf.jl

@@ -37,11 +37,11 @@ function infer_type_assignment_rhs(binding, state, scope)
     lhs = binding.val.args[1]
     rhs = binding.val.args[2]
     if is_loop_iter_assignment(binding.val)
-        settype!(binding, infer_eltype(rhs))
+        settype!(binding, infer_eltype(rhs, state))
     elseif headof(rhs) === :ref && length(rhs.args) > 1
         ref = refof_maybe_getfield(rhs.args[1])
         if ref isa Binding && ref.val isa EXPR
-            settype!(binding, infer_eltype(ref.val))
+            settype!(binding, infer_eltype(ref.val, state))
         end
     else
         if CSTParser.is_func_call(rhs)
@@ -147,11 +147,20 @@ function infer_type_decl(binding, state, scope)
         else
             settype!(binding, refof(t))
         end
-    elseif refof(t) isa SymbolServer.DataTypeStore
-        settype!(binding, refof(t))
+    else
+        edt = get_eventual_datatype(refof(t), state.server.external_env)
+        if edt !== nothing
+            settype!(binding, edt)
+        end
     end
 end
 
+get_eventual_datatype(_, _::ExternalEnv) = nothing
+get_eventual_datatype(b::SymbolServer.DataTypeStore, _::ExternalEnv) = b
+function get_eventual_datatype(b::SymbolServer.FunctionStore, env::ExternalEnv)
+    return SymbolServer._lookup(b.extends, getsymbols(env))
+end
+
 # Work out what type a bound variable has by functions that are called on it.
 function infer_type_by_use(b::Binding, env::ExternalEnv)
     b.type !== nothing && return # b already has a type
@@ -284,19 +293,22 @@ end
 # Assumes x.head.val == "="
 is_loop_iter_assignment(x::EXPR) = x.parent isa EXPR && ((x.parent.head == :for || x.parent.head == :generator) || (x.parent.head == :block && x.parent.parent isa EXPR && (x.parent.parent.head == :for || x.parent.parent.head == :generator)))
 
-function infer_eltype(x::EXPR)
+function infer_eltype(x::EXPR, state)
     if isidentifier(x) && hasref(x) # assume is IDENT
         r = refof(x)
         if r isa Binding && r.val isa EXPR
             if isassignment(r.val) && r.val.args[2] != x
-                return infer_eltype(r.val.args[2])
+                return infer_eltype(r.val.args[2], state)
             end
         end
     elseif headof(x) === :ref && hasref(x.args[1])
         r = refof(x.args[1])
-        if r isa SymbolServer.DataTypeStore ||
-            r isa Binding && CoreTypes.isdatatype(r.type)
-            r
+        if r isa Binding && CoreTypes.isdatatype(r.type)
+            return r
+        end
+        edt = get_eventual_datatype(r, state.server.external_env)
+        if edt isa SymbolServer.DataTypeStore
+            return edt
         end
     elseif headof(x) === :STRING
         return CoreTypes.Char

test/runtests.jl

@@ -2188,7 +2188,7 @@ end
             end
 
             end""")
-            @test refof(cst.args[1].args[3].args[3].args[3].args[2]) !== nothing
+            @test refof(cst.args[1].args[3].args[3].args[1]) !== nothing
             @test refof(cst.args[1].args[3].args[4].args[1]).is_public
             @test StaticLint.refof(cst.args[1].args[3].args[5].args[3].args[3].args[2].args[1]).is_public
         end