try out JuliaLowering on 1.13

Project.toml

@@ -1,7 +1,7 @@
 name = "ExplicitImports"
 uuid = "7d51a73a-1435-4ff3-83d9-f097790105c7"
-authors = ["Eric P. Hanson"]
 version = "1.13.1"
+authors = ["Eric P. Hanson"]
 
 [deps]
 Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a"

src/ExplicitImports.jl

@@ -1,15 +1,20 @@
 module ExplicitImports
 
+MUST_USE_JULIA_LOWERING::Bool = true
+
 #! explicit-imports: off
 # We vendor some dependencies to avoid compatibility problems. We tell ExplicitImports to ignore
 # these as we don't want it to recurse into vendored dependencies.
 # We also add `Vendored` to `ignore_submodules` elsewhere.
 module Vendored
 include(joinpath("vendored", "JuliaSyntax", "src", "JuliaSyntax.jl"))
 include(joinpath("vendored", "AbstractTrees", "src", "AbstractTrees.jl"))
+include(joinpath("vendored", "JuliaLowering", "src", "JuliaLowering.jl"))
 end
 #! explicit-imports: on
 
+using .Vendored.JuliaLowering
+
 using .Vendored.JuliaSyntax
 # suppress warning about Base.parse collision, even though parse is never used
 # this avoids a warning when loading the package while creating an unused explicit import
@@ -23,8 +28,11 @@ using Markdown: Markdown
 using PrecompileTools: @setup_workload, @compile_workload
 using Pkg: Pkg
 
+# debug
+parsefile
+
 # we'll borrow their `@_public` macro; if this goes away, we can get our own
-JuliaSyntax.@_public ignore_submodules
+JuliaSyntax.@_public public ignore_submodules
 
 export print_explicit_imports, explicit_imports, check_no_implicit_imports,
        explicit_imports_nonrecursive
@@ -60,6 +68,7 @@ const STRICT_PRINTING_KWARG = """
 const STRICT_NONRECURSIVE_KWARG = """
 * `strict=true`: when `strict=true`, results will be `nothing` in the case that the analysis could not be performed accurately, due to e.g. dynamic `include` statements. When `strict=false`, results are returned in all cases, but may be inaccurate."""
 
+include("lower.jl")
 include("parse_utilities.jl")
 include("find_implicit_imports.jl")
 include("get_names_used.jl")
@@ -139,7 +148,7 @@ function explicit_imports(mod::Module, file=pathof(mod); skip=(mod, Base, Core),
     end
 
     submodules = find_submodules(mod, file)
-    fill_cache!(file_analysis, last.(submodules))
+    fill_cache!(file_analysis, last.(submodules), mod)
     return [submodule => explicit_imports_nonrecursive(submodule, path; skip, warn_stale,
                                                        file_analysis=file_analysis[path],
                                                        strict)
@@ -206,7 +215,7 @@ function explicit_imports_nonrecursive(mod::Module, file=pathof(mod);
                                        # deprecated
                                        warn_stale=nothing,
                                        # private undocumented kwarg for hoisting this analysis
-                                       file_analysis=get_names_used(file))
+                                       file_analysis=get_names_used(file, mod))
     check_file(file)
     if warn_stale !== nothing
         @warn "[explicit_imports_nonrecursive] keyword argument `warn_stale` is deprecated and does nothing" _id = :explicit_imports_explicit_imports_warn_stale maxlog = 1
@@ -402,10 +411,10 @@ function find_submodule_path(file, submodule)
     return path
 end
 
-function fill_cache!(file_analysis::Dict, files)
+function fill_cache!(file_analysis::Dict, files, mod)
     for _file in files
         if !haskey(file_analysis, _file)
-            file_analysis[_file] = get_names_used(_file)
+            file_analysis[_file] = get_names_used(_file, mod)
         end
     end
     return file_analysis
@@ -430,10 +439,10 @@ end
 
 include("precompile.jl")
 
-@setup_workload begin
-    @compile_workload begin
-        sprint(print_explicit_imports, ExplicitImports, @__FILE__; context=:color => true)
-    end
-end
+# @setup_workload begin
+#     @compile_workload begin
+#         sprint(print_explicit_imports, ExplicitImports, @__FILE__; context=:color => true)
+#     end
+# end
 
 end

src/deprecated.jl

@@ -3,7 +3,7 @@ function stale_explicit_imports(mod::Module, file=pathof(mod); strict=true)
     @warn "[stale_explicit_imports] deprecated in favor of `improper_explicit_imports`" _id = :explicit_imports_stale_explicit_imports maxlog = 1
     submodules = find_submodules(mod, file)
     file_analysis = Dict{String,FileAnalysis}()
-    fill_cache!(file_analysis, last.(submodules))
+    fill_cache!(file_analysis, last.(submodules), mod)
     return [submodule => stale_explicit_imports_nonrecursive(submodule, path;
                                                              file_analysis=file_analysis[path],
                                                              strict)
@@ -13,7 +13,7 @@ end
 function stale_explicit_imports_nonrecursive(mod::Module, file=pathof(mod);
                                              strict=true,
                                              # private undocumented kwarg for hoisting this analysis
-                                             file_analysis=get_names_used(file))
+                                             file_analysis=get_names_used(file, mod))
     check_file(file)
     @warn "[stale_explicit_imports_nonrecursive] deprecated in favor of `improper_explicit_imports_nonrecursive`" _id = :explicit_imports_stale_explicit_imports maxlog = 1
 

src/get_names_used.jl

@@ -13,7 +13,7 @@ Base.@kwdef struct PerUsageInfo
     function_arg::Bool
     is_assignment::Bool
     module_path::Vector{Symbol}
-    scope_path::Vector{JuliaSyntax.SyntaxNode}
+    scope_path::Vector{JuliaLowering.SyntaxTree}
     struct_field_or_type_param::Bool
     for_loop_index::Bool
     generator_index::Bool
@@ -345,31 +345,33 @@ function is_double_colon_LHS(leaf)
     return child_index(leaf) == 1
 end
 
+DEBUG = []
 # Here we use the magic of AbstractTrees' `TreeCursor` so we can start at
 # a leaf and follow the parents up to see what scopes our leaf is in.
 # TODO-someday- cleanup. This basically has two jobs: check is function arg etc, and figure out the scope/module path.
 # We could do these two things separately for more clarity.
-function analyze_name(leaf; debug=false)
+function analyze_name(leaf)
     # Ok, we have a "name". Let us work our way up and try to figure out if it is in local scope or not
     function_arg = is_function_definition_arg(leaf)
     struct_field_or_type_param = is_struct_type_param(leaf) || is_struct_field_name(leaf)
     for_loop_index = is_for_arg(leaf)
     generator_index = is_generator_arg(leaf)
     catch_arg = is_catch_arg(leaf)
     module_path = Symbol[]
-    scope_path = JuliaSyntax.SyntaxNode[]
+    scope_path = JuliaLowering.SyntaxTree[]
     is_assignment = false
+    is_global = false
     node = leaf
     idx = 1
-
+    # @show try_get_val(nodevalue(leaf))
+    # @show kind(nodevalue(get_parent(leaf, 1)))
+    push!(DEBUG, leaf)
     prev_node = nothing
     while true
         # update our state
-        val = get_val(node)
         k = kind(node)
-        args = nodevalue(node).node.raw.children
+        args = children(nodevalue(node).node)
 
-        debug && println(val, ": ", k)
         # Constructs that start a new local scope. Note `let` & `macro` *arguments* are not explicitly supported/tested yet,
         # but we can at least keep track of scope properly.
         if k in
@@ -389,7 +391,7 @@ function analyze_name(leaf; debug=false)
                 return kind(arg.node) == K"Identifier"
             end
             if !isempty(ids)
-                push!(module_path, first(ids).node.val)
+                push!(module_path, get_val(first(ids).node))
             end
             push!(scope_path, nodevalue(node).node)
         end
@@ -417,17 +419,17 @@ function analyze_name(leaf; debug=false)
 end
 
 """
-    analyze_all_names(file)
+    analyze_all_names(file, in_mod::Module)
 
 Returns a tuple of two items:
 
 * `per_usage_info`: a table containing information about each name each time it was used
 * `untainted_modules`: a set containing modules found and analyzed successfully
 """
-function analyze_all_names(file)
+function analyze_all_names(file, in_mod::Module)
     # we don't use `try_parse_wrapper` here, since there's no recovery possible
     # (no other files we know about to look at)
-    tree = SyntaxNodeWrapper(file)
+    tree = SyntaxNodeWrapper(file, in_mod)
     # in local scope, a name refers to a global if it is read from before it is assigned to, OR if the global keyword is used
     # a name refers to a local otherwise
     # so we need to traverse the tree, keeping track of state like: which scope are we in, and for each name, in each scope, has it been used
@@ -444,7 +446,7 @@ function analyze_all_names(file)
                                  function_arg::Bool,
                                  is_assignment::Bool,
                                  module_path::Vector{Symbol},
-                                 scope_path::Vector{JuliaSyntax.SyntaxNode},
+                                 scope_path::Vector{JuliaLowering.SyntaxTree},
                                  struct_field_or_type_param::Bool,
                                  for_loop_index::Bool,
                                  generator_index::Bool,
@@ -495,6 +497,7 @@ function analyze_all_names(file)
         end
         ret = analyze_name(leaf)
         push!(seen_modules, ret.module_path)
+        # @show name, qualified_by, import_type, explicitly_imported_by, location, ret
         push!(per_usage_info,
               (; name, qualified_by, import_type, explicitly_imported_by, location, ret...))
     end
@@ -532,7 +535,7 @@ end
 # in JuliaSyntax 1.0. This is very slow and also not quite the semantics we want anyway.
 # Here, we wrap our nodes in a custom type that only compares object identity.
 struct SyntaxNodeList
-    nodes::Vector{JuliaSyntax.SyntaxNode}
+    nodes::Vector{JuliaLowering.SyntaxTree}
 end
 
 function Base.:(==)(a::SyntaxNodeList, b::SyntaxNodeList)
@@ -648,18 +651,18 @@ function setdiff_no_metadata(set1, set2)
 end
 
 """
-    get_names_used(file) -> FileAnalysis
+    get_names_used(file, in_mod::Module) -> FileAnalysis
 
 Figures out which global names are used in `file`, and what modules they are used within.
 
 Traverses static `include` statements.
 
 Returns a `FileAnalysis` object.
 """
-function get_names_used(file)
+function get_names_used(file, in_mod::Module)
     check_file(file)
     # Here we get 1 row per name per usage
-    per_usage_info, untainted_modules = analyze_all_names(file)
+    per_usage_info, untainted_modules = analyze_all_names(file, in_mod)
 
     names_used_for_global_bindings = get_global_names(per_usage_info)
     explicit_imports = get_explicit_imports(per_usage_info)

src/improper_explicit_imports.jl

@@ -1,6 +1,6 @@
 function analyze_explicitly_imported_names(mod::Module, file=pathof(mod);
                                            # private undocumented kwarg for hoisting this analysis
-                                           file_analysis=get_names_used(file))
+                                           file_analysis=get_names_used(file, mod))
     check_file(file)
     (; per_usage_info, unnecessary_explicit_import, tainted) = filter_to_module(file_analysis,
                                                                                         mod)
@@ -174,7 +174,7 @@ function improper_explicit_imports_nonrecursive(mod::Module, file=pathof(mod);
                                                 strict=true,
                                                 allow_internal_imports=true,
                                                 # private undocumented kwarg for hoisting this analysis
-                                                file_analysis=get_names_used(file))
+                                                file_analysis=get_names_used(file, mod))
     check_file(file)
     problematic, tainted = analyze_explicitly_imported_names(mod, file; file_analysis)
 
@@ -255,7 +255,7 @@ function improper_explicit_imports(mod::Module, file=pathof(mod); strict=true,
     check_file(file)
     submodules = find_submodules(mod, file)
     file_analysis = Dict{String,FileAnalysis}()
-    fill_cache!(file_analysis, last.(submodules))
+    fill_cache!(file_analysis, last.(submodules), mod)
     return [submodule => improper_explicit_imports_nonrecursive(submodule, path; strict,
                                                                 file_analysis=file_analysis[path],
                                                                 skip,

src/improper_qualified_accesses.jl

@@ -3,7 +3,7 @@
 
 function analyze_qualified_names(mod::Module, file=pathof(mod);
                                  # private undocumented kwarg for hoisting this analysis
-                                 file_analysis=get_names_used(file))
+                                 file_analysis=get_names_used(file, mod))
     check_file(file)
     (; per_usage_info, tainted) = filter_to_module(file_analysis, mod)
     # Do we want to do anything with `tainted`? This means there is unanalyzable code here
@@ -128,7 +128,7 @@ function improper_qualified_accesses_nonrecursive(mod::Module, file=pathof(mod);
                                                   # deprecated, does nothing
                                                   require_submodule_access=nothing,
                                                   # private undocumented kwarg for hoisting this analysis
-                                                  file_analysis=get_names_used(file))
+                                                  file_analysis=get_names_used(file, mod))
     check_file(file)
     if require_submodule_access !== nothing
         @warn "[improper_qualified_accesses_nonrecursive] `require_submodule_access` is deprecated and unused" _id = :explicit_imports_improper_qualified_accesses_require_submodule_access maxlog = 1
@@ -229,7 +229,7 @@ function improper_qualified_accesses(mod::Module, file=pathof(mod);
     end
     submodules = find_submodules(mod, file)
     file_analysis = Dict{String,FileAnalysis}()
-    fill_cache!(file_analysis, last.(submodules))
+    fill_cache!(file_analysis, last.(submodules), mod)
     return [submodule => improper_qualified_accesses_nonrecursive(submodule, path;
                                                                   file_analysis=file_analysis[path],
                                                                   skip,