Merge pull request #921 from timholy/avi/simple-non-jl

remove the interface to support non .jl files

Author: aviatesk

Project.toml

@@ -1,6 +1,6 @@
 name = "Revise"
 uuid = "295af30f-e4ad-537b-8983-00126c2a3abe"
-version = "3.7.6"
+version = "3.8.0"
 
 [deps]
 CodeTracking = "da1fd8a2-8d9e-5ec2-8556-3022fb5608a2"

docs/src/dev_reference.md

@@ -152,15 +152,3 @@ Revise.git_repo
 ```@docs
 Revise.init_worker
 ```
-
-## Teaching Revise about non-julia source codes
-Revise can be made to work for transpilers from non-Julia languages to Julia with a little effort.
-For example, if you wrote a transpiler from C to Julia, you can define a `struct CFile`
-which overrides enough of the common `String` methods (`abspath`,`isabspath`, `joinpath`, `normpath`,`isfile`,`findfirst`, and `String`),
-it will be supported by Revise if you define a method like
-```julia
-function Revise.parse_source!(mod_exprs_sigs::Revise.ModuleExprsSigs, file::CFile, mod::Module; kwargs...)
-    ex = # julia Expr returned from running transpiler
-    Revise.process_source!(mod_exprs_sigs, ex, file, mod; kwargs...)
-end
-```

src/callbacks.jl

@@ -30,8 +30,6 @@ Global variable, maps callback keys to user hooks.
 """
 const user_callbacks_by_key = Dict{Any, Any}()
 
-
-
 """
     key = Revise.add_callback(f, files, modules=nothing; key=gensym())
 

src/packagedef.jl

@@ -537,13 +537,13 @@ end
 init_watching(files) = init_watching(pkgdatas[NOPACKAGE], files)
 
 """
-    revise_dir_queued(dirname)
+    revise_dir_queued(dirname::AbstractString)
 
 Wait for one or more of the files registered in `Revise.watched_files[dirname]` to be
 modified, and then queue the corresponding files on [`Revise.revision_queue`](@ref).
 This is generally called via a [`Revise.TaskThunk`](@ref).
 """
-@noinline function revise_dir_queued(dirname)
+@noinline function revise_dir_queued(dirname::AbstractString)
     @assert isabspath(dirname)
     if !isdir(dirname)
         sleep(0.1)   # in case git has done a delete/replace cycle
@@ -891,7 +891,7 @@ it defaults to `Main`.
 
 If this produces many errors, check that you specified `mod` correctly.
 """
-function track(mod::Module, file; mode=:sigs, kwargs...)
+function track(mod::Module, file::AbstractString; mode=:sigs, kwargs...)
     isfile(file) || error(file, " is not a file")
     # Determine whether we're already tracking this file
     id = Base.moduleroot(mod) == Main ? PkgId(mod, string(mod)) : PkgId(mod)  # see #689 for `Main`
@@ -935,13 +935,13 @@ function track(mod::Module, file; mode=:sigs, kwargs...)
     return nothing
 end
 
-function track(file; kwargs...)
+function track(file::AbstractString; kwargs...)
     startswith(file, juliadir) && error("use Revise.track(Base) or Revise.track(<stdlib module>)")
     track(Main, file; kwargs...)
 end
 
 """
-    includet(filename)
+    includet(filename::AbstractString)
 
 Load `filename` and track future changes. `includet` is intended for quick "user scripts"; larger or more
 established projects are encouraged to put the code in one or more packages loaded with `using`
@@ -1001,7 +1001,7 @@ try fixing it with something like `push!(LOAD_PATH, "/path/to/my/private/repos")
 they will not be automatically tracked.
 (Call [`Revise.track`](@ref) manually on each file, if you've already `included`d all the code you need.)
 """
-function includet(mod::Module, file)
+function includet(mod::Module, file::AbstractString)
     prev = Base.source_path(nothing)
     file = if prev === nothing
         abspath(file)
@@ -1033,7 +1033,7 @@ function includet(mod::Module, file)
     end
     return nothing
 end
-includet(file) = includet(Main, file)
+includet(file::AbstractString) = includet(Main, file)
 
 """
     Revise.silence(pkg)

src/parsing.jl

@@ -9,7 +9,7 @@ if `filename` defines more module(s) then these will all have separate entries i
 
 If parsing `filename` fails, `nothing` is returned.
 """
-parse_source(filename, mod::Module; kwargs...) =
+parse_source(filename::AbstractString, mod::Module; kwargs...) =
     parse_source!(ModuleExprsSigs(mod), filename, mod; kwargs...)
 
 """
@@ -26,28 +26,27 @@ function parse_source!(mod_exprs_sigs::ModuleExprsSigs, filename::AbstractString
         @warn "$filename is not a file, omitting from revision tracking"
         return nothing
     end
-    parse_source!(mod_exprs_sigs, read(filename, String), filename, mod; kwargs...)
+    return parse_source!(mod_exprs_sigs, read(filename, String), filename, mod; kwargs...)
 end
 
-"""
-    success = parse_source!(mod_exprs_sigs::ModuleExprsSigs, src::AbstractString, filename::AbstractString, mod::Module)
-
-Parse a string `src` obtained by reading `file` as a single
-string. `pos` is the 1-based byte offset from which to begin parsing `src`.
-
-See also [`Revise.parse_source`](@ref).
-"""
 function parse_source!(mod_exprs_sigs::ModuleExprsSigs, src::AbstractString, filename::AbstractString, mod::Module; kwargs...)
-    startswith(src, "# REVISE: DO NOT PARSE") && return DoNotParse()
-    ex = Base.parse_input_line(src; filename=filename)
-    ex === nothing && return mod_exprs_sigs
-    if isexpr(ex, :error) || isexpr(ex, :incomplete)
-        eval(ex)
+    if startswith(src, "# REVISE: DO NOT PARSE")
+        return DoNotParse()
+    end
+    ex = Base.parse_input_line(src; filename)
+    if ex === nothing
+        return mod_exprs_sigs
+    elseif ex isa Expr
+        return process_ex!(mod_exprs_sigs, ex, filename, mod; kwargs...)
+    else # literals
+        return nothing
     end
-    return process_source!(mod_exprs_sigs, ex, filename, mod; kwargs...)
 end
 
-function process_source!(mod_exprs_sigs::ModuleExprsSigs, ex, filename, mod::Module; mode::Symbol=:sigs)
+function process_ex!(mod_exprs_sigs::ModuleExprsSigs, ex::Expr, filename::AbstractString, mod::Module; mode::Symbol=:sigs)
+    if isexpr(ex, :error) || isexpr(ex, :incomplete)
+        return eval(ex)
+    end
     for (mod, ex) in ExprSplitter(mod, ex)
         if mode === :includet
             try

src/pkgs.jl

@@ -390,7 +390,7 @@ end
 
 # Much of this is adapted from base/loading.jl
 
-function manifest_file(project_file)
+function manifest_file(project_file = Base.active_project())
     if project_file isa String && isfile(project_file)
         mfile = Base.project_file_manifest_path(project_file)
         if mfile isa String
@@ -399,7 +399,6 @@ function manifest_file(project_file)
     end
     return nothing
 end
-manifest_file() = manifest_file(Base.active_project())
 
 function manifest_paths!(pkgpaths::Dict, manifest_file::String)
     d = if isdefined(Base, :get_deps) # `get_deps` is present in versions that support new manifest formats
@@ -427,7 +426,7 @@ end
 manifest_paths(manifest_file::String) =
     manifest_paths!(Dict{PkgId,String}(), manifest_file)
 
-function watch_manifest(mfile)
+function watch_manifest(mfile::String)
     while true
         try
             wait_changed(mfile)

src/recipes.jl

@@ -14,7 +14,7 @@ end
 
 const vstring = "v$(VERSION.major).$(VERSION.minor)"
 
-function inpath(path, dirs)
+function inpath(path::AbstractString, dirs::Vector{String})
     spath = splitpath(path)
     idx = findfirst(isequal(first(dirs)), spath)
     idx === nothing && return false
@@ -29,15 +29,15 @@ function inpath(path, dirs)
     return true
 end
 
-function _track(id, modname; modified_files=revision_queue)
+function _track(id::PkgId, modname::Symbol; modified_files=revision_queue)
     haskey(pkgdatas, id) && return nothing  # already tracked
     isbase = modname === :Base
     isstdlib = !isbase && modname ∈ stdlib_names
     if isbase || isstdlib
         # Test whether we know where to find the files
         if isbase
             srcdir = fixpath(joinpath(juliadir, "base"))
-            dirs = ["base"]
+            dirs = String["base"]
         else
             stdlibv = joinpath("stdlib", vstring, String(modname))
             srcdir = fixpath(joinpath(juliadir, stdlibv))
@@ -48,7 +48,7 @@ function _track(id, modname; modified_files=revision_queue)
                 # This can happen for Pkg, since it's developed out-of-tree
                 srcdir = joinpath(juliadir, "usr", "share", "julia", stdlibv)  # omit fixpath deliberately
             end
-            dirs = ["stdlib", String(modname)]
+            dirs = String["stdlib", String(modname)]
         end
         if !isdir(srcdir)
             @error "unable to find path containing source for $modname, tracking is not possible"

src/relocatable_exprs.jl

@@ -73,7 +73,7 @@ function Base.iterate(iter::LineSkippingIterator, i=0)
     return (iter.args[i], i)
 end
 
-function skip_to_nonline(args, i)
+function skip_to_nonline(args::Vector{Any}, i::Int)
     while true
         i > length(args) && return i
         ex = args[i]

src/types.jl

@@ -145,16 +145,14 @@ Base.PkgId(pkgdata::PkgData) = PkgId(pkgdata.info)
 CodeTracking.basedir(pkgdata::PkgData) = basedir(pkgdata.info)
 CodeTracking.srcfiles(pkgdata::PkgData) = srcfiles(pkgdata.info)
 
-is_same_file(a, b) = String(a) == String(b)
-
-function fileindex(info, file)
+function fileindex(info::PkgData, file::AbstractString)
     for (i, f) in enumerate(srcfiles(info))
-        is_same_file(f, file) && return i
+        String(f) == String(file) && return i
     end
     return nothing
 end
 
-function hasfile(info, file)
+function hasfile(info::PkgData, file::AbstractString)
     if isabspath(file)
         file = relpath(file, info)
     end
@@ -168,7 +166,7 @@ function fileinfo(pkgdata::PkgData, file::String)
 end
 fileinfo(pkgdata::PkgData, i::Int) = pkgdata.fileinfos[i]
 
-function Base.push!(pkgdata::PkgData, pr::Pair{<:Any,FileInfo})
+function Base.push!(pkgdata::PkgData, pr::Pair{<:AbstractString,FileInfo})
     push!(srcfiles(pkgdata), pr.first)
     push!(pkgdata.fileinfos, pr.second)
     return pkgdata

src/utils.jl

@@ -1,4 +1,4 @@
-relpath_safe(path, startpath) = isempty(startpath) ? path : relpath(path, startpath)
+relpath_safe(path::AbstractString, startpath::AbstractString) = isempty(startpath) ? path : relpath(path, startpath)
 
 function Base.relpath(filename::AbstractString, pkgdata::PkgData)
     if isabspath(filename)
@@ -33,7 +33,7 @@ function unique_dirs(iter)
     return udirs
 end
 
-function file_exists(filename)
+function file_exists(filename::AbstractString)
     filename = normpath(filename)
     isfile(filename) && return true
     alt = get(cache_file_key, filename, nothing)
@@ -87,7 +87,7 @@ function unwrap(ex::Expr)
 end
 unwrap(rex::RelocatableExpr) = RelocatableExpr(unwrap(rex.ex))
 
-istrivial(a) = a === nothing || isa(a, LineNumberNode)
+istrivial(@nospecialize a) = a === nothing || isa(a, LineNumberNode)
 
 function unwrap_where(ex::Expr)
     while isexpr(ex, :where)