Merge branch 'master' into sp/large-file-limit

Author: pfitzseb

src/StaticLint.jl

@@ -17,7 +17,7 @@ include("scope.jl")
 include("subtypes.jl")
 include("methodmatching.jl")
 
-const LARGE_FILE_LIMIT = 1_000_000 # bytes
+const LARGE_FILE_LIMIT = 2_000_000 # bytes
 
 mutable struct Meta
     binding::Union{Nothing,Binding}
@@ -229,6 +229,20 @@ function traverse(x::EXPR, state)
     end
 end
 
+function check_filesize(x, path)
+    nb = try
+        filesize(path)
+    catch
+        seterror!(x, FileNotAvailable)
+        return false
+    end
+
+    toobig = nb > LARGE_FILE_LIMIT
+    if toobig
+        seterror!(x, FileTooBig)
+    end
+    return !toobig
+end
 
 """
     followinclude(x, state)
@@ -247,7 +261,11 @@ function followinclude(x, state::State)
         elseif isabspath(path)
             if hasfile(state.server, path)
             elseif canloadfile(state.server, path)
-                loadfile(state.server, path)
+                if check_filesize(x, path)
+                    loadfile(state.server, path)
+                else
+                    return
+                end
             else
                 path = ""
             end
@@ -257,7 +275,11 @@ function followinclude(x, state::State)
                 path = joinpath(dirname(getpath(state.file)), path)
             elseif canloadfile(state.server, joinpath(dirname(getpath(state.file)), path))
                 path = joinpath(dirname(getpath(state.file)), path)
-                loadfile(state.server, path)
+                if check_filesize(x, path)
+                    loadfile(state.server, path)
+                else
+                    return
+                end
             else
                 path = ""
             end
@@ -280,6 +302,7 @@ function followinclude(x, state::State)
                 return
             end
             f = getfile(state.server, path)
+
             if f.cst.fullspan > LARGE_FILE_LIMIT
                 seterror!(x, FileTooBig)
                 return

src/linting/checks.jl

@@ -31,7 +31,8 @@
     DuplicateFuncArgName,
     IncludePathContainsNULL,
     IndexFromLength,
-    FileTooBig
+    FileTooBig,
+    FileNotAvailable,
 )
 
 const LintCodeDescriptions = Dict{LintCodes,String}(
@@ -65,6 +66,7 @@ const LintCodeDescriptions = Dict{LintCodes,String}(
     IncludePathContainsNULL => "Cannot include file, path contains NULL characters.",
     IndexFromLength => "Indexing with indices obtained from `length`, `size` etc is discouraged. Use `eachindex` or `axes` instead.",
     FileTooBig => "File too big, not following include.",
+    FileNotAvailable => "File not available."
 )
 
 haserror(m::Meta) = m.error !== nothing
@@ -554,12 +556,15 @@ function check_farg_unused(x::EXPR)
 end
 
 function check_farg_unused_(arg, arg_names)
-    if hasbinding(arg)
-    elseif iskwarg(arg) && hasbinding(arg.args[1])
-        arg = arg.args[1]
-    elseif is_nospecialize_call(arg) && hasbinding(unwrap_nospecialize(arg))
-        arg = unwrap_nospecialize(arg)
-    else
+    if !hasbinding(arg)
+        if iskwarg(arg)
+            arg = arg.args[1]
+        end
+        if is_nospecialize_call(arg)
+            arg = unwrap_nospecialize(arg)
+        end
+    end
+    if !hasbinding(arg)
         return false
     end
     b = bindingof(arg)

src/type_inf.jl

@@ -33,6 +33,8 @@ function infer_type(binding::Binding, scope, state)
 end
 
 function infer_type_assignment_rhs(binding, state, scope)
+    is_destructuring = false
+    lhs = binding.val.args[1]
     rhs = binding.val.args[2]
     if is_loop_iter_assignment(binding.val)
         settype!(binding, infer_eltype(rhs))
@@ -43,13 +45,24 @@ function infer_type_assignment_rhs(binding, state, scope)
         end
     else
         if CSTParser.is_func_call(rhs)
+            if CSTParser.istuple(lhs)
+                if CSTParser.isparameters(lhs.args[1])
+                    is_destructuring = true
+                else
+                    return
+                end
+            end
             callname = CSTParser.get_name(rhs)
             if isidentifier(callname)
                 resolve_ref(callname, scope, state)
                 if hasref(callname)
                     rb = get_root_method(refof(callname), state.server)
                     if (rb isa Binding && (CoreTypes.isdatatype(rb.type) || rb.val isa SymbolServer.DataTypeStore)) || rb isa SymbolServer.DataTypeStore
-                        settype!(binding, rb)
+                        if is_destructuring
+                            infer_destructuring_type(binding, rb)
+                        else
+                            settype!(binding, rb)
+                        end
                     end
                 end
             end
@@ -94,6 +107,26 @@ function infer_type_assignment_rhs(binding, state, scope)
     end
 end
 
+function infer_destructuring_type(binding, rb::SymbolServer.DataTypeStore)
+    assigned_name = CSTParser.get_name(binding.val)
+    for (fieldname, fieldtype) in zip(rb.val.fieldnames, rb.val.types)
+        if fieldname == assigned_name
+            settype!(binding, fieldtype)
+            return
+        end
+    end
+end
+function infer_destructuring_type(binding::Binding, rb::EXPR)
+    assigned_name = string(to_codeobject(binding.name))
+    scope = scopeof(rb)
+    names = scope.names
+    if haskey(names, assigned_name)
+        b = names[assigned_name]
+        settype!(binding, b.type)
+    end
+end
+infer_destructuring_type(binding, rb::Binding) = infer_destructuring_type(binding, rb.val)
+
 function infer_type_decl(binding, state, scope)
     t = binding.val.args[2]
     if isidentifier(t)

test/runtests.jl

@@ -187,10 +187,11 @@ f(arg) = arg
             @test StaticLint.CoreTypes.ismodule(bindingof(parse_and_pass("module A end").args[1]).type)
             @test StaticLint.CoreTypes.ismodule(bindingof(parse_and_pass("baremodule A end").args[1]).type)
 
-    # @test parse_and_pass("function f(x::Int) x end")[1][2][3].binding.t == StaticLint.getsymbolserver(server)["Core"].vals["Function"]
+            # @test parse_and_pass("function f(x::Int) x end")[1][2][3].binding.t == StaticLint.getsymbolserver(server)["Core"].vals["Function"]
             let cst = parse_and_pass("""
         struct T end
-        function f(x::T) x end""")
+                    function f(x::T) x end
+                    """)
                 @test StaticLint.CoreTypes.isdatatype(bindingof(cst.args[1]).type)
                 @test StaticLint.CoreTypes.isfunction(bindingof(cst.args[2]).type)
                 @test bindingof(cst.args[2].args[1].args[2]).type == bindingof(cst.args[1])
@@ -199,7 +200,8 @@ f(arg) = arg
             let cst = parse_and_pass("""
         struct T end
         T() = 1
-        function f(x::T) x end""")
+                function f(x::T) x end
+                """)
                 @test StaticLint.CoreTypes.isdatatype(bindingof(cst.args[1]).type)
                 @test StaticLint.CoreTypes.isfunction(bindingof(cst.args[3]).type)
                 @test bindingof(cst.args[3].args[1].args[2]).type == bindingof(cst.args[1])
@@ -208,7 +210,8 @@ f(arg) = arg
 
             let cst = parse_and_pass("""
         struct T end
-        t = T()""")
+                t = T()
+                """)
                 @test StaticLint.CoreTypes.isdatatype(bindingof(cst.args[1]).type)
                 @test bindingof(cst.args[2].args[1]).type == bindingof(cst.args[1])
             end
@@ -222,7 +225,8 @@ f(arg) = arg
         import ..B
         B.x
         end
-        end""")
+                end
+                """)
                 @test refof(cst.args[1].args[3].args[2].args[3].args[2].args[2].args[1]) == bindingof(cst[1].args[3].args[1].args[3].args[1].args[1])
             end
 
@@ -235,7 +239,8 @@ f(arg) = arg
         end
         function f(arg::T1)
             arg.field.x
-        end""");
+                end
+                """);
                 @test refof(cst.args[3].args[2].args[1].args[1].args[1]) == bindingof(cst.args[3].args[1].args[2])
                 @test refof(cst.args[3].args[2].args[1].args[1].args[2].args[1]) == bindingof(cst.args[2].args[3].args[1])
                 @test refof(cst.args[3].args[2].args[1].args[2].args[1]) == bindingof(cst.args[1].args[3].args[1])
@@ -246,9 +251,9 @@ f(arg) = arg
             end
 
             let cst = parse_and_pass("""
-        macro mac_str() end
-        mac"whatever"
-        """)
+                macro mac_str() end
+                mac"whatever"
+                """)
                 @test refof(cst.args[2].args[1]) == bindingof(cst.args[1])
             end
 
@@ -261,50 +266,50 @@ f(arg) = arg
             end
 
             let cst = parse_and_pass("""
-        module Reparse
-        end
-        using .Reparse, CSTParser
-        """)
+                module Reparse
+                end
+                using .Reparse, CSTParser
+                """)
                 @test refof(cst.args[2].args[1].args[2]).val == bindingof(cst[1])
             end
 
             let cst = parse_and_pass("""
-        module A
-        A
-        end
-        """)
+                module A
+                A
+                end
+                """)
                 @test scopeof(cst).names["A"] == scopeof(cst.args[1]).names["A"]
                 @test refof(cst.args[1].args[2]) == bindingof(cst.args[1])
                 @test refof(cst.args[1].args[3].args[1]) == bindingof(cst.args[1])
             end
-    # let cst = parse_and_pass("""
-    #     using Test: @test
-    #     """)
-    #     @test bindingof(cst[1][4]) !== nothing
-    # end
+            # let cst = parse_and_pass("""
+            #     using Test: @test
+            #     """)
+            #     @test bindingof(cst[1][4]) !== nothing
+            # end
             let cst = parse_and_pass("""
-        sin(1,2,3)
-        """)
+            sin(1,2,3)
+            """)
                 @test errorof(cst.args[1]) === StaticLint.IncorrectCallArgs
             end
             let cst = parse_and_pass("""
-        for i in length(1) end
-        for i in 1.1 end
-        for i in 1 end
-        for i in 1:1 end
-        """)
+                for i in length(1) end
+                for i in 1.1 end
+                for i in 1 end
+                for i in 1:1 end
+                """)
                 @test errorof(cst.args[1].args[1]) === StaticLint.IncorrectIterSpec
                 @test errorof(cst.args[2].args[1]) === StaticLint.IncorrectIterSpec
                 @test errorof(cst.args[3].args[1]) === StaticLint.IncorrectIterSpec
                 @test errorof(cst.args[4].args[1]) === nothing
             end
 
             let cst = parse_and_pass("""
-        [i for i in length(1) end]
-        [i for i in 1.1 end]
-        [i for i in 1 end]
-        [i for i in 1:1 end]
-        """)
+                [i for i in length(1) end]
+                [i for i in 1.1 end]
+                [i for i in 1 end]
+                [i for i in 1:1 end]
+                """)
                 @test errorof(cst[1][2][3]) === StaticLint.IncorrectIterSpec
                 @test errorof(cst[2][2][3]) === StaticLint.IncorrectIterSpec
                 @test errorof(cst[3][2][3]) === StaticLint.IncorrectIterSpec
@@ -319,29 +324,44 @@ f(arg) = arg
             end
 
             let cst = parse_and_pass("""
-        struct Graph
-            children:: T
-        end
+                struct Graph
+                    children:: T
+                end
 
-        function test()
-            g = Graph()
-            f = g.children
-        end""")
+                function test()
+                    g = Graph()
+                    f = g.children
+                end""")
                 @test cst.args[2].args[2].args[2].args[2].args[2].args[1] in bindingof(cst.args[1].args[3].args[1]).refs
             end
 
             let cst = parse_and_pass("""
-        __source__
-        __module__
-        macro m()
-            __source__
-            __module__
-        end""")
+                __source__
+                __module__
+                macro m()
+                    __source__
+                    __module__
+                end""")
                 @test refof(cst[1]) === nothing
                 @test refof(cst[2]) === nothing
                 @test refof(cst[3][3][1]) !== nothing
                 @test refof(cst[3][3][2]) !== nothing
             end
+
+            let cst = parse_and_pass("""
+                struct Foo
+                    x::DataType
+                    y::Float64
+                end
+                (;x, y) = Foo(1,2)
+                x
+                y
+                """)
+                mx = cst.args[3].meta
+                @test mx.ref.type.name.name.name == :DataType
+                my = cst.args[4].meta
+                @test my.ref.type.name.name.name == :Float64
+            end
         end
 
         @testset "macros" begin
@@ -1351,9 +1371,13 @@ f(arg) = arg
     @testset "issue 1609" begin
         let
             cst1 = parse_and_pass("function g(@nospecialize(x), y) x + y end")
-            cst2 = parse_and_pass("function g(@nospecialize(x), y) y end")
+            cst2 = parse_and_pass("function g(@nospecialize(x) = 1) x end")
+            cst3 = parse_and_pass("function g(@nospecialize(x) = 1, y = 2) x + y end")
+            cst4 = parse_and_pass("function g(@nospecialize(x), y) y end")
             @test !StaticLint.haserror(cst1.args[1].args[1].args[2].args[3])
-            @test StaticLint.haserror(cst2.args[1].args[1].args[2].args[3])
+            @test !StaticLint.haserror(cst2.args[1].args[1].args[2].args[1])
+            @test !StaticLint.haserror(cst3.args[1].args[1].args[2].args[1])
+            @test StaticLint.haserror(cst4.args[1].args[1].args[2].args[3])
         end
     end