@tlua/tlua-linux-arm 0.0.38 → 0.0.40

package/lib/lib.luajit.d.tlua

@@ -47,24 +47,6 @@ interface LuaPairsIterator<K, V> {
 // user signatures, resolved specially by the checker.
 type NoInfer<T> = intrinsic;
 
-// Inert Promise surface. tlua has no await and no Promise semantics; these
-// exist only so `import(...)` and the residual `async` modifier keep
-// type-checking. Deliberately member-poor.
-interface PromiseLike<T> {
-    then(onfulfilled?: (value: T) => any, onrejected?: (reason: any) => any): PromiseLike<T>;
-}
-
-interface Promise<T> {
-    then(onfulfilled?: (value: T) => any, onrejected?: (reason: any) => any): Promise<T>;
-}
-
-interface PromiseConstructor {
-    readonly prototype: Promise<any>;
-    resolve<T>(value: T | PromiseLike<T>): Promise<T>;
-    resolve(): Promise<void>;
-}
-declare Promise: PromiseConstructor;
-
 // The erasable type-operator utilities inherited from TypeScript. These are
 // pure type sugar over machinery the checker supports (mapped, conditional,
 // and intrinsic string types); no runtime surface.
@@ -109,14 +91,6 @@ type NonNullable<T> = T & {};
 /** Obtain the return type of a function type */
 type ReturnType<T extends (...: any) => any> = T extends (...: any) => infer R ? R : any;
 
-/** Recursively unwrap the value type of a thenable */
-type Awaited<T> = T extends null | undefined ? T :
-    T extends table & { then(onfulfilled: infer F, ...: infer _): any; } ?
-        F extends ((value: infer V, ...: infer _) => any) ?
-            Awaited<V> :
-        never :
-    T;
-
 /** Convert string literal type to uppercase */
 type Uppercase<S extends string> = intrinsic;
 
@@ -132,7 +106,7 @@ type Uncapitalize<S extends string> = intrinsic;
 interface LuaMetatable<T extends table> {
     __index?: Table<any, any> | ((value: T, key: any) => any);
     __newindex?: Table<any, any> | ((value: T, key: any, newValue: any) => void);
-    __call?: async (value: T, ...: any) => (any?, ...any);
+    __call?: suspend (value: T, ...: any) => (any?, ...any);
     __tostring?: (value: T) => string;
     __len?: (value: T) => number;
     __unm?: (value: T) => any;
@@ -217,6 +191,10 @@ declare function xpcall(fn: function, handler: (message: any) => any, ...: any):
  * generic `T`. The whole coroutine module stays erased: resume/yield because a
  * `thread` is opaque and carries no packs (Luau makes the same call), and wrap
  * because a wrapped call exchanges values with `yield`, not with fn's packs.
+ * That erasure is about packs only -- `coroutine.yield` still carries the suspend
+ * flag, because it is the primitive the whole contract is founded on. `resume`
+ * and a wrapped function do not: driving a coroutine from ordinary code is what
+ * they are for.
  *
  * The signatures of setmetatable and getmetatable stay deliberately plain: the
  * checker pairs a table with its metatable itself. A call to the *global*
@@ -228,7 +206,7 @@ declare function xpcall(fn: function, handler: (message: any) => any, ...: any):
  * metamethods also dispatch ambiently: a declared type that states them as
  * `__add`-style members (a userdata class like GMod's Vector) overloads the
  * operators with no setmetatable in sight; __index, __newindex and __call stay
- * pairing-only. The __call slot is async-typed so a handler may carry the
+ * pairing-only. The __call slot is suspend-typed so a handler may carry the
  * coroutine contract -- a sync handler satisfies it too, and the pairing's call
  * surface keeps whichever flavor the handler declares.
  * debug.setmetatable and debug.getmetatable bypass __metatable protection. A
@@ -250,7 +228,16 @@ interface CoroutineLib {
     // parameter/return packs would assert types that are wrong for every coroutine
     // that yields, which is what wrap is for.
     wrap(fn: function): function;
-    yield(...: any): (any?, ...any);
+    // `yield` is the primitive that actually suspends the running coroutine, so
+    // it anchors the suspend contract: everything else marked `suspend` is marked
+    // by hand, and this is the one signature the contract can be founded on. A
+    // function whose body yields must therefore declare itself `suspend`, and a
+    // yield reached from ordinary code -- the runtime's "attempt to yield from
+    // outside a coroutine" -- is a diagnostic instead. The `suspend` modifier is
+    // illegal in an ambient context, so this is a property carrying a suspend
+    // function *type*; the argument and result types stay erased exactly as
+    // resume's do. Widening to the `function` top type is the escape hatch.
+    yield: suspend (...: any) => (any?, ...any);
 }
 
 declare coroutine: CoroutineLib;
@@ -466,6 +453,7 @@ interface DebugLib {
     sethook(thread: thread, hook?: function, mask?: string, count?: number): void;
     setlocal(level: number, localIndex: number, value: any): string | nil;
     setlocal(thread: thread, level: number, localIndex: number, value: any): string | nil;
+    setmetatable<T extends table>(value: T, metatable: LuaMetatable<T> | nil): T;
     setmetatable<T>(value: T, metatable: table | nil): T;
     setupvalue(fn: function, index: number, value: any): string | nil;
     traceback(message?: any, level?: number): string;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tlua/tlua-linux-arm",
-    "version": "0.0.38",
+    "version": "0.0.40",
     "license": "Apache-2.0",
     "author": "tlua",
     "homepage": "https://github.com/apyrr/tlua",
@@ -32,7 +32,7 @@
     "exports": {
         "./package.json": "./package.json"
     },
-    "gitHead": "fd72da4a6df495275246ceafaf390894567f3e47",
+    "gitHead": "f31116b7dc888e8bd7156171bc2027703f38ae09",
     "publishConfig": {
         "access": "public",
         "tag": "latest"