How do I forward declare global variables in strict mode?

[davidgiven]

I have code which approximately does this:

local function something()
    thisGlobal = { ... }
end

local function somethingElse()
    print(thisGlobal)
end

The strict type checker:

a. complains about unknown global variables both times
b. can't tell what the type of thisGlobal is.

I've tried defining the type of the global in my .d.lua file, but that's ignored --- presumably because globals defined there go into the immutable globals table rather than the mutable shadow globals table which assigning to _G affects.

Is there any way around this?

(The two functions are in different chunks sharing the same global table, so using local isn't an option here.)

[JohnnyMorganz]

I'm able to get the typechecker to register thisGlobal as a readable global variable, with the following definitions file:

declare thisGlobal: {
    x: number,
    y: number,
}

which partially solves your issue.
It still errors at the assignment though with "BuiltinGlobalWrite" error. It might be nice if there was a way to specify writable globals in the typechecker

[davidgiven]

I still get unknown global errors on reads even if I declare them like that --- for a while I thought it wasn't doing anything it all, but it does appear to set the type correctly. This also has the downside that I end up having to move the majority of my type definitions into the definitions file, which isn't much fun when dealing with complex objects like classes. (And fails completly for anything with type Something = typeof(setmetatable(...))...

Declaring global functions works fine, though. The typechecker will let me both refer to them define them with a function GlobalFunction variable without complaint.

[davidgiven]

I believe I've found a solution to this. The reason for at least some of the problem is that the type check for global assignment only checks the bindings for the current module, and not the current module's parent, which is where the type definition file puts its definitions. I'm not sure why defining global functions works, but presumably function is going through a different code path.

What I ended up doing was applying the fix I described in #867. This then allows me to declare globals inline by setting allowDeclarationSyntax in the parse options. These definitions go into the current module, which means the lvalue type checks finds them:

declare thisGlobal: ThisGlobalType

local function something()
    thisGlobal = { ... }
end

local function somethingElse()
    print(thisGlobal)
end

...which is kind of ideal for my use case. In #867 I did say that even with the change, the code no longer compiled, but that doesn't seem to be the case any more. Which is nice!

(Disclaimer: I'm still picking away at type errors and it's entirely possible that this has caused something else to go wrong which I haven't noticed yet...)