Merge pull request #251 from julia-vscode/envs

add infrastructure for file-specific environments

Author: davidanthoff

src/StaticLint.jl

@@ -38,6 +38,18 @@ hasscope(m::Meta) = m.scope isa Scope
 scopeof(m::Meta) = m.scope
 bindingof(m::Meta) = m.binding
 
+
+"""
+    ExternalEnv
+
+Holds a representation of an environment cached by SymbolServer.
+"""
+mutable struct ExternalEnv
+    symbols::SymbolServer.EnvStore
+    extended_methods::Dict{SymbolServer.VarRef,Vector{SymbolServer.VarRef}}
+    project_deps::Vector{Symbol}
+end
+
 abstract type State end
 mutable struct Toplevel{T} <: State
     file::T
@@ -47,6 +59,7 @@ mutable struct Toplevel{T} <: State
     modified_exprs::Union{Nothing,Vector{EXPR}}
     delayed::Vector{EXPR}
     resolveonly::Vector{EXPR}
+    env::ExternalEnv
     server
 end
 
@@ -59,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
@@ -73,14 +86,15 @@ 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
 end
 
 mutable struct Delayed <: State
     scope::Scope
+    env::ExternalEnv
     server
 end
 
@@ -95,8 +109,8 @@ function (state::Delayed)(x::EXPR)
     traverse(x, state)
     if state.scope != s0
         for b in values(state.scope.names)
-            infer_type_by_use(b, state.server)
-            check_unused_binding(b, state.scope)    
+            infer_type_by_use(b, state.env)
+            check_unused_binding(b, state.scope)
         end
         state.scope = s0
     end
@@ -105,6 +119,7 @@ end
 
 mutable struct ResolveOnly <: State
     scope::Scope
+    env::ExternalEnv
     server
 end
 
@@ -132,26 +147,27 @@ Performs a semantic pass across a project from the entry point `file`. A first p
 """
 function semantic_pass(file, modified_expr=nothing)
     server = file.server
-    setscope!(getcst(file), Scope(nothing, getcst(file), Dict(), Dict{Symbol,Any}(:Base => getsymbolserver(server)[:Base], :Core => getsymbolserver(server)[:Core]), nothing))
-    state = Toplevel(file, [getpath(file)], scopeof(getcst(file)), modified_expr === nothing, modified_expr, EXPR[], EXPR[], server)
+    env = getenv(file, server)
+    setscope!(getcst(file), Scope(nothing, getcst(file), Dict(), Dict{Symbol,Any}(:Base => env.symbols[:Base], :Core => env.symbols[:Core]), nothing))
+    state = Toplevel(file, [getpath(file)], scopeof(getcst(file)), modified_expr === nothing, modified_expr, EXPR[], EXPR[], env, server)
     state(getcst(file))
     for x in state.delayed
         if hasscope(x)
-            traverse(x, Delayed(scopeof(x), server)) 
-            for b in values(scopeof(x).names)
-                infer_type_by_use(b, state.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), server))
+            traverse(x, Delayed(retrieve_delayed_scope(x), env, server))
         end
     end
     if state.resolveonly !== nothing
         for x in state.resolveonly
             if hasscope(x)
-                traverse(x, ResolveOnly(scopeof(x), server))
+                traverse(x, ResolveOnly(scopeof(x), env, server))
             else
-                traverse(x, ResolveOnly(retrieve_delayed_scope(x), server))
+                traverse(x, ResolveOnly(retrieve_delayed_scope(x), env, server))
             end
         end
     end
@@ -263,7 +279,7 @@ 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)

src/bindings.jl

@@ -300,7 +300,7 @@ function add_binding(x, state, scope=state.scope)
                 lhs_ref = refof_maybe_getfield(parentof(parentof(b.name)).args[1])
                 if lhs_ref isa SymbolServer.ModuleStore && haskey(lhs_ref.vals, Symbol(name))
                     # Overloading
-                    if haskey(tls.names, name) && eventually_overloads(tls.names[name], lhs_ref.vals[Symbol(name)], state.server)
+                    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) 
                             setref!(b.name, tls.names[name]) # Add ref to previous overload
@@ -311,7 +311,7 @@ function add_binding(x, state, scope=state.scope)
                         # Name is already available
                         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.server))
+                            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
                         end
                     else
@@ -373,13 +373,13 @@ name_is_getfield(x) = parentof(x) isa EXPR && parentof(parentof(x)) isa EXPR &&
 
 
 """
-eventually_overloads(b, x, server)
+eventually_overloads(b, x, state)
 
 
 """
-eventually_overloads(b::Binding, ss::SymbolServer.SymStore, server) = b.val == ss || (b.refs !== nothing && length(b.refs) > 0 && first(b.refs) == ss)
-eventually_overloads(b::Binding, ss::SymbolServer.VarRef, server) = eventually_overloads(b, maybe_lookup(ss, server), server)
-eventually_overloads(b, ss, server) = false
+eventually_overloads(b::Binding, ss::SymbolServer.SymStore, state) = b.val == ss || (b.refs !== nothing && length(b.refs) > 0 && first(b.refs) == ss)
+eventually_overloads(b::Binding, ss::SymbolServer.VarRef, state) = eventually_overloads(b, maybe_lookup(ss, state), state)
+eventually_overloads(b, ss, state) = false
 
 isglobal(name, scope) = false
 isglobal(name::String, scope) = scope !== nothing && scopehasbinding(scope, "#globals") && name in scope.names["#globals"].refs

src/imports.jl

@@ -17,15 +17,15 @@ function resolve_import_block(x::EXPR, state::State, root, usinged, markfinal=tr
         arg = x.args[i]
         if isoperator(arg) && valof(arg) == "."
             # Leading dots. Can only be leading elements.
-            if root == getsymbolserver(state.server)
+            if root == getsymbols(state)
                 root = state.scope
             elseif root isa Scope && parentof(root) !== nothing
                 root = parentof(root)
             else
                 return
             end
         elseif isidentifier(arg) || (i == n && (CSTParser.ismacroname(arg) || isoperator(arg)))
-            root = maybe_lookup(hasref(arg) ? refof(arg) : _get_field(root, arg, state), state.server)
+            root = maybe_lookup(hasref(arg) ? refof(arg) : _get_field(root, arg, state), state)
             setref!(arg, root)
             if i == n
                 markfinal && _mark_import_arg(arg, root, state, usinged)
@@ -37,7 +37,7 @@ function resolve_import_block(x::EXPR, state::State, root, usinged, markfinal=tr
     end
 end
 
-function resolve_import(x::EXPR, state::State, root=getsymbolserver(state.server))
+function resolve_import(x::EXPR, state::State, root=getsymbols(state))
     if headof(x) === :using || headof(x) === :import
         usinged = headof(x) === :using
         if length(x.args) > 0 && isoperator(headof(x.args[1])) && valof(headof(x.args[1])) == ":"
@@ -50,9 +50,6 @@ function resolve_import(x::EXPR, state::State, root=getsymbolserver(state.server
                 resolve_import_block(x.args[i], state, root, usinged)
             end
         end
-        for i = 1:length(x.args)
-            resolve_import_block(x.args[i], state, root, usinged)
-        end
     end
 end
 
@@ -62,7 +59,7 @@ function _mark_import_arg(arg, par, state, usinged)
             push!(par.refs, arg)
         end
         if par isa SymbolServer.VarRef
-            par = SymbolServer._lookup(par, getsymbolserver(state.server), true)
+            par = SymbolServer._lookup(par, getsymbols(state), true)
             !(par isa SymbolServer.SymStore) && return
         end
         if bindingof(arg) === nothing
@@ -116,20 +113,22 @@ function _get_field(par, arg, state)
         if (arg_scope = retrieve_scope(arg)) !== nothing && (tlm = get_named_toplevel_module(arg_scope, arg_str_rep)) !== nothing && hasbinding(tlm)
             return bindingof(tlm)
         elseif haskey(par, Symbol(arg_str_rep))
-            return par[Symbol(arg_str_rep)]
+            if isempty(state.env.project_deps) || Symbol(arg_str_rep) in state.env.project_deps
+                return par[Symbol(arg_str_rep)]
+            end
         end
     elseif par isa SymbolServer.ModuleStore # imported module
         if Symbol(arg_str_rep) === par.name.name
             return par
         elseif haskey(par, Symbol(arg_str_rep))
             par = par[Symbol(arg_str_rep)]
             if par isa SymbolServer.VarRef # reference to dependency
-                return SymbolServer._lookup(par, getsymbolserver(state.server), true)
+                return SymbolServer._lookup(par, getsymbols(state), true)
             end
             return par
         end
         for used_module_name in par.used_modules
-            used_module = maybe_lookup(par[used_module_name], state.server)
+            used_module = maybe_lookup(par[used_module_name], state)
             if used_module !== nothing && isexportedby(Symbol(arg_str_rep), used_module)
                 return used_module[Symbol(arg_str_rep)]
             end
@@ -140,7 +139,7 @@ function _get_field(par, arg, state)
         elseif par.modules !== nothing
             for used_module in values(par.modules)
                 if used_module isa SymbolServer.ModuleStore && isexportedby(Symbol(arg_str_rep), used_module)
-                    return maybe_lookup(used_module[Symbol(arg_str_rep)], state.server)
+                    return maybe_lookup(used_module[Symbol(arg_str_rep)], state)
                 elseif used_module isa Scope && scope_exports(used_module, arg_str_rep, state)
                     return used_module.names[arg_str_rep]
                 end

src/interface.jl

@@ -15,13 +15,14 @@ it is paired with a collected list of errors/hints.
 """
 function lint_string(s::String, server = setup_server(); gethints = false)
     empty!(server.files)
-    f = StaticLint.File("", s, CSTParser.parse(s, true), nothing, server)
-    StaticLint.setroot(f, f)
-    StaticLint.setfile(server, "", f)
-    StaticLint.semantic_pass(f)
-    StaticLint.check_all(f.cst, StaticLint.LintOptions(), server)
+    f = File("", s, CSTParser.parse(s, true), nothing, server)
+    env = getenv(f, server)
+    setroot(f, f)
+    setfile(server, "", f)
+    semantic_pass(f)
+    check_all(f.cst, LintOptions(), env)
     if gethints
-        return f.cst, [(x, string(haserror(x) ? LintCodeDescriptions[x.meta.error] : "Missing reference", " at offset ", offset)) for (offset, x) in collect_hints(f.cst, server)]
+        return f.cst, [(x, string(haserror(x) ? LintCodeDescriptions[x.meta.error] : "Missing reference", " at offset ", offset)) for (offset, x) in collect_hints(f.cst, env)]
     else
         return f.cst
     end
@@ -30,23 +31,23 @@ 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 = StaticLint.loadfile(server, rootpath)
-    StaticLint.semantic_pass(root)
+    root = loadfile(server, rootpath)
+    semantic_pass(root)
     for f in values(server.files)
-        StaticLint.check_all(f.cst, StaticLint.LintOptions(), server)
+        check_all(f.cst, LintOptions(), getenv(f, server))
     end
     if gethints
         hints = []
         for (p,f) in server.files
-            append!(hints, [(x, string(haserror(x) ? LintCodeDescriptions[x.meta.error] : "Missing reference", " at offset ", offset, " of ", p)) for (offset, x) in collect_hints(f.cst, server)])
+            append!(hints, [(x, string(haserror(x) ? LintCodeDescriptions[x.meta.error] : "Missing reference", " at offset ", offset, " of ", p)) for (offset, x) in collect_hints(f.cst, getenv(f, server))])
         end
         return root, hints
     else