Upgrade tstl and make use of language-extensions instead of annotations (#22)

* Add release workflow

* Upgraded to tstl language extensions

* Add tsconfig to package

* Fixed tests

* Added 5.4 tests

* prettier

* Added reference to language extension types

* Move language extensions reference to core

Author: Perryvw

.github/workflows/release.yml

@@ -0,0 +1,23 @@
+name: Release
+
+on:
+    push:
+        tags: '*'
+
+jobs:
+    release:
+        name: Release
+        runs-on: ubuntu-latest
+
+        steps:
+            - uses: actions/checkout@v2
+            - name: Use Node.js 12.13.1
+              uses: actions/setup-node@v1
+              with:
+                  node-version: 12.13.1
+                  registry-url: 'https://registry.npmjs.org'
+            - run: npm ci
+            - run: npm run build
+            - run: npm publish
+              env:
+                  NODE_AUTH_TOKEN: ${{ secrets.NPM_AUTH_TOKEN }}

core/coroutine.d.ts

@@ -24,9 +24,11 @@ declare namespace coroutine {
      * values passed to yield (when the coroutine yields) or any values returned
      * by the body function (when the coroutine terminates). If there is any
      * error, resume returns false plus the error message.
-     * @tupleReturn
      */
-    function resume(co: LuaThread, ...val: any[]): [true, ...any[]] | [false, string];
+    function resume(
+        co: LuaThread,
+        ...val: any[]
+    ): LuaMultiReturn<[true, ...any[]] | [false, string]>;
 
     /**
      * Returns the status of coroutine co, as a string: "running", if the
@@ -45,12 +47,11 @@ declare namespace coroutine {
      * same values returned by resume, except the first boolean. In case of error,
      * propagates the error.
      */
-    function wrap(f: (...args: any[]) => any): /** @tupleReturn */ (...args: any[]) => any[];
+    function wrap(f: (...args: any[]) => any): (...args: any[]) => LuaMultiReturn<any[]>;
 
     /**
      * Suspends the execution of the calling coroutine. Any arguments to yield are
      * passed as extra results to resume.
-     * @tupleReturn
      */
-    function yield(...args: any[]): any[];
+    function yield(...args: any[]): LuaMultiReturn<any[]>;
 }

core/debug.d.ts

@@ -32,9 +32,10 @@ declare namespace debug {
      * Returns the current hook settings of the thread, as three values: the
      * current hook function, the current hook mask, and the current hook count
      * (as set by the debug.sethook function).
-     * @tupleReturn
      */
-    function gethook(thread?: LuaThread): [undefined, 0] | [Function, number, string?];
+    function gethook(
+        thread?: LuaThread
+    ): LuaMultiReturn<[undefined, 0] | [Function, number, string?]>;
 
     interface FunctionInfo<T extends Function = Function> {
         /**
@@ -126,9 +127,8 @@ declare namespace debug {
      * Variable names starting with '(' (open parenthesis) represent variables
      * with no known names (variables from chunks saved without debug
      * information).
-     * @tupleReturn
      */
-    function getupvalue(f: Function, up: number): [string, any] | [];
+    function getupvalue(f: Function, up: number): LuaMultiReturn<[string, any] | []>;
 
     /**
      * Returns the Lua value associated to u. If u is not a full userdata, returns

core/global.d.ts

@@ -6,10 +6,6 @@
 
 type LuaThread = { readonly __internal__: unique symbol };
 type LuaUserdata = { readonly __internal__: unique symbol };
-/** @luaIterator */
-type LuaIterable<T> = Iterable<T> & { readonly __internal__: unique symbol };
-/** @luaIterator @tupleReturn */
-type LuaTupleIterable<T extends any[]> = Iterable<T> & { readonly __internal__: unique symbol };
 
 /**
  * A global variable (not a function) that holds a string containing the running
@@ -124,7 +120,7 @@ declare function getmetatable<T extends object>(object: T): LuaMetatable<T> | un
  * will iterate over the key–value pairs (1,t[1]), (2,t[2]), ..., up to the
  * first nil value.
  */
-declare function ipairs<T>(t: Record<number, T>): LuaTupleIterable<[number, T]>;
+declare function ipairs<T>(t: Record<number, T>): LuaIterable<LuaMultiReturn<[number, T]>>;
 
 /**
  * Allows a program to traverse all fields of a table. Its first argument is a
@@ -142,9 +138,8 @@ declare function ipairs<T>(t: Record<number, T>): LuaTupleIterable<[number, T]>;
  * The behavior of next is undefined if, during the traversal, you assign any
  * value to a non-existent field in the table. You may however modify existing
  * fields. In particular, you may clear existing fields.
- * @tupleReturn
  */
-declare function next(table: object, index?: any): [any, any] | [];
+declare function next(table: object, index?: any): LuaMultiReturn<[any, any] | []>;
 
 /**
  * If t has a metamethod __pairs, calls it with t as argument and returns the
@@ -158,7 +153,7 @@ declare function next(table: object, index?: any): [any, any] | [];
  * See function next for the caveats of modifying the table during its
  * traversal.
  */
-declare function pairs<T>(t: T): LuaTupleIterable<[keyof T, T[keyof T]]>;
+declare function pairs<T>(t: T): LuaIterable<LuaMultiReturn<[keyof T, T[keyof T]]>>;
 
 /**
  * Calls function f with the given arguments in protected mode. This means that
@@ -167,19 +162,17 @@ declare function pairs<T>(t: T): LuaTupleIterable<[keyof T, T[keyof T]]>;
  * is true if the call succeeds without errors. In such case, pcall also returns
  * all results from the call, after this first result. In case of any error,
  * pcall returns false plus the error message.
- * @tupleReturn
  */
 declare function pcall<This, Args extends any[], R>(
     f: (this: This, ...args: Args) => R,
     context: This,
     ...args: Args
-): [true, R] | [false, string];
+): LuaMultiReturn<[true, R] | [false, string]>;
 
-/** @tupleReturn */
 declare function pcall<A extends any[], R>(
     f: (this: void, ...args: A) => R,
     ...args: A
-): [true, R] | [false, string];
+): LuaMultiReturn<[true, R] | [false, string]>;
 
 /**
  * Receives any number of arguments and prints their values to stdout, using the
@@ -222,9 +215,8 @@ declare function rawset<T extends object, K extends keyof T>(table: T, index: K,
  * negative number indexes from the end (-1 is the last argument). Otherwise,
  * index must be the string "#", and select returns the total number of extra
  * arguments it received.
- * @tupleReturn
  */
-declare function select<T>(index: number, ...args: T[]): T[];
+declare function select<T>(index: number, ...args: T[]): LuaMultiReturn<T[]>;
 
 /**
  * If index is a number, returns all arguments after argument number index; a

core/index.d.ts

@@ -1,3 +1,5 @@
+/// <reference types="typescript-to-lua/language-extensions" />
+
 /// <reference path="./coroutine.d.ts" />
 /// <reference path="./debug.d.ts" />
 /// <reference path="./global.d.ts" />

core/io.d.ts

@@ -60,8 +60,10 @@ declare namespace io {
     function lines<T extends FileReadFormat[]>(
         filename?: string,
         ...formats: T
-    ): LuaTupleIterable<
-        [] extends T ? [string] : { [P in keyof T]: T[P] extends 'n' ? number : string }
+    ): LuaIterable<
+        LuaMultiReturn<
+            [] extends T ? [string] : { [P in keyof T]: T[P] extends 'n' ? number : string }
+        >
     >;
 
     /**
@@ -80,9 +82,11 @@ declare namespace io {
      *
      * The mode string can also have a 'b' at the end, which is needed in some
      * systems to open the file in binary mode.
-     * @tupleReturn
      */
-    function open(filename: string, mode?: string): [LuaFile] | [undefined, string, number];
+    function open(
+        filename: string,
+        mode?: string
+    ): LuaMultiReturn<[LuaFile] | [undefined, string, number]>;
 
     /**
      * Similar to io.input, but operates over the default output file.
@@ -100,7 +104,6 @@ declare namespace io {
 
     /**
      * Equivalent to io.input():read(···).
-     * @tupleReturn
      */
     const read: LuaFile['read'];
 
@@ -120,9 +123,8 @@ declare namespace io {
 
     /**
      * Equivalent to io.output():write(···).
-     * @tupleReturn
      */
-    function write(...args: (string | number)[]): [LuaFile] | [undefined, string];
+    function write(...args: (string | number)[]): LuaMultiReturn<[LuaFile] | [undefined, string]>;
 }
 
 interface LuaFile {
@@ -157,8 +159,10 @@ interface LuaFile {
      */
     lines<T extends FileReadFormat[]>(
         ...formats: T
-    ): LuaTupleIterable<
-        [] extends T ? [string] : { [P in keyof T]: T[P] extends 'n' ? number : string }
+    ): LuaIterable<
+        LuaMultiReturn<
+            [] extends T ? [string] : { [P in keyof T]: T[P] extends 'n' ? number : string }
+        >
     >;
 
     /**
@@ -188,11 +192,10 @@ interface LuaFile {
      *   string, or nil on end of file.
      *
      * The formats "l" and "L" should be used only for text files.
-     * @tupleReturn
      */
     read<T extends FileReadFormat[]>(
         ...formats: T
-    ): { [P in keyof T]?: T[P] extends 'n' ? number : string };
+    ): LuaMultiReturn<{ [P in keyof T]?: T[P] extends 'n' ? number : string }>;
 
     /**
      * Sets and geionts the file position, measured from the beginning of the
@@ -212,9 +215,11 @@ interface LuaFile {
      * the call file:seek("set") sets the position to the beginning of the file
      * (and returns 0); and the call file:seek("end") sets the position to the end
      * of the file, and returns its size.
-     * @tupleReturn
      */
-    seek(whence?: 'set' | 'cur' | 'end', offset?: number): [number] | [undefined, string];
+    seek(
+        whence?: 'set' | 'cur' | 'end',
+        offset?: number
+    ): LuaMultiReturn<[number] | [undefined, string]>;
 
     /**
      * Sets the buffering mode for an output file. There are three available
@@ -237,7 +242,6 @@ interface LuaFile {
      *
      * In case of success, this function returns file. Otherwise it returns nil
      * plus a string describing the error.
-     * @tupleReturn
      */
-    write(...args: (string | number)[]): [LuaFile] | [undefined, string];
+    write(...args: (string | number)[]): LuaMultiReturn<[LuaFile] | [undefined, string]>;
 }

core/math.d.ts

@@ -77,9 +77,8 @@ declare namespace math {
     /**
      * Returns the integral part of x and the fractional part of x. Its second
      * result is always a float.
-     * @tupleReturn
      */
-    function modf(x: number): [number, number];
+    function modf(x: number): LuaMultiReturn<[number, number]>;
 
     /**
      * The value of π.

core/os.d.ts

@@ -107,17 +107,15 @@ declare namespace os {
      * Deletes the file (or empty directory, on POSIX systems) with the given
      * name. If this function fails, it returns nil, plus a string describing the
      * error and the error code. Otherwise, it returns true.
-     * @tupleReturn
      */
-    function remove(filename: string): [true] | [undefined, string];
+    function remove(filename: string): LuaMultiReturn<[true] | [undefined, string]>;
 
     /**
      * Renames the file or directory named oldname to newname. If this function
      * fails, it returns nil, plus a string describing the error and the error
      * code. Otherwise, it returns true.
-     * @tupleReturn
      */
-    function rename(oldname: string, newname: string): [true] | [undefined, string];
+    function rename(oldname: string, newname: string): LuaMultiReturn<[true] | [undefined, string]>;
 
     /**
      * Sets the current locale of the program. locale is a system-dependent string

core/string.d.ts

@@ -26,8 +26,7 @@ declare namespace string {
      * Numeric codes are not necessarily portable across platforms.
      */
     function byte(s: string, i?: number): number;
-    /** @tupleReturn */
-    function byte(s: string, i?: number, j?: number): number[];
+    function byte(s: string, i?: number, j?: number): LuaMultiReturn<number[]>;
 
     /**
      * Receives zero or more integers. Returns a string with length equal to the
@@ -57,14 +56,13 @@ declare namespace string {
      *
      * If the pattern has captures, then in a successful match the captured values
      * are also returned, after the two indices.
-     * @tupleReturn
      */
     function find(
         s: string,
         pattern: string,
         init?: number,
         plain?: boolean
-    ): [number, number, ...string[]] | [];
+    ): LuaMultiReturn<[number, number, ...string[]] | []>;
 
     /**
      * Returns a formatted version of its variable number of arguments following
@@ -123,7 +121,7 @@ declare namespace string {
      * For this function, a caret '^' at the start of a pattern does not work as
      * an anchor, as this would prevent the iteration.
      */
-    function gmatch(s: string, pattern: string): LuaTupleIterable<string[]>;
+    function gmatch(s: string, pattern: string): LuaIterable<LuaMultiReturn<string[]>>;
 
     /**
      * Returns a copy of s in which all (or the first n, if given) occurrences of
@@ -151,14 +149,13 @@ declare namespace string {
      * string or a number, then it is used as the replacement string; otherwise,
      * if it is false or nil, then there is no replacement (that is, the original
      * match is kept in the string).
-     * @tupleReturn
      */
     function gsub(
         s: string,
         pattern: string,
         repl: string | Record<string, string> | ((...matches: string[]) => string),
         n?: number
-    ): [string, number];
+    ): LuaMultiReturn<[string, number]>;
 
     /**
      * Receives a string and returns its length. The empty string "" has length 0.
@@ -179,9 +176,8 @@ declare namespace string {
      * returns nil. If pattern specifies no captures, then the whole match is
      * returned. A third, optional numeric argument init specifies where to start
      * the search; its default value is 1 and can be negative.
-     * @tupleReturn
      */
-    function match(s: string, pattern: string, init?: number): string[];
+    function match(s: string, pattern: string, init?: number): LuaMultiReturn<string[]>;
 
     /**
      * Returns a string that is the string s reversed.