OOP Type Checking Workaround

[warped moss]

I'm trying to use type checking because it's helpful and I like it.

It all works just fine, except when I need to require something from ReplicatedStorage.

Because the linter can't handle non-static paths for require, I can't get the exported type from the class.

-- Solves type checking error, does not actually set the type
local Logger = require(ReplicatedStorage:WaitForChild("Utility").Classes.Logger)

-- I expect to be able to do this, but it does not work (typechecking error), no intellisense
local myLogger : Logger.Logger = Logger.new()

So I'm stuck here really trying to make it work so I can pull the exported type from the required module.

Has anyone done this before and have a workaround? I've googled this quite a lot and the suggested work arounds just don't work.

I tried using Rojo, but it seems it hasn't been updated since 2021, and Visual Studio Code seems to have a similar issue, and the Rojo plugin doesn't seem to be able to actually change code.

Edit
Turns out I'm stupid and I just wasn't using the right path in the require

[twilit ridge]

what's the logger module

@warped moss

[warped moss]

Like you need to see it or are just curious?

[twilit ridge]

I need to see it

[warped moss]

--!strict

--[[
    Helps log information to the console for better debugging.
    
    Just helps with prefixing a tag so the source of print statements is easier to see.
]]

type LoggerImpl = {
    __index:     LoggerImpl,
    new:         (tag: string, disabled: boolean) -> LoggerType,
    TagInfo:     (tag: string, ...any) -> (),
    TagWarn:     (tag: string, ...any) -> (),
    TagError:     (tag: string, ...any) -> (),
    Info:         (...any) -> (),
    Warn:         (...any) -> (),
    Error:         (...any) -> ()
}

type LoggerInst = {
    Tag: string,
    Disabled: boolean
}

export type LoggerType = typeof(setmetatable({} :: LoggerInst, {} :: LoggerImpl))

local Logger = {}
Logger.__index = Logger

--[[
    Logs a message as a white-colored info output
]]
function Logger.TagInfo(tag: string, ...)
    print(`[{tag}]`, ...)
end

--[[
    Logs a message as a yellow-colored warning output
]]
function Logger.TagWarn(tag: string, ...)
    warn(`[{tag}]`, ...)
end

--[[
    Logs an error, halting execution
]]
function Logger.TagError(tag: string, ...)
    local t = table.pack(...)
    local str = ""
    for _, v in t do
        str = str..`{v} `
    end
    error(`[{tag}] {str}`)
end

--[[
    Creates a new logger, using the given tag in future logs
]]
function Logger.new(tag: string, disabled: boolean?)
    local self = setmetatable({}, Logger)

    self.Tag = tag
    self.Disabled = disabled or false

    return self
end

--[[
    Logs a message as a white-colored info output
]]
function Logger:Info(...)
    if (self.Disabled) then return end
    print(`[{self.Tag}]`, ...)
end

--[[
    Logs a message as a yellow-colored warning output
]]
function Logger:Warn(...)
    if (self.Disabled) then return end
    warn(`[{self.Tag}]`, ...)
end

--[[
    Logs an error, halting execution
]]
function Logger:Error(...)
    if (self.Disabled) then return end
    local t = table.pack(...)
    local str = ""
    for _, v in t do
        str = str..`{v} `
    end
    error(`[{self.Tag}] {str}`)
end

return Logger

[twilit ridge]

just say that the function returns a LoggerType

[warped moss]

That doesn't solve the issue. I left that out due to the fact the Luau docs example did not include it

The issue is I can't use the type in this scenario:

type SpiderClassInst = {
    Logger: Logger.Logger
}

as this

local Logger = require(ReplicatedStorage:WaitForChild("Utility").Classes.Logger)

doesn't seem to be able to see the types regardless of exporting.

local Logger = require(ReplicatedStorage.Utility.Classes.Logger)

Does not work either as that causes an unsupported path error, as it isn't static

[twilit ridge]

if you want to use types from other modules u'll need to export it if its that what you're asking

cuz I didn't really understood the issue

[warped moss]

I do export the types

the typechecking linter isn't able to parse the exported types so I'm trying to figure out another way to do this so I can access the types

[twilit ridge]

I usually manually write all the properties & methods of OOP in a global types module

so for example here I would just require the types module and just do Types.Logger

[warped moss]

Is that stored in ReplicatedStorage separate from everything else?

[twilit ridge]

just along with my modules container

[warped moss]

And how do you normally require the types module?

[twilit ridge]

is just a module that I use globally for all my types so I just do

local Types = require(RS.Modules.Utils.Types)

and then I can easily do

local a: Types.MyOOP

for example

[warped moss]

Hmm. Shouldn't the fact I'm requiring a module that's exporting types from ReplicatedStorage mean the exported types should be found?

[twilit ridge]

nope, here you would need to specify the module that exported these types and then access it

[warped moss]

Doing this

local LoggerTypes = require(ReplicatedStorage.Utility.Classes.Logger.Types)

doesn't seem to work either...

[twilit ridge]

but I don't understand what are you trying to do? like when you require the module what are you expecting to happen

[warped moss]

where "Types" is

export type LoggerImpl = {
    __index:     LoggerImpl,
    new:         (tag: string, disabled: boolean) -> LoggerType,
    TagInfo:     (tag: string, ...any) -> (),
    TagWarn:     (tag: string, ...any) -> (),
    TagError:     (tag: string, ...any) -> (),
    Info:         (...any) -> (),
    Warn:         (...any) -> (),
    Error:         (...any) -> ()
}

export type LoggerInst = {
    Tag: string,
    Disabled: boolean
}

export type LoggerType = typeof(setmetatable({} :: LoggerInst, {} :: LoggerImpl))

return {}

[twilit ridge]

to access the LoggerType just do LoggerTypes.LoggerType

[warped moss]

I'm expecting to be able to do what you did, grab the exported type so I can apply nice happy intellisense

[twilit ridge]

local a: LoggerTypes.LoggerType

[warped moss]

I know, which is what I did
local l: LoggerTypes.Logger = Logger.new("hello")
but intellisense isn't showing up

[twilit ridge]

you're not accessing the right type

.LoggerType

[warped moss]

Wow I'm an absolute doofus. I should have read that first. I'm sorry.

Seems to work now. I think this works just fine for me. Thanks for taking the time to parse all that with me.

[twilit ridge]

wrinting a dot should autocomplete all the types dot just like tables

[warped moss]

Yes it does. I've done typechecking before, just this one situation wasn't working.

Everything would imply that I can pull the type from the other required module. Even though it has other stuff in it.

It's odd the module has to only have types like this

From the Luau docs:

-- Module Bar
export type Baz = string

local module = {}

module.Quux = "Hello, world!"

return module

-- Module Foo
local Bar = require(script.Parent.Bar)

local baz1: Bar.Baz = 1     -- not ok
local baz2: Bar.Baz = "foo" -- ok

print(Bar.Quux)         -- ok
print(Bar.FakeProperty) -- not ok

Bar.NewProperty = true -- not ok

Oh maybe it meant just that kind of interaction is for static paths, but your method will always work. Okay

[unreal leaf]

If you can use Rojo I’d highly recommend involving ROBLOX LSP too.

I use it and you can specify the filesystem path of a module upon requiring a module, which returns everything inside of that module and can be used for typing.

E.g

…
—-@module src.ReplicatedStorage.Modules.WeaponModule
local WeaponModule = require(ReplicatedStorage.Modules.WeaponModule)
…

@warped moss

Although it seems like your problem has been fixed.

Either way I passed on my opinion, if you ever need it hope it helps.

It also means you don’t have to type out export type for every module or have a global module for storing types etcetc

[warped moss]

So this like exports all the types? Even though in the Studio editor it doesn't allow that?

[unreal leaf]

ROBLOX LSP parses the module file you provide in the file system and assigns the returned type in the module to the require(…)

So in Rojo (and I use VSCode), I can have intellisense work as intended on the class

Either way if you can export the type of the class too then that works

[foggy idol]

** You are now Level 11! **

[unreal leaf]

But Rojo and ROBLOX LSP are pretty nice, so I’m just giving a recommendation.

[warped moss]

So Roblox LSP is a Visual Studio extension? I wonder if I already have that installed.

I tried using Rojo earlier and it didn't seem to actually change the scripts in Studio which was odd. Is it still Rojo 7? Or is there a newer version?

[unreal leaf]

Rojo 7.4.4, latest version of ROBLOX LSP with some settings mended although I think —-@module works out the box, not sure from what version though

[unreal leaf]

Did you install the roblox studio plugin too for Rojo and serve your code?

[warped moss]

Oh yeah, it connected just fine, it just didn't reflect changes after I saved

[unreal leaf]

Are the files listed in the default.project.json “path” paths?

If there isn’t a “path” scope set in default.project.json where your code is Rojo for some reason doesn’t understand changes at all

[warped moss]

{
  "name": "project",
  "tree": {
    "$className": "DataModel",
    "ReplicatedStorage": {
      "$className": "ReplicatedStorage",
      "$ignoreUnknownInstances": true,
      "$path": "src/ReplicatedStorage"
    },
    "ServerScriptService": {
      "$className": "ServerScriptService",
      "$ignoreUnknownInstances": true,
      "$path": "src/ServerScriptService"
    },
    "ServerStorage": {
      "$className": "ServerStorage",
      "$ignoreUnknownInstances": true,
      "$path": "src/ServerStorage"
    },
    "StarterPlayer": {
      "$className": "StarterPlayer",
      "StarterCharacterScripts": {
        "$className": "StarterCharacterScripts",
        "$ignoreUnknownInstances": true,
        "$path": "src/StarterPlayer/StarterCharacterScripts"
      },
      "StarterPlayerScripts": {
        "$className": "StarterPlayerScripts",
        "$ignoreUnknownInstances": true,
        "$path": "src/StarterPlayer/StarterPlayerScripts"
      },
      "$ignoreUnknownInstances": true
    },
    "Workspace": {
      "$className": "Workspace",
      "$ignoreUnknownInstances": true,
      "$path": "src/Workspace"
    }
  }
}

Just the default JSON, it's detecting all the folders and modules and such

[unreal leaf]

Hmm

Maybe try the latest version of Rojo?

Could be the culprit

And reinstall the plugin on Studio too maybe

[warped moss]

My plugin is a bit behind, 7.2.1, I guess I just need to go update that!

[unreal leaf]

Yeah probably some incompatibility issues with Studio

So updating should help

🙏

[warped moss]

Yeah so uhm. Turns out I just wasn't even using the right path for my module.

I'm doing code cleanup so I wasn't actually playing the game for it to yell at me about that.

cough cough

[unreal leaf]

😹😹

[warped moss]

So now it uhm... all works as it should...

I am a professional software engineer. I swear.

No Rojo or anything. Just me being a doofus.

[unreal leaf]

😹

Imposter syndrome at its core

Have fun. 💪

[warped moss]

@unreal leaf sorry for the ping, I just have one last type checking related question. How do you handle docs?

So like

--[[
    Checks to see if this class has the ability with the given key
    
    @param abilityKey - The key of the ability to check for
]]

is how I'd do it for regular functions.

But I notice that it doesn't appear on the typed function when I hover. Trying to apply that same style of doc above the function type doesn't seem to work either

I do get something when I hover over the function, but just not my written docs.

Is this a "sorry bud, use Rojo" situation?

[unreal leaf]

https://stackoverflow.com/questions/78633143/add-a-docstring-to-a-lua-function-in-roblox-studio

@warped moss

If you want extensive support for docstrings then yeah use something like VSCode it seems.

Otherwise apparently single line comments suffice? Not on my pc atm so can’t verify.