Support go to definition on imported type references

Author: JohnnyMorganz

CHANGELOG.md

@@ -28,6 +28,7 @@ type Contents = {
 - Added `luau-lsp.diagnostics.strictDatamodelTypes` (default: `false`) which configures whether we use expressive DataModel types to power diagnostics.
   When off, `game` / `script` / `workspace` (and all their members) are typed as `any`, which helps to prevent false positives, but may lead to false negatives.
 - Added CLI option `--base-luaurc=PATH` for both LSP and Analyze mode to provide a path to a `.luaurc` file which is used as the default configuration
+- Added support for Go To Definition / Type Definition on imported type references `module.Type` (gated behind FFlag `SupportTypeAliasGoToDeclaration`)
 
 ### Changed
 

src/LuauExt.cpp

@@ -746,6 +746,22 @@ std::optional<Luau::Property> lookupProp(const Luau::TypeId& parentType, const L
     return std::nullopt;
 }
 
+std::optional<Luau::ModuleName> lookupImportedModule(const Luau::Scope& deepScope, const Luau::Name& name)
+{
+    const Luau::Scope* scope = &deepScope;
+    while (true)
+    {
+        auto it = scope->importedModules.find(name);
+        if (it != scope->importedModules.end())
+            return it->second;
+
+        if (scope->parent)
+            scope = scope->parent.get();
+        else
+            return std::nullopt;
+    }
+}
+
 bool types::isMetamethod(const Luau::Name& name)
 {
     return name == "__index" || name == "__newindex" || name == "__call" || name == "__concat" || name == "__unm" || name == "__add" ||

src/include/LSP/LuauExt.hpp

@@ -119,6 +119,7 @@ std::optional<Luau::Location> getLocation(Luau::TypeId type);
 
 std::optional<Luau::Location> lookupTypeLocation(const Luau::Scope& deepScope, const Luau::Name& name);
 std::optional<Luau::Property> lookupProp(const Luau::TypeId& parentType, const Luau::Name& name);
+std::optional<Luau::ModuleName> lookupImportedModule(const Luau::Scope& deepScope, const Luau::Name& name);
 
 // Converts a UTF-8 position to a UTF-16 position, using the provided text document if available
 // NOTE: if the text document doesn't exist, we perform no conversion, so the positioning may be

src/operations/GotoDefinition.cpp

@@ -4,6 +4,8 @@
 #include "Luau/AstQuery.h"
 #include "LSP/LuauExt.hpp"
 
+LUAU_FASTFLAG(SupportTypeAliasGoToDeclaration)
+
 lsp::DefinitionResult WorkspaceFolder::gotoDefinition(const lsp::DefinitionParams& params)
 {
     lsp::DefinitionResult result;
@@ -114,20 +116,65 @@ lsp::DefinitionResult WorkspaceFolder::gotoDefinition(const lsp::DefinitionParam
     }
     else if (auto reference = node->as<Luau::AstTypeReference>())
     {
+        auto uri = params.textDocument.uri;
+        auto referenceTextDocument = textDocument;
+        bool tempDocument = false; // NOTE: need to be EXTREMELY CAREFUL on deleting the ptr
+
         auto scope = Luau::findScopeAtPosition(*module, position);
         if (!scope)
             return result;
 
-        // TODO: we currently can't handle if its imported from a module
         if (reference->prefix)
-            return result;
+        {
+            if (FFlag::SupportTypeAliasGoToDeclaration)
+            {
+                if (auto importedName = lookupImportedModule(*scope, reference->prefix.value().value))
+                {
+                    auto fileName = fileResolver.resolveToRealPath(*importedName);
+                    if (!fileName)
+                        return result;
+                    uri = Uri::file(*fileName);
+
+                    // TODO: fix "forAutocomplete"
+                    if (auto importedModule = frontend.moduleResolverForAutocomplete.getModule(*importedName);
+                        importedModule && importedModule->hasModuleScope())
+                        scope = importedModule->getModuleScope();
+                    else
+                        return result;
+
+                    referenceTextDocument = fileResolver.getTextDocument(*importedName);
+                    if (!referenceTextDocument)
+                    {
+                        // Open a temporary text document so we can perform operations on it
+                        if (auto source = fileResolver.readSource(*importedName))
+                        {
+                            tempDocument = true;
+                            referenceTextDocument = new TextDocument{uri, "luau", 0, source->source};
+                        }
+                        else
+                            return result;
+                    }
+                }
+                else
+                    return result;
+            }
+            else
+                return result;
+        }
 
         auto location = lookupTypeLocation(*scope, reference->name.value);
         if (!location)
+        {
+            if (tempDocument)
+                delete referenceTextDocument;
             return result;
+        }
 
         result.emplace_back(lsp::Location{
-            params.textDocument.uri, lsp::Range{textDocument->convertPosition(location->begin), textDocument->convertPosition(location->end)}});
+            uri, lsp::Range{referenceTextDocument->convertPosition(location->begin), referenceTextDocument->convertPosition(location->end)}});
+
+        if (tempDocument)
+            delete referenceTextDocument;
     }
 
     return result;
@@ -162,7 +209,7 @@ std::optional<lsp::Location> WorkspaceFolder::gotoTypeDefinition(const lsp::Type
     if (!node)
         return std::nullopt;
 
-    auto findTypeLocation = [textDocument, &module, &position, &params](Luau::AstType* type) -> std::optional<lsp::Location>
+    auto findTypeLocation = [this, textDocument, &module, &position, &params](Luau::AstType* type) -> std::optional<lsp::Location>
     {
         // TODO: should we only handle references here? what if its an actual type
         if (auto reference = type->as<Luau::AstTypeReference>())
@@ -173,7 +220,16 @@ std::optional<lsp::Location> WorkspaceFolder::gotoTypeDefinition(const lsp::Type
 
             // TODO: we currently can't handle if its imported from a module
             if (reference->prefix)
+            {
+                if (FFlag::SupportTypeAliasGoToDeclaration)
+                    if (auto importedName = scope->importedModules.find(reference->prefix.value().value);
+                        importedName != scope->importedModules.end())
+                        // TODO: fix "forAutocomplete"
+                        if (auto importedModule = frontend.moduleResolverForAutocomplete.getModule(importedName->second);
+                            importedModule && importedModule->hasModuleScope())
+                            scope = importedModule->getModuleScope();
                 return std::nullopt;
+            }
 
             auto location = lookupTypeLocation(*scope, reference->name.value);
             if (!location)