REPL completion: make import mode more forgiving

Don't require a using/import to be on its own line to enter import mode; instead
look for partial import expressions and require the cursor be in the range where
modules/imported names would go.

Fixes JuliaLang#56389 (including the fix for JuliaLang#55842)

Author: xal-0

stdlib/REPL/src/REPLCompletions.jl

@@ -937,40 +937,22 @@ const superscript_regex = Regex("^\\\\\\^[" * join(isdigit(k) || isletter(k) ? "
 
 # Aux function to detect whether we're right after a using or import keyword
 function get_import_mode(s::String, pos::Int)
-    # allow all of these to start with leading whitespace and macros like @eval and @eval(
-    # ^\s*(?:@\w+\s*(?:\(\s*)?)?
-
-    # Do not enter import mode unless cursor beyond import keyword
-    beyond_kw(m) = pos >= m.offsets[1] + sizeof(m[1])
-
-    # match simple cases like `using |` and `import  |`
-    mod_import_match_simple = match(r"^\s*(?:@\w+\s*(?:\(\s*)?)?\b(using|import)\s*$", s)
-    if mod_import_match_simple !== nothing && beyond_kw(mod_import_match_simple)
-        if mod_import_match_simple[1] == "using"
-            return :using_module
-        else
-            return :import_module
-        end
-    end
-    # match module import statements like `using Foo|`, `import Foo, Bar|` and `using Foo.Bar, Baz, |`
-    mod_import_match = match(r"^\s*(?:@\w+\s*(?:\(\s*)?)?\b(using|import)\s+([\w\.]+(?:\s*,\s*[\w\.]+)*),?\s*$", s)
-    if mod_import_match !== nothing && beyond_kw(mod_import_match)
-        if mod_import_match.captures[1] == "using"
-            return :using_module
-        else
-            return :import_module
+    # Capture group 1 will be returned, group 2 is where the cursor should be.
+    function match_pos(re)
+        for m in eachmatch(re, s, overlap=true)
+            m !== nothing || continue
+            pos in range(m.offsets[2], length=sizeof(m[2])) || continue
+            return m[1]
         end
     end
+
+    # match module import statements like `using |`, `import |`, `using Foo|`, `import Foo, Bar|` and `using Foo.Bar, Baz, |`
+    m = match_pos(r"\b(using|import)(\s+(?:[\w\.]+(?:\s*,\s*[\w\.]+)*(:?\s*,)?\s*)?)")
+    m !== nothing && return m == "using" ? :using_module : :import_module
+
     # now match explicit name import statements like `using Foo: |` and `import Foo: bar, baz|`
-    name_import_match = match(r"^\s*(?:@\w+\s*(?:\(\s*)?)?\b(using|import)\s+([\w\.]+)\s*:\s*([\w@!\s,]+)$", s)
-    if name_import_match !== nothing && beyond_kw(name_import_match)
-        if name_import_match[1] == "using"
-            return :using_name
-        else
-            return :import_name
-        end
-    end
-    return nothing
+    m = match_pos(r"\b(using|import)\s+(?:[\w\.]+(?:\s*,\s*[\w\.]+)*)\s*(:\s*(?:[\w@!\s,]+)*)")
+    m !== nothing && return m == "using" ? :using_name : :import_name
 end
 
 function close_path_completion(dir, path, str, pos)

stdlib/REPL/test/replcompletions.jl

@@ -2492,3 +2492,17 @@ let (c, r) = test_complete_pos("@tim| using Date")
     @test "@time" in c
     @test r == 1:4
 end
+
+# #56389
+let s = "begin\n  using Linear"
+    c, r = test_complete(s)
+    @test "LinearAlgebra" in c
+    @test r == 15:20
+    @test s[r] == "Linear"
+end
+let s = "using .CompletionFoo: bar, type_"
+    c, r = test_complete(s)
+    @test "type_test" in c
+    @test r == 28:32
+    @test s[r] == "type_"
+end