IntelliSense and Type Tracking for GLua

GLua Language Server uses a combination of static analysis and the bundled Garry’s Mod wiki dataset to provide precise IntelliSense across your entire workspace. It tracks types through function calls, string literals, loops, and metatables so that completion and hover information always resolve to the correct class.

Type tracking

The server understands how common GLua functions transform types and propagates that knowledge through your code.

Player lookup

When you call player.GetByID, the server knows the result is a Player entity:

local ply = player.GetByID(1)
ply:Kick("Reason") -- completion offers Player methods

Panel creation

vgui.Create with a known panel class returns that type:

local frame = vgui.Create("DFrame")
frame:SetTitle("Hello") -- completion offers DFrame methods

Loop iteration

ipairs over a player list types each element as Player:

for _, ply in ipairs(player.GetAll()) do
    ply:ChatPrint("Hello") -- ply is typed as Player
end

Typed hook sender

When you register a hook with a typed sender parameter, the callback receives the correct type:

hook.Add("PlayerSay", "MyAddon", function(sender, text, teamChat)
    sender:Kick("Spam") -- sender is typed as Player
end)

Entity methods

Inside ENT methods, self is typed as Entity:

function ENT:Initialize()
    self:SetModel("models/props_c17/oildrum001.mdl") -- self is Entity
end

Typing your own functions

You can add explicit types to your own functions with annotations, or let the server infer them from usage.

---@param target Player
---@param message string
---@return boolean
function NotifyPlayer(target, message)
    target:ChatPrint(message)
    return true
end

function NotifyPlayer(target, message)
    target:ChatPrint(message) -- target inferred as Player from ChatPrint call
    return true               -- return type inferred as boolean
end

Supported annotation tags

GLua Language Server uses the same annotation dialect as Lua Language Server.

Tag	Purpose	Example
`---@param`	Declare parameter type	`---@param ply Player`
`---@return`	Declare return type	`---@return boolean`
`---@type`	Cast an expression	`---@type Player`
`---@class`	Define a custom class	`---@class MyPanel : DPanel`
`---@field`	Add a field to a class	`---@field Name string`
`---@deprecated`	Mark as deprecated	`---@deprecated Use NewFunc instead`

You can also use union types, optional parameters, and array syntax:

---@param items (string|number)[]
---@param options? table
---@return string|nil

How inference falls back

When the server cannot determine an exact type, it uses the following strategy:

Ambiguous sets — If an object could be one of several types, the server finds the most specific common base class. For example, a value that is sometimes a Player and sometimes an NPC falls back to Entity.
Unrecognisable values — If a type cannot be inferred at all, it falls back to any. You will still get generic Lua completions, but no Garry’s Mod specific methods.
Explicit annotations always win — If you add a ---@type or ---@param annotation, it overrides any inferred type.

Add explicit annotations at module boundaries (shared files called from multiple realms, library functions used by other addons) to improve completion accuracy across your entire workspace.

Get Started

Features

Configuration

Reference

IntelliSense and Type Tracking for GLua

Type tracking

Player lookup

Panel creation

Loop iteration

Typed hook sender

Entity methods

Typing your own functions

Supported annotation tags

How inference falls back

​Type tracking

​Player lookup

​Panel creation

​Loop iteration

​Typed hook sender

​Entity methods

​Typing your own functions

​Supported annotation tags

​How inference falls back

Type tracking

Player lookup

Panel creation

Loop iteration

Typed hook sender

Entity methods

Typing your own functions

Supported annotation tags

How inference falls back