Merge branch 'master' into envs

Author: pfitzseb

.github/pull_request_template.md

@@ -0,0 +1,5 @@
+Fixes #.
+
+For every PR, please check the following:
+- [ ] End-user documentation check. If this PR requires end-user documentation in the Julia VS Code extension docs, please add that at https://github.com/julia-vscode/docs.
+- [ ] Changelog mention. If this PR should be mentioned in the CHANGELOG for the Julia VS Code extension, please open a PR against https://github.com/julia-vscode/julia-vscode/blob/master/CHANGELOG.md with those changes.

.github/workflows/jlpkgbutler-ci-master-workflow.yml

@@ -10,7 +10,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        julia-version: ['1.0', '1.1', '1.2', '1.3', '1.4', '1.5']
+        julia-version: ['1.0', '1.1', '1.2', '1.3', '1.4', '1.5', '1.6']
         julia-arch: [x64, x86]
         os: [ubuntu-latest, windows-latest, macOS-latest]
         exclude:

.github/workflows/jlpkgbutler-ci-pr-workflow.yml

@@ -9,7 +9,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        julia-version: ['1.0', '1.1', '1.2', '1.3', '1.4', '1.5']
+        julia-version: ['1.0', '1.1', '1.2', '1.3', '1.4', '1.5', '1.6']
         julia-arch: [x64, x86]
         os: [ubuntu-latest, windows-latest, macOS-latest]
         exclude:

.github/workflows/jlpkgbutler-codeformat-pr-workflow.yml

@@ -12,7 +12,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: julia-actions/julia-codeformat@releases/v1
       - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v2
+        uses: peter-evans/create-pull-request@v3
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
           commit-message: Format files using DocumentFormat

src/StaticLint.jl

@@ -11,32 +11,11 @@ using SymbolServer: VarRef
 
 const noname = EXPR(:noname, nothing, nothing, 0, 0, nothing, nothing, nothing)
 
-baremodule CoreTypes # Convenience
-using ..SymbolServer
-using Base: ==, @static
-
-const DataType = SymbolServer.stdlibs[:Core][:DataType]
-const Function = SymbolServer.stdlibs[:Core][:Function]
-const Module = SymbolServer.stdlibs[:Core][:Module]
-const String = SymbolServer.stdlibs[:Core][:String]
-const Symbol = SymbolServer.stdlibs[:Core][:Symbol]
-const Int = SymbolServer.stdlibs[:Core][:Int]
-const Float64 = SymbolServer.stdlibs[:Core][:Float64]
-const Vararg = SymbolServer.FakeTypeName(Core.Vararg)
-
-isva(x::SymbolServer.FakeUnionAll) = isva(x.body)
-@static if Core.Vararg isa Core.Type
-    function isva(x)
-        return (x isa SymbolServer.FakeTypeName && x.name.name == :Vararg &&
-            x.name.parent isa SymbolServer.VarRef && x.name.parent.name == :Core)
-    end
-else
-    isva(x) = x isa SymbolServer.FakeTypeofVararg
-end
-end
-
+include("coretypes.jl")
 include("bindings.jl")
 include("scope.jl")
+include("subtypes.jl")
+include("methodmatching.jl")
 
 mutable struct Meta
     binding::Union{Nothing,Binding}
@@ -63,7 +42,7 @@ bindingof(m::Meta) = m.binding
 """
     ExternalEnv
 
-Holds a representation of an environment cached by SymbolServer. 
+Holds a representation of an environment cached by SymbolServer.
 """
 mutable struct ExternalEnv
     symbols::SymbolServer.EnvStore
@@ -93,7 +72,7 @@ function (state::Toplevel)(x::EXPR)
     s0 = scopes(x, state)
     resolve_ref(x, state)
     followinclude(x, state)
-    
+
     old_in_modified_expr = state.in_modified_expr
     if state.modified_exprs !== nothing && x in state.modified_exprs
         state.in_modified_expr = true
@@ -107,7 +86,7 @@ function (state::Toplevel)(x::EXPR)
     else
         traverse(x, state)
     end
-    
+
     state.in_modified_expr = old_in_modified_expr
     state.scope != s0 && (state.scope = s0)
     return state.scope
@@ -129,8 +108,9 @@ function (state::Delayed)(x::EXPR)
 
     traverse(x, state)
     if state.scope != s0
-        for (k, b) in state.scope.names
+        for b in values(state.scope.names)
             infer_type_by_use(b, state.env)
+            check_unused_binding(b, state.scope)
         end
         state.scope = s0
     end
@@ -173,9 +153,10 @@ function semantic_pass(file, modified_expr=nothing)
     state(getcst(file))
     for x in state.delayed
         if hasscope(x)
-            traverse(x, Delayed(scopeof(x), env, server)) 
+            traverse(x, Delayed(scopeof(x), env, server))
             for (k, b) in scopeof(x).names
                 infer_type_by_use(b, env)
+                check_unused_binding(b, scopeof(x))
             end
         else
             traverse(x, Delayed(retrieve_delayed_scope(x), env, server))
@@ -298,12 +279,21 @@ the path of the file to be included. Has limited support for `joinpath` calls.
 function get_path(x::EXPR, state)
     if CSTParser.iscall(x) && length(x.args) == 2
         parg = x.args[2]
+
         if CSTParser.isstringliteral(parg)
+            if occursin("\0", valof(parg))
+                seterror!(parg, IncludePathContainsNULL)
+                return ""
+            end
             path = CSTParser.str_value(parg)
             path = normpath(path)
             Base.containsnul(path) && throw(SLInvalidPath("Couldn't convert '$x' into a valid path. Got '$path'"))
             return path
         elseif CSTParser.ismacrocall(parg) && valof(parg.args[1]) == "@raw_str" && CSTParser.isstringliteral(parg.args[3])
+            if occursin("\0", valof(parg.args[3]))
+                seterror!(parg.args[3], IncludePathContainsNULL)
+                return ""
+            end
             path = normpath(CSTParser.str_value(parg.args[3]))
             Base.containsnul(path) && throw(SLInvalidPath("Couldn't convert '$x' into a valid path. Got '$path'"))
             return path
@@ -315,7 +305,11 @@ function get_path(x::EXPR, state)
                 if _is_macrocall_to_BaseDIR(arg) # Assumes @__DIR__ points to Base macro.
                     push!(path_elements, dirname(getpath(state.file)))
                 elseif CSTParser.isstringliteral(arg)
-                    push!(path_elements, string(valofid(arg)))
+                    if occursin("\0", valof(arg))
+                        seterror!(arg, IncludePathContainsNULL)
+                        return ""
+                    end
+                    push!(path_elements, string(valof(arg)))
                 else
                     return ""
                 end

src/bindings.jl

@@ -140,15 +140,29 @@ function mark_binding!(x::EXPR, val=x)
     return x
 end
 
-
-function mark_parameters(sig::EXPR)
-    signame = CSTParser.rem_where_subtype(sig)
-    if CSTParser.iscurly(signame)
-        for i = 2:length(signame.args)
-            mark_binding!(signame.args[i])
+function mark_parameters(sig::EXPR, params = String[])
+    if CSTParser.issubtypedecl(sig)
+        mark_parameters(sig.args[1], params)
+    elseif iswhere(sig)
+        for i = 2:length(sig.args)
+            x = mark_binding!(sig.args[i])
+            val = valof(bindingof(x).name)
+            if val isa String
+                push!(params, val)
+            end
+        end
+        mark_parameters(sig.args[1], params)
+    elseif CSTParser.iscurly(sig)
+        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 
+                x.meta.binding = nothing
+            end
         end
     end
-    return sig
+    sig
 end
 
 
@@ -231,18 +245,15 @@ function is_in_funcdef(x)
     end
 end
 
-function _in_func_def(x::EXPR)
+rem_wheres_subs_decls(x::EXPR) = (iswhere(x) || isdeclaration(x) || CSTParser.issubtypedecl(x)) ? rem_wheres_subs_decls(x.args[1]) : x
+
+function _in_func_or_struct_def(x::EXPR)
     # only called in :where
     # check 1st arg contains a call (or op call)
-    ex = CSTParser.rem_wheres_decls(x.args[1])
-
-    !(CSTParser.iscall(ex) || CSTParser.is_getfield(ex) || CSTParser.isunarycall(ex)) && return false
-
-    # check parent is func def
-    return is_in_funcdef(x)
+    ex = rem_wheres_subs_decls(x.args[1])
+    is_in_fexpr(x, CSTParser.defines_struct) || ((CSTParser.iscall(ex) || CSTParser.is_getfield(ex) || CSTParser.isunarycall(ex)) && is_in_funcdef(x))
 end
 
-
 """
     add_binding(x, state, scope=state.scope)
 
@@ -307,14 +318,22 @@ function add_binding(x, state, scope=state.scope)
                         # Mark as overloaded so that calls to `M.f()` resolve properly.
                         overload_method(tls, b, VarRef(lhs_ref.name, Symbol(name))) # Add to overloaded list but not scope.
                     end
-                elseif lhs_ref isa Binding && lhs_ref.type == CoreTypes.Module
+                elseif lhs_ref isa Binding && CoreTypes.ismodule(lhs_ref.type)
                     if hasscope(lhs_ref.val) && haskey(scopeof(lhs_ref.val).names, name)
                         # Don't need to do anything, name will resolve
                     end
                 end
             else
                 if scopehasbinding(tls, name)
-                    if tls.names[name] isa Binding && ((tls.names[name].type == CoreTypes.Function || tls.names[name].type == CoreTypes.DataType) || tls.names[name] isa SymbolServer.FunctionStore || tls.names[name] isa SymbolServer.DataTypeStore)
+
+                    existing_binding = tls.names[name]
+                    if existing_binding isa Binding && (existing_binding.val isa Binding || existing_binding.val isa SymbolServer.FunctionStore || existing_binding.val isa SymbolServer.DataTypeStore)
+                        # Should possibly be a while statement
+                        # If the .val is as above the Binding likely won't have a proper type attached
+                        # so lets use the .val instead.
+                        existing_binding = existing_binding.val
+                    end
+                    if (existing_binding isa Binding && ((CoreTypes.isfunction(existing_binding.type) || CoreTypes.isdatatype(existing_binding.type))) || existing_binding isa SymbolServer.FunctionStore || existing_binding isa SymbolServer.DataTypeStore)
                         # do nothing name of `x` will resolve to the root method
                     else
                         seterror!(x, CannotDefineFuncAlreadyHasValue)
@@ -333,7 +352,10 @@ function add_binding(x, state, scope=state.scope)
         elseif scopehasbinding(scope, name)
             # TODO: some checks about rebinding of consts
             check_const_decl(name, b, scope)
+
             scope.names[name] = b
+        elseif is_soft_scope(scope) && parentof(scope) isa Scope && isidentifier(b.name) && scopehasbinding(parentof(scope), valofid(b.name)) && !enforce_hard_scope(x, scope)
+            add_binding(x, state, scope.parent)
         else
             scope.names[name] = b
         end
@@ -343,6 +365,10 @@ function add_binding(x, state, scope=state.scope)
     end
 end
 
+function enforce_hard_scope(x::EXPR, scope)
+    scope.expr.head === :for && is_in_fexpr(x, x-> x == scope.expr.args[1])
+end
+
 name_is_getfield(x) = parentof(x) isa EXPR && parentof(parentof(x)) isa EXPR && CSTParser.is_getfield_w_quotenode(parentof(parentof(x)))
 
 
@@ -372,7 +398,7 @@ function mark_globals(x::EXPR, state)
 end
 
 function name_extends_imported_method(b::Binding)
-    if b.type == CoreTypes.Function && CSTParser.hasparent(b.name) && CSTParser.is_getfield(parentof(b.name))
+    if CoreTypes.isfunction(b.type) && CSTParser.hasparent(b.name) && CSTParser.is_getfield(parentof(b.name))
         if refof_maybe_getfield(parentof(b.name)[1]) !== nothing
 
         end

src/coretypes.jl

@@ -0,0 +1,47 @@
+baremodule CoreTypes # Convenience
+using ..SymbolServer
+using Base: ==, @static
+
+const Any = SymbolServer.stdlibs[:Core][:Any]
+const DataType = SymbolServer.stdlibs[:Core][:DataType]
+const Function = SymbolServer.stdlibs[:Core][:Function]
+const Module = SymbolServer.stdlibs[:Core][:Module]
+const String = SymbolServer.stdlibs[:Core][:String]
+const Char = SymbolServer.stdlibs[:Core][:Char]
+const Symbol = SymbolServer.stdlibs[:Core][:Symbol]
+const Bool = SymbolServer.stdlibs[:Core][:Bool]
+const Int = SymbolServer.stdlibs[:Core][:Int]
+const UInt8 = SymbolServer.stdlibs[:Core][:UInt8]
+const UInt16 = SymbolServer.stdlibs[:Core][:UInt16]
+const UInt32 = SymbolServer.stdlibs[:Core][:UInt32]
+const UInt64 = SymbolServer.stdlibs[:Core][:UInt64]
+const Float64 = SymbolServer.stdlibs[:Core][:Float64]
+const Vararg = SymbolServer.FakeTypeName(Core.Vararg)
+
+iscoretype(x, name) = false
+iscoretype(x::SymbolServer.VarRef, name) = x isa SymbolServer.DataTypeStore && x.name.name == name && x.name isa SymbolServer.VarRef && x.name.parent.name == :Core
+iscoretype(x::SymbolServer.DataTypeStore, name) = x isa SymbolServer.DataTypeStore && x.name.name.name == name && x.name.name isa SymbolServer.VarRef && x.name.name.parent.name == :Core
+isdatatype(x) = iscoretype(x, :DataType)
+isfunction(x) = iscoretype(x, :Function)
+ismodule(x) = iscoretype(x, :Module)
+isstring(x) = iscoretype(x, :String)
+ischar(x) = iscoretype(x, :Char)
+issymbol(x) = iscoretype(x, :Symbol)
+@static if Core.Int == Core.Int64
+    isint(x) = iscoretype(x, :Int64)
+else
+    isint(x) = iscoretype(x, :Int32)
+end
+isfloat(x) = iscoretype(x, :Float64)
+isvector(x) = iscoretype(x, :Vector)
+isarray(x) = iscoretype(x, :Array)
+isva(x::SymbolServer.FakeUnionAll) = isva(x.body)
+@static if Core.Vararg isa Core.Type
+    function isva(x)
+        return (x isa SymbolServer.FakeTypeName && x.name.name == :Vararg &&
+            x.name.parent isa SymbolServer.VarRef && x.name.parent.name == :Core)
+    end
+else
+    isva(x) = x isa SymbolServer.FakeTypeofVararg
+end
+end

src/imports.jl

@@ -1,4 +1,17 @@
 function resolve_import_block(x::EXPR, state::State, root, usinged, markfinal=true)
+    if x.head == :as
+        resolve_import_block(x.args[1], state, root, usinged, markfinal)
+        if x.args[2].meta === nothing
+            x.args[2].meta = Meta()
+        end
+        if hasbinding(last(x.args[1].args))
+            lhsbinding = bindingof(last(x.args[1].args))
+            x.args[2].meta.binding = Binding(x.args[2], lhsbinding.val, lhsbinding.type, lhsbinding.refs)
+            setref!(x.args[2], bindingof(x.args[2]))
+            last(x.args[1].args).meta.binding = nothing
+        end
+        return
+    end
     n = length(x.args)
     for i = 1:length(x.args)
         arg = x.args[i]
@@ -75,10 +88,13 @@ function add_to_imported_modules(scope::Scope, name::Symbol, val)
     if scope.modules isa Dict
         scope.modules[name] = val
     else
-        modules = Dict(name => val)
+        Dict(name => val)
     end
 end
 no_modules_above(s::Scope) = !CSTParser.defines_module(s.expr) || s.parent === nothing || no_modules_above(s.parent)
+function get_named_toplevel_module(s, name) 
+    return nothing
+end
 function get_named_toplevel_module(s::Scope, name::String)
     if CSTParser.defines_module(s.expr) 
         m_name = CSTParser.get_name(s.expr)

src/interface.jl

@@ -31,17 +31,17 @@ end
 """
     lint_file(rootpath, server)
 
-Read a file from disc, parse and run a semantic pass over it. The file should be the 
+Read a file from disc, parse and run a semantic pass over it. The file should be the
 root of a project, e.g. for this package that file is `src/StaticLint.jl`. Other files
 in the project will be loaded automatically (calls to `include` with complicated arguments
-are not handled, see `followinclude` for details). A `FileServer` will be returned 
+are not handled, see `followinclude` for details). A `FileServer` will be returned
 containing the `File`s of the package.
 """
 function lint_file(rootpath, server = setup_server(); gethints = false)
     empty!(server.files)
     root = loadfile(server, rootpath)
     semantic_pass(root)
-    for (p,f) in server.files
+    for f in values(server.files)
         check_all(f.cst, LintOptions(), getenv(f, server))
     end
     if gethints