Implement include() with Base.IncludeInto and similarly for eval (#68)

Adopt the changes from JuliaLang/julia#55949
to define module-local include / eval in terms of `Base.IncludeInto` and
`Core.EvalInto`.

It previously made sense to define `include()` and `eval()` as part of desugaring.
But now that `include` is just an instance of `IncludeInto` the runtime can define
these without calling into flisp so I've reverted to letting `jl_eval_module_expr()`
do that from the C code.

Author: c42f

src/desugaring.jl

@@ -4248,56 +4248,7 @@ function expand_module(ctx, ex::SyntaxTree)
     @chk kind(modname_ex) == K"Identifier"
     modname = modname_ex.name_val
 
-    std_defs = if !has_flags(ex, JuliaSyntax.BARE_MODULE_FLAG)
-        @ast ctx (@HERE) [
-            K"block"
-            [K"using"(@HERE)
-                [K"importpath"
-                    "Base"           ::K"Identifier"
-                ]
-            ]
-            [K"function"(@HERE)
-                [K"call"
-                    "eval"           ::K"Identifier"
-                    "x"              ::K"Identifier"
-                ]
-                [K"call"
-                    "eval"           ::K"core"
-                    modname          ::K"Identifier"
-                    "x"              ::K"Identifier"
-                ]
-            ]
-            [K"function"(@HERE)
-                [K"call"
-                    "include"        ::K"Identifier"
-                    "x"              ::K"Identifier"
-                ]
-                [K"call"
-                    "_call_latest"   ::K"core"
-                    "include"        ::K"top"
-                    modname          ::K"Identifier"
-                    "x"              ::K"Identifier"
-                ]
-            ]
-            [K"function"(@HERE)
-                [K"call"
-                    "include"        ::K"Identifier"
-                    [K"::"
-                        "mapexpr"    ::K"Identifier"
-                        "Function"   ::K"top"
-                    ]
-                    "x"              ::K"Identifier"
-                ]
-                [K"call"
-                    "_call_latest"   ::K"core"
-                    "include"        ::K"top"
-                    "mapexpr"        ::K"Identifier"
-                    modname          ::K"Identifier"
-                    "x"              ::K"Identifier"
-                ]
-            ]
-        ]
-    end
+    std_defs = !has_flags(ex, JuliaSyntax.BARE_MODULE_FLAG)
 
     body = ex[2]
     @chk kind(body) == K"block"
@@ -4311,10 +4262,10 @@ function expand_module(ctx, ex::SyntaxTree)
             eval_module           ::K"Value"
             ctx.mod               ::K"Value"
             modname               ::K"String"
+            std_defs              ::K"Bool"
             ctx.expr_compat_mode  ::K"Bool"
             [K"inert"(body)
                 [K"toplevel"
-                    std_defs
                     children(body)...
                 ]
             ]

src/runtime.jl

@@ -214,7 +214,8 @@ end
 #     public modname
 #
 # And run statments in the toplevel expression `body`
-function eval_module(parentmod, modname, expr_compat_mode, body)
+function eval_module(parentmod::Module, modname::AbstractString, std_defs::Bool,
+                     expr_compat_mode::Bool, body::SyntaxTree)
     # Here we just use `eval()` with an Expr.
     # If we wanted to avoid this we'd need to reproduce a lot of machinery from
     # jl_eval_module_expr()
@@ -229,11 +230,10 @@ function eval_module(parentmod, modname, expr_compat_mode, body)
     # mod = @ccall jl_new_module(Symbol(modname)::Symbol, parentmod::Module)::Any
     # ...
     name = Symbol(modname)
-    Core.eval(parentmod, :(
-        baremodule $name
-            $eval($name, $body; expr_compat_mode=$expr_compat_mode)
-        end
-    ))
+    eval_module_body(mod) = eval(mod, body; expr_compat_mode=expr_compat_mode)
+    Core.eval(parentmod,
+        Expr(:module, std_defs, name,
+             Expr(:block, Expr(:call, eval_module_body, name))))
 end
 
 const _Base_has_eval_import = isdefined(Base, :_eval_import)

test/misc_ir.jl

@@ -182,6 +182,26 @@ LoweringError:
 (; a=1, f())
 #       └─┘ ── Invalid named tuple element
 
+########################################
+# Module lowering
+module Mod
+    body
+    stmts
+end
+#---------------------
+1   (call JuliaLowering.eval_module TestMod "Mod" true false (inert (toplevel body stmts)))
+2   (return %₁)
+
+########################################
+# Bare module lowering
+baremodule BareMod
+    body
+    stmts
+end
+#---------------------
+1   (call JuliaLowering.eval_module TestMod "BareMod" false false (inert (toplevel body stmts)))
+2   (return %₁)
+
 ########################################
 # Error: Modules not allowed in local scope
 let

test/modules.jl

@@ -11,17 +11,19 @@ end
 """, "module_test")
 @test A isa Module
 @test A.g() == "hi"
-@test A.include isa Function
+@test A.include isa Base.IncludeInto
+@test A.eval isa Core.EvalInto
 @test A.Base === Base
-@test A.eval(:(x = -1)) == -1
-@test A.x == -1
+@test A.eval(:(x = -2)) == -2
+@test A.x == -2
 
 B = JuliaLowering.include_string(test_mod, """
 baremodule B
 end
 """, "baremodule_test")
 @test B.Core === Core
 @test !isdefined(B, :include)
+@test !isdefined(B, :eval)
 @test !isdefined(B, :Base)
 
 # modules allowed in nested code in global scope