[DO NOT MERGE] Improving local Lint disabling, per rule

src/interface.jl

@@ -172,11 +172,32 @@ function filter_and_print_hint(hint_as_string::String, io::IO=stdout, filters::V
     # +1 is because CSTParser gives offset starting at 0.
     offset = Base.parse(Int64, offset_as_string) + 1
 
-    line_number, column, annotation_line = convert_offset_to_line_from_filename(offset, filename)
+    # Remove the offset from the result. No need for this.
+    cleaned_hint = replace(hint_as_string, (" at offset $offset_as_string of" => ""))
+    try
+        line_number, column, annotation_line = convert_offset_to_line_from_filename(offset, filename)
+
+        # isdefined(Man, :Infiltrator) && Main.infiltrate(@__MODULE__, Base.@locals, @__FILE__, @__LINE__)
+        local error_type
+        cleaned_hint_without_filename = cleaned_hint[1:end-length(filename)-1]
+        if !(cleaned_hint_without_filename in keys(error_msg2type))
+            error_type = string(StaticLint.error_msg2type[cleaned_hint_without_filename])
+        else
+            error_type = nothing
+        end
 
-    if isnothing(annotation_line)
-        print_hint(formatter, io, "Line $(line_number), column $(column):", hint_as_string)
-        return true
+        function typestring_from_annotation(annotation::String)
+            isnothing(annotation) && return nothing
+            contains(annotation, ":") || return nothing
+            return split(annotation, ":")[2]
+        end
+        if isnothing(annotation_line) || typestring_from_annotation(annotation_line) !== error_type
+            print_hint(formatter, io, "Line $(line_number), column $(column):", cleaned_hint)
+            return true
+        end
+    catch e
+        # isdefined(Main, :Infiltrator) && Main.infiltrate(@__MODULE__, Base.@locals, @__FILE__, @__LINE__)
+        @error "Cannot retreive offset=$offset in file $filename error=$e"
     end
     return false
 end

src/linting/checks.jl

@@ -113,6 +113,10 @@ LintOptions(options::Vararg{Union{Bool,Nothing},length(default_options)}) =
     LintOptions(something.(options, default_options)...)
 
 
+function fetch_value(x::SymbolServer.VarRef, tag::Symbol)
+    return x.name
+end
+
 function fetch_value(x::EXPR, tag::Symbol)
     if headof(x) == tag
         return x.val
@@ -136,14 +140,21 @@ function check_all(x::EXPR, opts::LintOptions, env::ExternalEnv, markers::Dict{S
         markers[:function] = fetch_value(x, :IDENTIFIER)
     end
 
+    if headof(x) === :macrocall
+        id = fetch_value(x, :IDENTIFIER)
+        if !isnothing(id)
+            markers[:macrocall] = id
+        end
+    end
+
     # Do checks
     opts.call && check_call(x, env)
     opts.iter && check_loop_iter(x, env)
     opts.nothingcomp && check_nothing_equality(x, env)
     opts.constif && check_if_conds(x)
     opts.lazy && check_lazy(x)
     opts.datadecl && check_datatype_decl(x, env)
-    opts.typeparam && check_typeparams(x)
+    opts.typeparam && check_typeparams(x, markers)
     opts.modname && check_modulename(x)
     opts.pirates && check_for_pirates(x)
     opts.useoffuncargs && check_farg_unused(x)
@@ -167,6 +178,7 @@ function check_all(x::EXPR, opts::LintOptions, env::ExternalEnv, markers::Dict{S
     # Do some cleaning
     headof(x) === :const && delete!(markers, :const)
     headof(x) === :function && delete!(markers, :function)
+    headof(x) === :macrocall && delete!(markers, :macrocall)
 end
 
 function _typeof(x, state)
@@ -341,7 +353,18 @@ function check_call(x, env::ExternalEnv)
         tls = retrieve_toplevel_scope(x)
         tls === nothing && return @warn "Couldn't get top-level scope." # General check, this means something has gone wrong.
         func_ref === nothing && return
-        !sig_match_any(func_ref, x, call_counts, tls, env) && seterror!(x, IncorrectCallArgs)
+        if !sig_match_any(func_ref, x, call_counts, tls, env)
+            if func_ref.name isa SymbolServer.VarRef &&
+                !isnothing(func_ref.name.parent) &&
+                func_ref.name.parent.name == :Base &&
+                !isnothing(func_ref.name.name)
+
+                func_ref.name.name in [:copy] && return
+            end
+            function_name = fetch_value(func_ref.name, :IDENTIFIER)
+            function_name in ["delete!", "copy", "copy!", "write", "hash", "iterate"] && return
+            seterror!(x, "Possible method call error: $(function_name).")
+        end
     end
 end
 
@@ -778,7 +801,10 @@ end
 
 isunionfaketype(t::SymbolServer.FakeTypeName) = t.name.name === :Union && t.name.parent isa SymbolServer.VarRef && t.name.parent.name === :Core
 
-function check_typeparams(x::EXPR)
+function check_typeparams(x::EXPR, markers::Dict{Symbol,String})
+    haskey(markers, :macrocall) && markers[:macrocall] == "@match" && return
+    haskey(markers, :macrocall) && markers[:macrocall] == "@matchrule" && return
+
     if iswhere(x)
         for i in 2:length(x.args)
             a = x.args[i]