Type definition files, questions & feedback

[petrihakkinen]

Hi!

I've got some questions and feedback regarding the typechecker and type definition files.

1. Let's say I have a native function which does the following:

test(key, value)  -- stores a key-value pair, key is string, value can be anything, returns nothing
test(key) 	-- retrieves the value of a key

There are (at least) two ways to write the type definition for this function:

declare test1: (((key: string, value: any) -> ()) & ((key: string) -> any))
declare test2: (((key: string) -> any) & ((key: string, value: any) -> ()))

Let's use these to typecheck the following script:

tonumber(test1("foo"))	-- Error: Argument count mismatch. Function expects 1 argument, but none are specified
tonumber(test2("foo"))	-- Ok

So it seems the two type definitions are not really equivalent. Is this expected behavior? Does ordering in type unions matter, or this a bug in the typechecker?

2. How do I declare var-args of some specific type at the end of function argument list?

For example, let's say I have a function which takes any number of strings: foo("a", "b", "c"...).

In EmbeddedBuiltinDefinitions.cpp I can see "...number" used in the type definition of bit32.band, but
when I try to use it with global function declaration, I get an error:

declare function test(...string): ()	-- Error!
declare function test(...: ...string): ()	-- Error!

Well, actually I don't get an error message :) but LoadDefinitionFileResult.success is false after loadDefinitionFile call.

3. There seems to be some other cases where loading a broken type definition does not produce an error message.

For example,

declare draw_box: ((x: number, y: number, z: number, width, height, depth) -> ())

This causes loadDefinitionFile to fail without producing an error message.

4. Is there some standard file extension that is used for type definition files?

Feedback:

My number one wish would be simplified syntax for declaring function overloads. Something like this would be ideal:

declare function foo(bar: string): ()
declare function foo(bar: string, baz: number, something: boolean): ()

This would be equal to but much more readable than:

declare foo: (((bar: string): ()) & ((bar: string, baz: number, something: boolean): ()))

(My wish number two would be documentation for the type definitions but I guess the syntax has not been finalized yet...)

[JohnnyMorganz]

(I'll prefix this by saying these are just my own observations, and they might be wrong)

2. How do I declare var-args of some specific type at the end of function argument list?

Its similar to how it works in general Luau syntax: https://luau-lang.org/typecheck#variadic-types
In function declaration syntax, it should be

declare function foo(...: number): ()

whilst in function type syntax, it'll be

type Foo = (...number) -> ()

3. There seems to be some other cases where loading a broken type definition does not produce an error message.

Note that the error message is not stored directly in the LoadDefinitionResult.
For parse errors, they will be in result.parseResult.errors
For type errors, they will be in loadResult.module->errors
https://github.com/JohnnyMorganz/luau-analyze-rojo/blob/master/main.cpp#L791-L803

1. Let's say I have a native function which does the following: ...
   So it seems the two type definitions are not really equivalent. Is this expected behavior? Does ordering in type unions matter, or this a bug in the typechecker?

AIUI, the type checker currently works greedily through function overloads, and goes with the first one which matches.
Technically, for test1, the arguments match the first overload (where value = nil), so the return type is set as (), so tonumber errors. Sounds not ideal though

4. Is there some standard file extension that is used for type definition files?

I've just been using .d.luau (https://github.com/JohnnyMorganz/luau-lsp/blob/main/scripts/globalTypes.d.lua), but I am also interested in knowing this :)

My number one wish would be simplified syntax for declaring function overloads. Something like this would be ideal:

This syntax is valid for class method definitions, curiously it isn't for global functions 🤔. Would be great to see this be possible once definition syntax is stabilised

declare class Foo
     function overloaded(self, x: string): string
     function overloaded(self, x: number): number
end

[petrihakkinen]

Many thanks! Somehow I had missed the error vec in Module entirely...

I'll mark as answered although my wish for simplified syntax for declaring global function overloads still stands :)

[alexmccord]

Definition files are currently incomplete, and that's actually one of the feature that's not added yet. Feel free to make a pull request to get this in!