Merge pull request #290 from julia-vscode/sp/no-macrocall-linting

disable non-at-eval macrocall linting

Author: davidanthoff

src/bindings.jl

@@ -59,6 +59,8 @@ function mark_bindings!(x::EXPR, state)
             mark_sig_args!(x.args[1])
         elseif CSTParser.iscurly(x.args[1])
             mark_typealias_bindings!(x)
+        elseif is_in_noneval_macrocall(x.args[1])
+            return
         elseif !is_getfield(x.args[1])
             mark_binding!(x.args[1], x)
         end
@@ -156,8 +158,8 @@ function mark_parameters(sig::EXPR, params = String[])
         for i = 2:length(sig.args)
             x = mark_binding!(sig.args[i])
             if bindingof(x) isa Binding && valof(bindingof(x).name) in params
-                # Don't mark a new binding if a parameter has already been 
-                # introduced from a :where 
+                # Don't mark a new binding if a parameter has already been
+                # introduced from a :where
                 x.meta.binding = nothing
             end
         end
@@ -259,7 +261,7 @@ end
 
 Add the binding of `x` to the current scope. Special handling is required for:
 * macros: to prefix the `@`
-* functions: These are added to the top-level scope unless this syntax is used to define a closure within a function. If a function with the same name already exists in the scope then it is not replaced. This enables the `refs` list of the Binding of that 'root method' to hold a method table, the name of the new function will resolve to the binding of the root method (to get a list of actual methods -`[get_method(ref) for ref in binding.refs if get_method(ref) !== nothing]`). For example 
+* functions: These are added to the top-level scope unless this syntax is used to define a closure within a function. If a function with the same name already exists in the scope then it is not replaced. This enables the `refs` list of the Binding of that 'root method' to hold a method table, the name of the new function will resolve to the binding of the root method (to get a list of actual methods -`[get_method(ref) for ref in binding.refs if get_method(ref) !== nothing]`). For example
 ```julia
 [1] f() = 1
 [2] f(x) = 2
@@ -302,14 +304,14 @@ function add_binding(x, state, scope=state.scope)
                     # Overloading
                     if haskey(tls.names, name) && eventually_overloads(tls.names[name], lhs_ref.vals[Symbol(name)], state)
                         # Though we're explicitly naming a function for overloading, it has already been imported to the toplevel scope.
-                        if !hasref(b.name) 
+                        if !hasref(b.name)
                             setref!(b.name, tls.names[name]) # Add ref to previous overload
                             overload_method(tls, b, VarRef(lhs_ref.name, Symbol(name)))
                         end
                         # Do nothing, get_name(x) will resolve to the root method
                     elseif isexportedby(name, lhs_ref)
                         # Name is already available
-                        tls.names[name] = b 
+                        tls.names[name] = b
                         if !hasref(b.name) # Is this an appropriate indicator that we've not marked the overload?
                             push!(b.refs, maybe_lookup(lhs_ref[Symbol(name)], state))
                             setref!(b.name, b) # we actually set the rhs of the qualified name to point to this binding

src/linting/checks.jl

@@ -554,7 +554,8 @@ function collect_hints(x::EXPR, env, missingrefs=:all, isquoted=false, errs=Tupl
     elseif !isquoted
         if missingrefs != :none && isidentifier(x) && !hasref(x) &&
             !(valof(x) == "var" && parentof(x) isa EXPR && isnonstdid(parentof(x))) &&
-            !((valof(x) == "stdcall" || valof(x) == "cdecl" || valof(x) == "fastcall" || valof(x) == "thiscall" || valof(x) == "llvmcall") && is_in_fexpr(x, x -> iscall(x) && isidentifier(x.args[1]) && valof(x.args[1]) == "ccall"))
+            !((valof(x) == "stdcall" || valof(x) == "cdecl" || valof(x) == "fastcall" || valof(x) == "thiscall" || valof(x) == "llvmcall") && is_in_fexpr(x, x -> iscall(x) && isidentifier(x.args[1]) && valof(x.args[1]) == "ccall")) &&
+            !is_in_noneval_macrocall(x)
 
             push!(errs, (pos, x))
         elseif haserror(x) && errorof(x) isa StaticLint.LintCodes
@@ -904,6 +905,12 @@ function is_sig_arg(x)
     is_in_fexpr(x, CSTParser.iscall)
 end
 
+function is_in_noneval_macrocall(x)
+    macrocall = maybe_get_parent_fexpr(x, x -> x.head === :macrocall && valof(x.args[1]) != "@eval")
+    return macrocall !== nothing
+end
+
+
 function is_overwritten_in_loop(x)
     # Cuts out false positives for check_unused_binding - the linear nature of our
     # semantic passes mean a variable declared at the end of a loop's block but used at

test/runtests.jl

@@ -1744,3 +1744,14 @@ end
     @test isempty(StaticLint.collect_hints(cst, server))
 
 end
+
+
+@testset "macrocall bindings: #2187" begin
+    cst = parse_and_pass("""
+    function f()
+        @info "Downloading" source = url dest = file
+        return nothing
+    end
+    """)
+    @test isempty(StaticLint.collect_hints(cst, server))
+end