Revert "diagnostic: Add method error diagnostic (#169)" (08de28f)

Temporarily revert this new feature for cutting a new release.

Author: aviatesk

.JETLSConfig.toml

@@ -15,23 +15,6 @@ match_type = "regex"
 severity = "off"
 path = "LSP/src/LSP.jl"
 
-# TODO [JETLS]
-# `@interface` type instability for anonymous interface definitions
-[[diagnostic.patterns]]
-pattern = "no matching method found `.*var\"AnonymousInterface.*`"
-match_by = "message"
-match_type = "regex"
-severity = "off"
-path = "LSP/src/**/*.jl"
-
-# This is type instability within JSON3.jl
-[[diagnostic.patterns]]
-pattern = "no matching method found `convert(.+)`"
-match_by = "message"
-match_type = "regex"
-severity = "off"
-path = "src/testrunner/testrunner-types.jl"
-
 # TODO [JuliaLowering]
 # Temporarily downgrade some known JuliaLowering issues to information level
 [[diagnostic.patterns]]

CHANGELOG.md

@@ -47,12 +47,6 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ### Added
 
-- Added [`inference/method-error`](https://aviatesk.github.io/JETLS.jl/release/diagnostic/#diagnostic/inference/method-error)
-  diagnostic that detects function calls where no matching method exists for
-  the inferred argument types. This catches potential `MethodError`s that would
-  occur at runtime. For union-split calls, the diagnostic reports only the
-  failing branches with their count (e.g., "1/2 union split").
-
 - Anonymous function assignments (`f = (x) -> x + 1` and
   `clos = function (y) ... end`) are now analyzed as `Function` symbols
   for `textDocument/documentSymbol`, with their arguments as children.

README.md

@@ -61,7 +61,7 @@ the list itself is subject to change.
   - [x] Undefined bindings
   - [x] Non-existent struct fields
   - [x] Out-of-bounds field access by index
-  - [x] `MethodError`
+  - [ ] Potential `MethodError`
   - [x] Configuration support
   - [x] [CLI interface](https://aviatesk.github.io/JETLS.jl/release/cli-check)
 - Completion

docs/src/diagnostic.md

@@ -111,7 +111,6 @@ 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)
@@ -665,34 +664,6 @@ 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, MethodErrorReport, UndefVarErrorReport
+export BoundsErrorReport, FieldErrorReport, UndefVarErrorReport
 
 using Core.IR
 using JET.JETInterface
@@ -244,47 +244,6 @@ end # @static if VERSION ≥ v"1.12.2"
 # Analysis injections
 # ===================
 
-# function is_from_kwcall(analyzer, sv)
-#     report_target_modules = @something analyzer.report_target_modules return false
-#     checkbounds(Bool, sv.callstack, sv.parentid) || return false
-#     sv = sv.callstack[sv.parentid]
-#     checkbounds(Bool, sv.callstack, sv.parentid) || return false
-#     sv = sv.callstack[sv.parentid]
-#     mi = CC.frame_instance(sv)
-#     def = mi.def
-#     def isa Method || return false
-#     sig = Base.unwrap_unionall(def.sig)
-#     sig isa DataType || return false
-#     length(sig.parameters) >= 1 || return false
-#     sig.parameters[1] === typeof(Core.kwcall) || return false
-#     checkbounds(Bool, sv.callstack, sv.parentid) || return false
-#     sv = sv.callstack[sv.parentid]
-#     return CC.frame_module(sv) ∈ report_target_modules
-# end
-
-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;
@@ -520,84 +479,6 @@ 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

@@ -419,8 +419,6 @@ 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

@@ -399,7 +399,6 @@ 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[
@@ -420,7 +419,6 @@ 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,
 ])
 

test/analysis/test_Analyzer.jl

@@ -99,47 +99,6 @@ end
     end
 end
 
-only_int(x::Int) = 2x
-
-@testset "MethodErrorReport" begin
-    # no report when method exists
-    let result = analyze_call((Int,)) do x
-            sin(x)
-        end
-        @test isempty(get_reports(result))
-    end
-
-    # basic method error
-    let result = analyze_call() do
-            sin(1, 2)
-        end
-        reports = get_reports(result)
-        @test length(reports) == 1
-        r = only(reports)
-        @test r isa MethodErrorReport && r.union_split == 0
-    end
-
-    # union split case: only one branch fails
-    let result = analyze_call((Union{Int,String},)) do x
-            only_int(x)
-        end
-        reports = get_reports(result)
-        @test length(reports) == 1
-        r = only(reports)
-        @test r isa MethodErrorReport && r.union_split == 2 && length(r.t) == 1
-    end
-
-    # union split case: all branches fail
-    let result = analyze_call((Union{String,Symbol},)) do x
-            only_int(x)
-        end
-        reports = get_reports(result)
-        @test length(reports) == 1
-        r = only(reports)
-        @test r isa MethodErrorReport && r.union_split == 2 && length(r.t) == 2
-    end
-end
-
 @testset "BoundsError analysis" begin
     # `getindex(::Tuple, ::Int)`
     let result = analyze_call((Tuple{Int},)) do tpl1
@@ -301,21 +260,6 @@ end
         end
         @test isempty(get_reports(result))
     end
-
-    # MethodErrorReport
-    let result = analyze_call(; report_target_modules=(@__MODULE__,)) do
-            sin(1, 2)
-        end
-        reports = get_reports(result)
-        @test length(reports) == 1
-        r = only(reports)
-        @test r isa MethodErrorReport
-    end
-    let result = analyze_call(; report_target_modules=(ExternalModule,)) do
-            sin(1, 2)
-        end
-        @test isempty(get_reports(result))
-    end
 end
 
 end # module test_LSAnalyzer