Support disabling globals from global scope

Setting that accepts a list of libraries (`table`) or library methods (`string.split`)

Closes #888

Author: JohnnyMorganz

CHANGELOG.md

@@ -6,6 +6,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## [Unreleased]
 
+### Added
+
+- Added configuration `luau-lsp.types.disabledGlobals` to support removing globals from the main scope for analysis.
+  Accepts a list of libraries or library methods (e.g., `table`, `string.split`,
+  etc.) ([#888](https://github.com/JohnnyMorganz/luau-lsp/issues/888))
+
 ### Changed
 
 - Sync to upstream Luau 0.663

editors/code/package.json

@@ -294,6 +294,15 @@
           },
           "scope": "window"
         },
+        "luau-lsp.types.disabledGlobals": {
+          "markdownDescription": "A list of globals to remove from the global scope. Accepts full libraries or particular functions (e.g., `table` or `table.clone`)",
+          "type": "array",
+          "default": [],
+          "items": {
+            "type": "string"
+          },
+          "scope": "window"
+        },
         "luau-lsp.types.roblox": {
           "markdownDescription": "Load in and automatically update Roblox type definitions for the type checker",
           "type": "boolean",

src/Workspace.cpp

@@ -300,7 +300,72 @@ void WorkspaceFolder::indexFiles(const ClientConfiguration& config)
     client->sendTrace("workspace: indexing all files COMPLETED");
 }
 
-void WorkspaceFolder::registerTypes()
+static void clearDisabledGlobals(const ClientPtr client, const Luau::GlobalTypes& globalTypes, const std::vector<std::string>& disabledGlobals)
+{
+    const auto targetScope = globalTypes.globalScope;
+    for (const auto& disabledGlobal : disabledGlobals)
+    {
+        std::string library = disabledGlobal;
+        std::optional<std::string> method = std::nullopt;
+
+        if (const auto separator = disabledGlobal.find('.'); separator != std::string::npos)
+        {
+            library = disabledGlobal.substr(0, separator);
+            method = disabledGlobal.substr(separator + 1);
+        }
+
+        const auto globalName = globalTypes.globalNames.names->get(library.c_str());
+        if (globalName.value == nullptr)
+        {
+            client->sendLogMessage(lsp::MessageType::Warning, "disabling globals: skipping unknown global - " + disabledGlobal);
+            continue;
+        }
+
+        if (auto binding = targetScope->bindings.find(globalName); binding != targetScope->bindings.end())
+        {
+            if (method)
+            {
+                const auto typeId = Luau::follow(binding->second.typeId);
+                if (const auto ttv = Luau::getMutable<Luau::TableType>(typeId))
+                {
+                    if (contains(ttv->props, *method))
+                    {
+                        client->sendLogMessage(lsp::MessageType::Info, "disabling globals: erasing global - " + disabledGlobal);
+                        ttv->props.erase(*method);
+                    }
+                    else
+                        client->sendLogMessage(lsp::MessageType::Warning, "disabling globals: could not find method - " + disabledGlobal);
+                }
+                else if (const auto ctv = Luau::getMutable<Luau::ClassType>(typeId))
+                {
+                    if (contains(ctv->props, *method))
+                    {
+                        client->sendLogMessage(lsp::MessageType::Info, "disabling globals: erasing global - " + disabledGlobal);
+                        ttv->props.erase(*method);
+                    }
+                    else
+                        client->sendLogMessage(lsp::MessageType::Warning, "disabling globals: could not find method - " + disabledGlobal);
+                }
+                else
+                {
+                    client->sendLogMessage(lsp::MessageType::Warning,
+                        "disabling globals: cannot clear method from global, only tables or classes are supported - " + disabledGlobal);
+                }
+            }
+            else
+            {
+                client->sendLogMessage(lsp::MessageType::Info, "disabling globals: erasing global - " + disabledGlobal);
+                targetScope->bindings.erase(globalName);
+            }
+        }
+        else
+        {
+            client->sendLogMessage(lsp::MessageType::Warning, "disabling globals: skipping unknown global - " + disabledGlobal);
+        }
+    }
+}
+
+void WorkspaceFolder::registerTypes(const std::vector<std::string>& disabledGlobals)
 {
     LUAU_TIMETRACE_SCOPE("WorkspaceFolder::initialize", "LSP");
     client->sendTrace("workspace initialization: registering Luau globals");
@@ -368,6 +433,16 @@ void WorkspaceFolder::registerTypes()
             client->publishDiagnostics({uri, std::nullopt, diagnostics});
         }
     }
+
+    if (!disabledGlobals.empty())
+    {
+        client->sendTrace("workspace initialization: removing disabled globals");
+        clearDisabledGlobals(client, frontend.globals, disabledGlobals);
+        if (!FFlag::LuauSolverV2)
+            clearDisabledGlobals(client, frontend.globalsForAutocomplete, disabledGlobals);
+        client->sendTrace("workspace initialization: removing disabled globals COMPLETED");
+    }
+
     Luau::freeze(frontend.globals.globalTypes);
     if (!FFlag::LuauSolverV2)
         Luau::freeze(frontend.globalsForAutocomplete.globalTypes);
@@ -387,7 +462,7 @@ void WorkspaceFolder::setupWithConfiguration(const ClientConfiguration& configur
         platform = LSPPlatform::getPlatform(configuration, &fileResolver, this);
         fileResolver.platform = platform.get();
 
-        registerTypes();
+        registerTypes(configuration.types.disabledGlobals);
     }
 
     client->sendTrace("workspace: apply platform-specific configuration");

src/include/LSP/ClientConfiguration.hpp

@@ -36,8 +36,10 @@ struct ClientTypesConfiguration
     bool roblox = true;
     /// Any definition files to load globally
     std::vector<std::filesystem::path> definitionFiles{};
+    /// A list of globals to remove from the global scope. Accepts full libraries or particular functions (e.g., `table` or `table.clone`)
+    std::vector<std::string> disabledGlobals{};
 };
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(ClientTypesConfiguration, roblox, definitionFiles);
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(ClientTypesConfiguration, roblox, definitionFiles, disabledGlobals);
 
 enum struct InlayHintsParameterNamesConfig
 {

src/include/LSP/Workspace.hpp

@@ -84,7 +84,7 @@ class WorkspaceFolder
     const Luau::ModulePtr getModule(const Luau::ModuleName& moduleName, bool forAutocomplete = false) const;
 
 private:
-    void registerTypes();
+    void registerTypes(const std::vector<std::string>& disabledGlobals);
     void endAutocompletion(const lsp::CompletionParams& params);
     void suggestImports(const Luau::ModuleName& moduleName, const Luau::Position& position, const ClientConfiguration& config,
         const TextDocument& textDocument, std::vector<lsp::CompletionItem>& result, bool completingTypeReferencePrefix = true);

tests/Definitions.test.cpp

@@ -42,4 +42,56 @@ TEST_CASE("handles_definitions_files_relying_on_mutations")
     REQUIRE(result.errors.empty());
 }
 
+TEST_CASE("support_disabling_global_types")
+{
+    auto client = std::make_shared<Client>(Client{});
+    auto workspace = WorkspaceFolder(client, "$TEST_WORKSPACE", Uri(), std::nullopt);
+
+    auto config = defaultTestClientConfiguration();
+    config.types.disabledGlobals = {
+        "table",
+    };
+
+    workspace.setupWithConfiguration(config);
+
+    auto document = newDocument(workspace, "foo.luau", R"(
+        local x = string.split("", "")
+        local y = table.insert({}, 1)
+    )");
+
+    auto result = workspace.frontend.check("foo.luau");
+    REQUIRE_EQ(result.errors.size(), 1);
+
+    auto err = Luau::get<Luau::UnknownSymbol>(result.errors[0]);
+    REQUIRE(err);
+    CHECK_EQ(err->name, "table");
+    CHECK_EQ(err->context, Luau::UnknownSymbol::Context::Binding);
+}
+
+TEST_CASE("support_disabling_methods_in_global_types")
+{
+    auto client = std::make_shared<Client>(Client{});
+    auto workspace = WorkspaceFolder(client, "$TEST_WORKSPACE", Uri(), std::nullopt);
+
+    auto config = defaultTestClientConfiguration();
+    config.types.disabledGlobals = {
+        "table.insert",
+    };
+
+    workspace.setupWithConfiguration(config);
+
+    auto document = newDocument(workspace, "foo.luau", R"(
+        local x = table.find({}, "value")
+        local y = table.insert({}, 1)
+    )");
+
+    auto result = workspace.frontend.check("foo.luau");
+    REQUIRE_EQ(result.errors.size(), 1);
+
+    auto err = Luau::get<Luau::UnknownProperty>(result.errors[0]);
+    REQUIRE(err);
+    CHECK_EQ(Luau::toString(err->table), "typeof(table)");
+    CHECK_EQ(err->key, "insert");
+}
+
 TEST_SUITE_END();