Adds Runtime::runSource method (#911)

Adds `Runtime::runSource` method to support running Luau source code
directly.

Resolves #285.

To avoid duplication and unnecessary dependencies between the `Runtime`
and `CLI`, I decided to move main logic of `runBytecode` to the
`Runtime`, which feels like its natural place. If that's not the case
and main logic of `runBytecode` should stay in `climain`, I can revert
the changes. But the solution will be more verbose.

The `CLI` layer's `runBytecode` now delegates to `Runtime::runBytecode`
with an `onLoaded` callback for codegen and profiling, eliminating
duplication within the `Runtime` implementation.

~~Additionally, I moved the `profiler options` from the `CLI` directly
into the `profiler`. Currently, the sampling `frequency` in Hz
duplicates its default value in two places:
[here](https://github.com/luau-lang/lute/blob/6ed3142c96d109a7ac94ec7c9a7d8dc86a56ac69/lute/cli/src/profiler.cpp#L53)
and
[here](https://github.com/luau-lang/lute/blob/6ed3142c96d109a7ac94ec7c9a7d8dc86a56ac69/lute/cli/include/lute/climain.h#L13).
It has no impact at the moment, but having a single source will help
avoid potential bugs in the future.~~
Moved to PR #918.

Author: tyulpan

lute/cli/include/lute/climain.h

@@ -1,22 +1,7 @@
 #pragma once
-#include "lute/profiler.h"
 
-#include <functional>
-#include <optional>
 #include <string>
 
-struct lua_State;
-struct Runtime;
 class LuteReporter;
 
 int cliMain(int argc, char** argv, LuteReporter& reporter);
-bool runBytecode(
-    Runtime& runtime,
-    const std::string& bytecode,
-    const std::string& chunkname,
-    lua_State* GL,
-    int program_argc,
-    char** program_argv,
-    LuteReporter& reporter,
-    std::optional<ProfileOptions> profileOptions = std::nullopt
-);

lute/cli/src/climain.cpp

@@ -9,7 +9,6 @@
 #include "lute/packagerun.h"
 #include "lute/process.h"
 #include "lute/profiler.h"
-#include "lute/ref.h"
 #include "lute/reporter.h"
 #include "lute/requiresetup.h"
 #include "lute/runtime.h"
@@ -116,84 +115,45 @@ Compile Options:
 	-h, --help              Display this usage message.
 )";
 
-static bool setupArguments(lua_State* L, int argc, char** argv)
-{
-    if (!lua_checkstack(L, argc))
-        return false;
-
-    for (int i = 0; i < argc; ++i)
-        lua_pushstring(L, argv[i]);
-
-    return true;
-}
-
-bool runBytecode(
+static bool runBytecode(
     Runtime& runtime,
     const std::string& bytecode,
     const std::string& chunkname,
-    lua_State* GL,
     int program_argc,
     char** program_argv,
     LuteReporter& reporter,
-    std::optional<ProfileOptions> profileOptions
+    std::optional<ProfileOptions> profileOptions = std::nullopt
 )
 {
-    // module needs to run in a new thread, isolated from the rest
-    lua_State* L = lua_newthread(GL);
-
-    if (profileOptions)
-        profilerStart(L, profileOptions->frequency);
-
-    // new thread needs to have the globals sandboxed
-    luaL_sandboxthread(L);
-
-    if (luau_load(L, chunkname.c_str(), bytecode.data(), bytecode.size(), 0) != 0)
-    {
-        if (const char* str = lua_tostring(L, -1))
-            reporter.reportError(str);
-        else
-            reporter.reportError("Failed to load bytecode");
-
-        lua_pop(GL, 1);
-        return false;
-    }
-
-    if (getCodegenEnabled())
-    {
-        Luau::CodeGen::CompilationOptions nativeOptions;
-        Luau::CodeGen::compile(L, -1, nativeOptions);
-    }
-
-    if (!setupArguments(L, program_argc, program_argv))
-    {
-        reporter.reportError("Failed to pass arguments to Luau");
-        lua_pop(GL, 1);
-        return false;
-    }
-
-    runtime.args.clear();
-    for (int i = 0; i < program_argc; ++i)
-        runtime.args.emplace_back(program_argv[i]);
-
-    runtime.GL = GL;
-    runtime.runningThreads.push_back({true, getRefForThread(L), program_argc});
-
-    lua_pop(GL, 1);
+    bool success = runtime.runBytecode(
+        bytecode,
+        chunkname,
+        program_argc,
+        program_argv,
+        [&](lua_State* L)
+        {
+            if (getCodegenEnabled())
+            {
+                Luau::CodeGen::CompilationOptions nativeOptions;
+                Luau::CodeGen::compile(L, -1, nativeOptions);
+            }
+            if (profileOptions)
+                profilerStart(L, profileOptions->frequency);
+        }
+    );
 
-    bool b = runtime.runToCompletion();
     if (profileOptions)
     {
         profilerStop();
         profilerDump(profileOptions->filename.c_str(), reporter);
     }
 
-    return b;
+    return success;
 }
 
 static bool runFile(
     Runtime& runtime,
     const char* name,
-    lua_State* GL,
     int program_argc,
     char** program_argv,
     LuteReporter& reporter,
@@ -217,7 +177,7 @@ static bool runFile(
 
     std::string bytecode = Luau::compile(*source, copts());
 
-    return runBytecode(runtime, bytecode, chunkname, GL, program_argc, program_argv, reporter, profileOptions);
+    return runBytecode(runtime, bytecode, chunkname, program_argc, program_argv, reporter, profileOptions);
 }
 
 static int assertionHandler(const char* expr, const char* file, int line, const char* function)
@@ -396,7 +356,6 @@ int handleRunCommand(int argc, char** argv, int argOffset, bool packageAwareness
     }
 
     Runtime runtime{reporter};
-    lua_State* L;
 
     if (packageAwareness)
     {
@@ -419,14 +378,14 @@ int handleRunCommand(int argc, char** argv, int argOffset, bool packageAwareness
         }
 
         auto [directDependencies, allDependencies] = getDependenciesFromLockfile(*lockfile);
-        L = setupPkgRunState(runtime, std::move(directDependencies), std::move(allDependencies));
+        setupPkgRunState(runtime, std::move(directDependencies), std::move(allDependencies));
     }
     else
     {
-        L = setupRunState(runtime);
+        setupRunState(runtime);
     }
 
-    bool success = runFile(runtime, validPath.c_str(), L, program_argc, program_argv, reporter, profileOptions);
+    bool success = runFile(runtime, validPath.c_str(), program_argc, program_argv, reporter, profileOptions);
     return success ? 0 : 1;
 }
 
@@ -650,10 +609,9 @@ void setupVersionLibrary(lua_State* L)
 int handleCliCommand(CliCommandResult result, int program_argc, char** program_argv, LuteReporter& reporter)
 {
     Runtime runtime{reporter};
-    lua_State* L = setupCliCommandState(runtime, setupVersionLibrary);
+    setupCliCommandState(runtime, setupVersionLibrary);
 
-    std::string bytecode = Luau::compile(std::string(result.contents), copts());
-    return runBytecode(runtime, bytecode, "@" + result.path, L, program_argc, program_argv, reporter) ? 0 : 1;
+    return runtime.runSource(std::string(result.contents), copts(), "@" + result.path, program_argc, program_argv) ? 0 : 1;
 }
 
 int cliMain(int argc, char** argv, LuteReporter& reporter)
@@ -674,12 +632,12 @@ int cliMain(int argc, char** argv, LuteReporter& reporter)
     {
         Runtime runtime{reporter};
 
-        lua_State* GL = setupBundleState(runtime, payload->luauConfigFiles, payload->filePathToBytecode);
+        setupBundleState(runtime, payload->luauConfigFiles, payload->filePathToBytecode);
         std::string entryPoint = payload->entryPointPath;
         auto entryModule = payload->filePathToBytecode.find(entryPoint);
         if (entryModule != nullptr)
         {
-            bool success = runBytecode(runtime, *entryModule, "@@bundle/" + entryPoint, GL, argc, argv, reporter);
+            bool success = runBytecode(runtime, *entryModule, "@@bundle/" + entryPoint, argc, argv, reporter);
             return success ? 0 : 1;
         }
     }

lute/runtime/CMakeLists.txt

@@ -16,5 +16,5 @@ target_sources(Lute.Runtime PRIVATE
 target_compile_features(Lute.Runtime PUBLIC cxx_std_17)
 target_include_directories(Lute.Runtime PUBLIC "include" ${LIBUV_INCLUDE_DIR})
 target_link_libraries(Lute.Runtime PUBLIC Lute.Common)
-target_link_libraries(Lute.Runtime PRIVATE Luau.Require Luau.VM uv_a)
+target_link_libraries(Lute.Runtime PRIVATE Luau.Require Luau.Compiler Luau.VM uv_a)
 target_compile_options(Lute.Runtime PRIVATE ${LUTE_OPTIONS})

lute/runtime/include/lute/runtime.h

@@ -19,6 +19,11 @@
 
 struct lua_State;
 
+namespace Luau
+{
+struct CompileOptions;
+}
+
 struct ThreadToContinue
 {
     bool success = false;
@@ -81,6 +86,26 @@ struct Runtime
 
     uv_loop_t* getEventLoop();
 
+    // Load and run bytecode.
+    // If provided, onLoaded is called after bytecode is loaded
+    // with the loaded function at the top of the stack.
+    bool runBytecode(
+        const std::string& bytecode,
+        const std::string& chunkname,
+        int argc = 0,
+        char** argv = nullptr,
+        std::function<void(lua_State*)> onLoaded = nullptr
+    );
+
+    // Compile Luau source and run it.
+    bool runSource(
+        const std::string& source,
+        const Luau::CompileOptions& compileOptions,
+        const std::string& chunkname = "=stdin",
+        int argc = 0,
+        char** argv = nullptr
+    );
+
     LuteReporter& reporter;
 
     // VM for this runtime

lute/runtime/src/runtime.cpp

@@ -1,8 +1,12 @@
 #include "lute/runtime.h"
 
 #include "lute/common.h"
+#include "lute/ref.h"
+
+#include "Luau/Compiler.h"
 
 #include "lua.h"
+#include "luacode.h"
 #include "lualib.h"
 
 #include "uv.h"
@@ -363,6 +367,52 @@ ResumeToken getResumeToken(lua_State* L)
     return token;
 }
 
+bool Runtime::runBytecode(const std::string& bytecode, const std::string& chunkname, int argc, char** argv, std::function<void(lua_State*)> onLoaded)
+{
+    lua_State* L = lua_newthread(GL);
+
+    luaL_sandboxthread(L);
+
+    if (luau_load(L, chunkname.c_str(), bytecode.data(), bytecode.size(), 0) != 0)
+    {
+        reportError(L);
+        lua_pop(GL, 1);
+        return false;
+    }
+
+    if (onLoaded)
+        onLoaded(L);
+
+    if (argc > 0 && argv != nullptr)
+    {
+        if (!lua_checkstack(L, argc))
+        {
+            fprintf(stderr, "Failed to pass arguments to Luau\n");
+            lua_pop(GL, 1);
+            return false;
+        }
+
+        for (int i = 0; i < argc; ++i)
+            lua_pushstring(L, argv[i]);
+    }
+
+    args.clear();
+    for (int i = 0; i < argc; ++i)
+        args.emplace_back(argv[i]);
+
+    runningThreads.push_back({true, getRefForThread(L), argc});
+
+    lua_pop(GL, 1);
+
+    return runToCompletion();
+}
+
+bool Runtime::runSource(const std::string& source, const Luau::CompileOptions& compileOptions, const std::string& chunkname, int argc, char** argv)
+{
+    std::string bytecode = Luau::compile(source, compileOptions);
+    return runBytecode(bytecode, chunkname, argc, argv);
+}
+
 lua_State* setupState(Runtime& runtime, std::function<void(lua_State*)> doBeforeSandbox)
 {
     // Separate VM for data copies

tests/CMakeLists.txt

@@ -22,6 +22,7 @@ target_sources(Lute.Test PRIVATE
 
     # Test files
     src/compile.test.cpp
+    src/runsource.test.cpp
     src/configresolver.test.cpp
     src/lutefs.test.cpp
     src/modulepath.test.cpp

tests/src/cliruntimefixture.cpp

@@ -1,10 +1,8 @@
 #include "cliruntimefixture.h"
 
-#include "lute/climain.h"
+#include "lute/options.h"
 #include "lute/requiresetup.h"
 
-#include "Luau/Compiler.h"
-
 #include "lua.h"
 #include "lualib.h"
 
@@ -34,6 +32,5 @@ CliRuntimeFixture::CliRuntimeFixture()
 
 bool CliRuntimeFixture::runCode(const std::string& source)
 {
-    std::string bytecode = Luau::compile(source, Luau::CompileOptions());
-    return runBytecode(*runtime, bytecode, "=stdin", L, 0, nullptr, getReporter());
+    return runtime->runSource(source, copts());
 }

tests/src/packagerequire.test.cpp

@@ -5,7 +5,6 @@
 #include "lute/runtime.h"
 #include "lute/userlandvfs.h"
 
-#include "Luau/Compiler.h"
 #include "Luau/FileUtils.h"
 #include "Luau/Require.h"
 
@@ -24,7 +23,7 @@ TEST_CASE_FIXTURE(LuteFixture, "package_aware_require")
 {
     Runtime runtime{getReporter()};
 
-    lua_State* L = setupState(
+    setupState(
         runtime,
         [](lua_State* L)
         {
@@ -84,8 +83,7 @@ TEST_CASE_FIXTURE(LuteFixture, "package_aware_require")
     std::optional<std::string> contents = readFile(path);
     REQUIRE(contents);
 
-    std::string bytecode = Luau::compile(*contents, copts());
-    bool success = runBytecode(runtime, bytecode, "@" + path, L, 0, nullptr, getReporter());
+    bool success = runtime.runSource(*contents, copts(), "@" + path);
     CHECK(success);
 }