diagnostic: Add method error diagnostic (inference/method-error)

This commit is certainly quite useful as it does find new errors,
but it's still difficult to identify where the errors are coming from,
and it's still noisy in the current state.
In particular, it even reports type instabilities in the code generated
by `@testset`, so I'm not sure what to do about it.

Author: aviatesk

docs/src/diagnostic.md

@@ -110,6 +110,7 @@ Here is a summary table of the diagnostics explained in this section:
 | [`inference/undef-global-var`](@ref diagnostic/reference/inference/undef-global-var)             | `Warning`             | `JETLS/save`  | References to undefined global variables           |
 | [`inference/field-error`](@ref diagnostic/reference/inference/field-error)                       | `Warning`             | `JETLS/save`  | Access to non-existent struct fields               |
 | [`inference/bounds-error`](@ref diagnostic/reference/inference/bounds-error)                     | `Warning`             | `JETLS/save`  | Out-of-bounds field access by index                |
+| [`inference/method-error`](@ref diagnostic/inference/method-error)                               | `Warning`             | No matching method found for function calls                       |
 | [`testrunner/test-failure`](@ref diagnostic/reference/testrunner/test-failure)                   | `Error`               | `JETLS/extra` | Test failures from TestRunner integration          |
 
 ### [Syntax diagnostic (`syntax/*`)](@id diagnostic/reference/syntax)
@@ -607,6 +608,34 @@ function bounds_error(tpl::Tuple{Int})
 end
 ```
 
+#### [Method error (`inference/method-error`)](@id diagnostic/inference/method-error)
+
+**Default severity:** `Warning`
+
+Function calls where no matching method can be found for the inferred argument
+types. This diagnostic detects potential `MethodError`s that would occur at
+runtime.
+
+Examples:
+
+```julia
+function method_error_example()
+    return sin(1, 2)  # no matching method found `sin(::Int64, ::Int64)` (JETLS inference/method-error)
+end
+```
+
+When multiple union-split signatures fail to find matches, the diagnostic will
+report all failed signatures:
+
+```julia
+only_int(x::Int) = 2x
+
+function union_split_method_error(x::Union{Int,String})
+    return only_int(x)  # no matching method found `only_int(::String)` (1/2 union split)
+                        # (JETLS inference/method-error)
+end
+```
+
 ### [TestRunner diagnostic (`testrunner/*`)](@id diagnostic/reference/testrunner)
 
 TestRunner diagnostics are reported when you manually run tests via code lens

src/analysis/Analyzer.jl

@@ -1,7 +1,7 @@
 module Analyzer
 
 export LSAnalyzer, inference_error_report_severity, inference_error_report_stack, reset_report_target_modules!
-export BoundsErrorReport, FieldErrorReport, UndefVarErrorReport
+export BoundsErrorReport, FieldErrorReport, MethodErrorReport, UndefVarErrorReport
 
 using Core.IR
 using JET.JETInterface
@@ -234,6 +234,29 @@ end # @static if VERSION ≥ v"1.12.2"
 # Analysis injections
 # ===================
 
+function CC.abstract_call_gf_by_type(
+        analyzer::LSAnalyzer, @nospecialize(func), arginfo::CC.ArgInfo, si::CC.StmtInfo,
+        @nospecialize(atype), sv::CC.InferenceState, max_methods::Int
+    )
+    ret = @invoke CC.abstract_call_gf_by_type(analyzer::ToplevelAbstractAnalyzer,
+        func::Any, arginfo::CC.ArgInfo, si::CC.StmtInfo, atype::Any, sv::CC.InferenceState, max_methods::Int)
+    if !should_analyze(analyzer, sv)
+        return ret
+    end
+    atype′ = Ref{Any}(atype)
+    function after_abstract_call_gf_by_type(analyzer′::LSAnalyzer, sv′::CC.InferenceState)
+        ret′ = ret[]
+        report_method_error!(analyzer′, sv′, ret′, arginfo, atype′[])
+        return true
+    end
+    if isready(ret)
+        after_abstract_call_gf_by_type(analyzer, sv)
+    else
+        push!(sv.tasks, after_abstract_call_gf_by_type)
+    end
+    return ret
+end
+
 # TODO Better to factor out and share it with `JET.JETAnalyzer`
 function CC.abstract_eval_globalref(
         analyzer::LSAnalyzer, g::GlobalRef, saw_latestworld::Bool, sv::CC.InferenceState;
@@ -469,6 +492,76 @@ function report_fieldaccess!(
     return true
 end
 
+# MethodErrorReport
+# -----------------
+
+@jetreport struct MethodErrorReport <: LSErrorReport
+    @nospecialize t # ::Union{Type, Vector{Type}}
+    union_split::Int
+end
+function JETInterface.print_report_message(io::IO, report::MethodErrorReport)
+    print(io, "no matching method found ")
+    if report.union_split == 0
+        print_callsig(io, report.t)
+    else
+        ts = report.t::Vector{Any}
+        nts = length(ts)
+        for i = 1:nts
+            print_callsig(io, ts[i])
+            i == nts || print(io, ", ")
+        end
+        print(io, " (", nts, '/', report.union_split, " union split)")
+    end
+end
+function print_callsig(io, @nospecialize(t))
+    print(io, '`')
+    Base.show_tuple_as_call(io, Symbol(""), t)
+    print(io, '`')
+end
+inference_error_report_stack_impl(r::MethodErrorReport) = length(r.vst):-1:1
+inference_error_report_severity_impl(::MethodErrorReport) = DiagnosticSeverity.Warning
+
+function report_method_error!(analyzer::LSAnalyzer,
+    sv::CC.InferenceState, call::CC.CallMeta, arginfo::CC.ArgInfo, @nospecialize(atype))
+    info = call.info
+    if isa(info, CC.ConstCallInfo)
+        info = info.call
+    end
+    if isa(info, CC.MethodMatchInfo)
+        report_method_error!(analyzer, sv, info, atype)
+    elseif isa(info, CC.UnionSplitInfo)
+        report_method_error_for_union_split!(analyzer, sv, info, arginfo)
+    end
+end
+
+function report_method_error!(analyzer::LSAnalyzer, sv::CC.InferenceState, info::CC.MethodMatchInfo, @nospecialize(atype))
+    if CC.isempty(info.results)
+        report = MethodErrorReport(sv, atype, 0)
+        add_new_report!(analyzer, sv.result, report)
+    end
+end
+
+function report_method_error_for_union_split!(analyzer::LSAnalyzer, sv::CC.InferenceState, info::CC.UnionSplitInfo, arginfo::CC.ArgInfo)
+    # check each match for union-split signature
+    split_argtypes = empty_matches = nothing
+    for (i, matchinfo) in enumerate(info.split)
+        if CC.isempty(matchinfo.results)
+            if isnothing(split_argtypes)
+                split_argtypes = CC.switchtupleunion(CC.typeinf_lattice(analyzer), arginfo.argtypes)
+            end
+            argtypes′ = split_argtypes[i]::Vector{Any}
+            if empty_matches === nothing
+                empty_matches = (Any[], length(info.split))
+            end
+            sig_n = CC.argtypes_to_type(argtypes′)
+            push!(empty_matches[1], sig_n)
+        end
+    end
+    if empty_matches !== nothing
+        add_new_report!(analyzer, sv.result, MethodErrorReport(sv, empty_matches...))
+    end
+end
+
 # Constructor
 # ===========
 

src/diagnostic.jl

@@ -423,6 +423,8 @@ function inference_error_report_code(@nospecialize report::JET.InferenceErrorRep
         return INFERENCE_FIELD_ERROR_CODE
     elseif report isa BoundsErrorReport
         return INFERENCE_BOUNDS_ERROR_CODE
+    elseif report isa MethodErrorReport
+        return INFERENCE_METHOD_ERROR_CODE
     end
     error(lazy"Diagnostic code is not defined for this report: $report")
 end

src/types.jl

@@ -398,6 +398,7 @@ const INFERENCE_UNDEF_GLOBAL_VAR_CODE = "inference/undef-global-var"
 const INFERENCE_UNDEF_STATIC_PARAM_CODE = "inference/undef-static-param" # currently not reported
 const INFERENCE_FIELD_ERROR_CODE = "inference/field-error"
 const INFERENCE_BOUNDS_ERROR_CODE = "inference/bounds-error"
+const INFERENCE_METHOD_ERROR_CODE = "inference/method-error"
 const TESTRUNNER_TEST_FAILURE_CODE = "testrunner/test-failure"
 
 const ALL_DIAGNOSTIC_CODES = Set{String}(String[
@@ -417,6 +418,7 @@ const ALL_DIAGNOSTIC_CODES = Set{String}(String[
     INFERENCE_UNDEF_STATIC_PARAM_CODE,
     INFERENCE_FIELD_ERROR_CODE,
     INFERENCE_BOUNDS_ERROR_CODE,
+    INFERENCE_METHOD_ERROR_CODE,
     TESTRUNNER_TEST_FAILURE_CODE,
 ])