CoCalc -- EmbeddedBuiltinDefinitions.cpp

GitHub Repository: Roblox/luau
Path: blob/master/Analysis/src/EmbeddedBuiltinDefinitions.cpp
²⁷²⁵ views
1
// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
2
#include "Luau/BuiltinDefinitions.h"
3

4
LUAU_FASTFLAGVARIABLE(LuauTypeCheckerUdtfRenameClassToExtern)
5
LUAU_FASTFLAGVARIABLE(LuauNewMathConstantsAnalysis)
6
LUAU_FASTFLAGVARIABLE(LuauTypeCheckerVectorReadOnly)
7
LUAU_FASTFLAG(LuauIntegerLibrary)
8
LUAU_FASTFLAG(LuauIntegerType)
9

10
namespace Luau
11
{
12

13
static constexpr const char* kBuiltinDefinitionBaseSrc = R"BUILTIN_SRC(
14

15
@checked declare function require(target: any): any
16

17
@checked declare function getfenv(target: any): { [string]: any }
18

19
declare _G: any
20
declare _VERSION: string
21

22
declare function gcinfo(): number
23

24
declare function print<T...>(...: T...)
25

26
declare function type<T>(value: T): string
27
declare function typeof<T>(value: T): string
28

29
-- `assert` has a magic function attached that will give more detailed type information
30
declare function assert<T>(value: T, errorMessage: string?): T
31
declare function error<T>(message: T, level: number?): never
32

33
declare function tostring<T>(value: T): string
34
declare function tonumber<T>(value: T, radix: number?): number?
35

36
declare function rawequal<T1, T2>(a: T1, b: T2): boolean
37
declare function rawget<K, V>(tab: {[K]: V}, k: K): V?
38
declare function rawset<K, V>(tab: {[K]: V}, k: K, v: V): {[K]: V}
39
declare function rawlen<K, V>(obj: {[K]: V} | string): number
40

41
declare function setfenv<T..., R...>(target: number | (T...) -> R..., env: {[string]: any}): ((T...) -> R...)?
42

43
declare function ipairs<V>(tab: {V}): (({V}, number) -> (number?, V), {V}, number)
44

45
declare function pcall<A..., R...>(f: (A...) -> R..., ...: A...): (boolean, R...)
46

47
-- FIXME: The actual type of `xpcall` is:
48
-- <E, A..., R1..., R2...>(f: (A...) -> R1..., err: (E) -> R2..., A...) -> (true, R1...) | (false, R2...)
49
-- Since we can't represent the return value, we use (boolean, R1...).
50
declare function xpcall<E, A..., R1..., R2...>(f: (A...) -> R1..., err: (E) -> R2..., ...: A...): (boolean, R1...)
51

52
-- `select` has a magic function attached to provide more detailed type information
53
declare function select<A...>(i: string | number, ...: A...): ...any
54

55
-- FIXME: This type is not entirely correct - `loadstring` returns a function or
56
-- (nil, string).
57
declare function loadstring<A...>(src: string, chunkname: string?): (((A...) -> any)?, string?)
58

59
@checked declare function newproxy(mt: boolean?): any
60

61
-- Cannot use `typeof` here because it will produce a polytype when we expect a monotype.
62
declare function unpack<V>(tab: {V}, i: number?, j: number?): ...V
63

64
)BUILTIN_SRC";
65

66
static constexpr const char* kBuiltinDefinitionBit32Src = R"BUILTIN_SRC(
67

68
declare bit32: {
69
    band: @checked (...number) -> number,
70
    bor: @checked (...number) -> number,
71
    bxor: @checked (...number) -> number,
72
    btest: @checked (number, ...number) -> boolean,
73
    rrotate: @checked (x: number, disp: number) -> number,
74
    lrotate: @checked (x: number, disp: number) -> number,
75
    lshift: @checked (x: number, disp: number) -> number,
76
    arshift: @checked (x: number, disp: number) -> number,
77
    rshift: @checked (x: number, disp: number) -> number,
78
    bnot: @checked (x: number) -> number,
79
    extract: @checked (n: number, field: number, width: number?) -> number,
80
    replace: @checked (n: number, v: number, field: number, width: number?) -> number,
81
    countlz: @checked (n: number) -> number,
82
    countrz: @checked (n: number) -> number,
83
    byteswap: @checked (n: number) -> number,
84
}
85

86
)BUILTIN_SRC";
87

88
static constexpr const char* kBuiltinDefinitionMathSrc = R"BUILTIN_SRC(
89

90
declare math: {
91
    frexp: @checked (n: number) -> (number, number),
92
    ldexp: @checked (s: number, e: number) -> number,
93
    fmod: @checked (x: number, y: number) -> number,
94
    modf: @checked (n: number) -> (number, number),
95
    pow: @checked (x: number, y: number) -> number,
96
    exp: @checked (n: number) -> number,
97

98
    ceil: @checked (n: number) -> number,
99
    floor: @checked (n: number) -> number,
100
    abs: @checked (n: number) -> number,
101
    sqrt: @checked (n: number) -> number,
102

103
    log: @checked (n: number, base: number?) -> number,
104
    log10: @checked (n: number) -> number,
105

106
    rad: @checked (n: number) -> number,
107
    deg: @checked (n: number) -> number,
108

109
    sin: @checked (n: number) -> number,
110
    cos: @checked (n: number) -> number,
111
    tan: @checked (n: number) -> number,
112
    sinh: @checked (n: number) -> number,
113
    cosh: @checked (n: number) -> number,
114
    tanh: @checked (n: number) -> number,
115
    atan: @checked (n: number) -> number,
116
    acos: @checked (n: number) -> number,
117
    asin: @checked (n: number) -> number,
118
    atan2: @checked (y: number, x: number) -> number,
119

120
    min: @checked (number, ...number) -> number,
121
    max: @checked (number, ...number) -> number,
122

123
    pi: number,
124
    huge: number,
125
    nan: number,
126
    e: number,
127
    phi: number,
128
    sqrt2: number,
129
    tau: number,
130

131
    randomseed: @checked (seed: number) -> (),
132
    random: @checked (number?, number?) -> number,
133

134
    sign: @checked (n: number) -> number,
135
    clamp: @checked (n: number, min: number, max: number) -> number,
136
    noise: @checked (x: number, y: number?, z: number?) -> number,
137
    round: @checked (n: number) -> number,
138
    map: @checked (x: number, inmin: number, inmax: number, outmin: number, outmax: number) -> number,
139
    lerp: @checked (a: number, b: number, t: number) -> number,
140

141
    isnan: @checked (x: number) -> boolean,
142
    isinf: @checked (x: number) -> boolean,
143
    isfinite: @checked (x: number) -> boolean,
144
}
145

146
)BUILTIN_SRC";
147

148
// Remove with FFlag::LuauNewMathConstantsAnalysis
149
static constexpr const char* kBuiltinDefinitionMathSrc_DEPRECATED = R"BUILTIN_SRC(
150

151
declare math: {
152
    frexp: @checked (n: number) -> (number, number),
153
    ldexp: @checked (s: number, e: number) -> number,
154
    fmod: @checked (x: number, y: number) -> number,
155
    modf: @checked (n: number) -> (number, number),
156
    pow: @checked (x: number, y: number) -> number,
157
    exp: @checked (n: number) -> number,
158

159
    ceil: @checked (n: number) -> number,
160
    floor: @checked (n: number) -> number,
161
    abs: @checked (n: number) -> number,
162
    sqrt: @checked (n: number) -> number,
163

164
    log: @checked (n: number, base: number?) -> number,
165
    log10: @checked (n: number) -> number,
166

167
    rad: @checked (n: number) -> number,
168
    deg: @checked (n: number) -> number,
169

170
    sin: @checked (n: number) -> number,
171
    cos: @checked (n: number) -> number,
172
    tan: @checked (n: number) -> number,
173
    sinh: @checked (n: number) -> number,
174
    cosh: @checked (n: number) -> number,
175
    tanh: @checked (n: number) -> number,
176
    atan: @checked (n: number) -> number,
177
    acos: @checked (n: number) -> number,
178
    asin: @checked (n: number) -> number,
179
    atan2: @checked (y: number, x: number) -> number,
180

181
    min: @checked (number, ...number) -> number,
182
    max: @checked (number, ...number) -> number,
183

184
    pi: number,
185
    huge: number,
186

187
    randomseed: @checked (seed: number) -> (),
188
    random: @checked (number?, number?) -> number,
189

190
    sign: @checked (n: number) -> number,
191
    clamp: @checked (n: number, min: number, max: number) -> number,
192
    noise: @checked (x: number, y: number?, z: number?) -> number,
193
    round: @checked (n: number) -> number,
194
    map: @checked (x: number, inmin: number, inmax: number, outmin: number, outmax: number) -> number,
195
    lerp: @checked (a: number, b: number, t: number) -> number,
196

197
    isnan: @checked (x: number) -> boolean,
198
    isinf: @checked (x: number) -> boolean,
199
    isfinite: @checked (x: number) -> boolean,
200
}
201

202
)BUILTIN_SRC";
203

204
static constexpr const char* kBuiltinDefinitionOsSrc = R"BUILTIN_SRC(
205

206
type DateTypeArg = {
207
    year: number,
208
    month: number,
209
    day: number,
210
    hour: number?,
211
    min: number?,
212
    sec: number?,
213
    isdst: boolean?,
214
}
215

216
type DateTypeResult = {
217
    year: number,
218
    month: number,
219
    wday: number,
220
    yday: number,
221
    day: number,
222
    hour: number,
223
    min: number,
224
    sec: number,
225
    isdst: boolean,
226
}
227

228
declare os: {
229
    time: (time: DateTypeArg?) -> number,
230
    date: ((formatString: "*t" | "!*t", time: number?) -> DateTypeResult) & ((formatString: string?, time: number?) -> string),
231
    difftime: (t2: DateTypeResult | number, t1: DateTypeResult | number) -> number,
232
    clock: () -> number,
233
}
234

235
)BUILTIN_SRC";
236

237
static constexpr const char* kBuiltinDefinitionCoroutineSrc = R"BUILTIN_SRC(
238

239
declare coroutine: {
240
    create: <A..., R...>(f: (A...) -> R...) -> thread,
241
    resume: <A..., R...>(co: thread, A...) -> (boolean, R...),
242
    running: () -> thread,
243
    status: @checked (co: thread) -> "dead" | "running" | "normal" | "suspended",
244
    wrap: <A..., R...>(f: (A...) -> R...) -> ((A...) -> R...),
245
    yield: <A..., R...>(A...) -> R...,
246
    isyieldable: () -> boolean,
247
    close: @checked (co: thread) -> (boolean, any)
248
}
249

250
)BUILTIN_SRC";
251

252
static constexpr const char* kBuiltinDefinitionTableSrc = R"BUILTIN_SRC(
253

254
declare table: {
255
    concat: <V>(t: {V}, sep: string?, i: number?, j: number?) -> string,
256
    insert: (<V>(t: {V}, value: V) -> ()) & (<V>(t: {V}, pos: number, value: V) -> ()),
257
    maxn: <V>(t: {V}) -> number,
258
    remove: <V>(t: {V}, number?) -> V?,
259
    sort: <V>(t: {V}, comp: ((V, V) -> boolean)?) -> (),
260
    create: <V>(count: number, value: V?) -> {V},
261
    find: <V>(haystack: {V}, needle: V, init: number?) -> number?,
262

263
    unpack: <V>(list: {V}, i: number?, j: number?) -> ...V,
264
    pack: <V>(...V) -> { n: number, [number]: V },
265

266
    getn: <V>(t: {V}) -> number,
267
    foreach: <K, V>(t: {[K]: V}, f: (K, V) -> ()) -> (),
268
    foreachi: <V>({V}, (number, V) -> ()) -> (),
269

270
    move: <V>(src: {V}, a: number, b: number, t: number, dst: {V}?) -> {V},
271

272
    clear: (table: {}) -> (),
273
    isfrozen: (t: {}) -> boolean,
274
}
275

276
)BUILTIN_SRC";
277

278
static constexpr const char* kBuiltinDefinitionDebugSrc = R"BUILTIN_SRC(
279

280
declare debug: {
281
    info: ((thread: thread, level: number, options: string) -> ...any) & ((level: number, options: string) -> ...any) & (<A..., R1...>(func: (A...) -> R1..., options: string) -> ...any),
282
    traceback: ((message: string?, level: number?) -> string) & ((thread: thread, message: string?, level: number?) -> string),
283
}
284

285
)BUILTIN_SRC";
286

287
static constexpr const char* kBuiltinDefinitionUtf8Src = R"BUILTIN_SRC(
288

289
declare utf8: {
290
    char: @checked (...number) -> string,
291
    charpattern: string,
292
    codes: @checked (str: string) -> ((string, number) -> (number, number), string, number),
293
    codepoint: @checked (str: string, i: number?, j: number?) -> ...number,
294
    len: @checked (s: string, i: number?, j: number?) -> (number?, number?),
295
    offset: @checked (s: string, n: number?, i: number?) -> number,
296
}
297

298
)BUILTIN_SRC";
299

300
static constexpr const char* kBuiltinDefinitionBufferSrc = R"BUILTIN_SRC(
301
--- Buffer API
302
declare buffer: {
303
    create: @checked (size: number) -> buffer,
304
    fromstring: @checked (str: string) -> buffer,
305
    tostring: @checked (b: buffer) -> string,
306
    len: @checked (b: buffer) -> number,
307
    copy: @checked (target: buffer, targetOffset: number, source: buffer, sourceOffset: number?, count: number?) -> (),
308
    fill: @checked (b: buffer, offset: number, value: number, count: number?) -> (),
309
    readi8: @checked (b: buffer, offset: number) -> number,
310
    readu8: @checked (b: buffer, offset: number) -> number,
311
    readi16: @checked (b: buffer, offset: number) -> number,
312
    readu16: @checked (b: buffer, offset: number) -> number,
313
    readi32: @checked (b: buffer, offset: number) -> number,
314
    readu32: @checked (b: buffer, offset: number) -> number,
315
    readf32: @checked (b: buffer, offset: number) -> number,
316
    readf64: @checked (b: buffer, offset: number) -> number,
317
    writei8: @checked (b: buffer, offset: number, value: number) -> (),
318
    writeu8: @checked (b: buffer, offset: number, value: number) -> (),
319
    writei16: @checked (b: buffer, offset: number, value: number) -> (),
320
    writeu16: @checked (b: buffer, offset: number, value: number) -> (),
321
    writei32: @checked (b: buffer, offset: number, value: number) -> (),
322
    writeu32: @checked (b: buffer, offset: number, value: number) -> (),
323
    writef32: @checked (b: buffer, offset: number, value: number) -> (),
324
    writef64: @checked (b: buffer, offset: number, value: number) -> (),
325
    readstring: @checked (b: buffer, offset: number, count: number) -> string,
326
    writestring: @checked (b: buffer, offset: number, value: string, count: number?) -> (),
327
    readbits: @checked (b: buffer, bitOffset: number, bitCount: number) -> number,
328
    writebits: @checked (b: buffer, bitOffset: number, bitCount: number, value: number) -> (),
329
    readinteger: @checked (b: buffer, offset: number) -> integer,
330
    writeinteger: @checked (b: buffer, offset: number, value: integer) -> (),
331
}
332

333
)BUILTIN_SRC";
334

335
static constexpr const char* kBuiltinDefinitionBufferSrc_NOINTEGER = R"BUILTIN_SRC(
336
--- Buffer API
337
declare buffer: {
338
    create: @checked (size: number) -> buffer,
339
    fromstring: @checked (str: string) -> buffer,
340
    tostring: @checked (b: buffer) -> string,
341
    len: @checked (b: buffer) -> number,
342
    copy: @checked (target: buffer, targetOffset: number, source: buffer, sourceOffset: number?, count: number?) -> (),
343
    fill: @checked (b: buffer, offset: number, value: number, count: number?) -> (),
344
    readi8: @checked (b: buffer, offset: number) -> number,
345
    readu8: @checked (b: buffer, offset: number) -> number,
346
    readi16: @checked (b: buffer, offset: number) -> number,
347
    readu16: @checked (b: buffer, offset: number) -> number,
348
    readi32: @checked (b: buffer, offset: number) -> number,
349
    readu32: @checked (b: buffer, offset: number) -> number,
350
    readf32: @checked (b: buffer, offset: number) -> number,
351
    readf64: @checked (b: buffer, offset: number) -> number,
352
    writei8: @checked (b: buffer, offset: number, value: number) -> (),
353
    writeu8: @checked (b: buffer, offset: number, value: number) -> (),
354
    writei16: @checked (b: buffer, offset: number, value: number) -> (),
355
    writeu16: @checked (b: buffer, offset: number, value: number) -> (),
356
    writei32: @checked (b: buffer, offset: number, value: number) -> (),
357
    writeu32: @checked (b: buffer, offset: number, value: number) -> (),
358
    writef32: @checked (b: buffer, offset: number, value: number) -> (),
359
    writef64: @checked (b: buffer, offset: number, value: number) -> (),
360
    readstring: @checked (b: buffer, offset: number, count: number) -> string,
361
    writestring: @checked (b: buffer, offset: number, value: string, count: number?) -> (),
362
    readbits: @checked (b: buffer, bitOffset: number, bitCount: number) -> number,
363
    writebits: @checked (b: buffer, bitOffset: number, bitCount: number, value: number) -> ()
364
}
365

366
)BUILTIN_SRC";
367

368
static const char* const kBuiltinDefinitionVectorSrc = R"BUILTIN_SRC(
369

370
-- While vector would have been better represented as a built-in primitive type, type solver extern type handling covers most of the properties
371
declare extern type vector with
372
    read x: number
373
    read y: number
374
    read z: number
375
end
376

377
declare vector: {
378
    create: @checked (x: number, y: number, z: number?) -> vector,
379
    magnitude: @checked (vec: vector) -> number,
380
    normalize: @checked (vec: vector) -> vector,
381
    cross: @checked (vec1: vector, vec2: vector) -> vector,
382
    dot: @checked (vec1: vector, vec2: vector) -> number,
383
    angle: @checked (vec1: vector, vec2: vector, axis: vector?) -> number,
384
    floor: @checked (vec: vector) -> vector,
385
    ceil: @checked (vec: vector) -> vector,
386
    abs: @checked (vec: vector) -> vector,
387
    sign: @checked (vec: vector) -> vector,
388
    clamp: @checked (vec: vector, min: vector, max: vector) -> vector,
389
    max: @checked (vector, ...vector) -> vector,
390
    min: @checked (vector, ...vector) -> vector,
391
    lerp: @checked (vec1: vector, vec2: vector, t: number) -> vector,
392

393
    zero: vector,
394
    one: vector,
395
}
396

397
)BUILTIN_SRC";
398

399
static const char* const kBuiltinDefinitionVectorSrc_DEPRECATED = R"BUILTIN_SRC(
400

401
-- While vector would have been better represented as a built-in primitive type, type solver extern type handling covers most of the properties
402
declare extern type vector with
403
    x: number
404
    y: number
405
    z: number
406
end
407

408
declare vector: {
409
    create: @checked (x: number, y: number, z: number?) -> vector,
410
    magnitude: @checked (vec: vector) -> number,
411
    normalize: @checked (vec: vector) -> vector,
412
    cross: @checked (vec1: vector, vec2: vector) -> vector,
413
    dot: @checked (vec1: vector, vec2: vector) -> number,
414
    angle: @checked (vec1: vector, vec2: vector, axis: vector?) -> number,
415
    floor: @checked (vec: vector) -> vector,
416
    ceil: @checked (vec: vector) -> vector,
417
    abs: @checked (vec: vector) -> vector,
418
    sign: @checked (vec: vector) -> vector,
419
    clamp: @checked (vec: vector, min: vector, max: vector) -> vector,
420
    max: @checked (vector, ...vector) -> vector,
421
    min: @checked (vector, ...vector) -> vector,
422
    lerp: @checked (vec1: vector, vec2: vector, t: number) -> vector,
423

424
    zero: vector,
425
    one: vector,
426
}
427

428
)BUILTIN_SRC";
429

430
static const char* const kBuiltinDefinitionIntegerSrc = R"BUILTIN_SRC(
431

432
declare integer: {
433
    create: @checked (x: number) -> integer,
434
    tonumber: @checked (x: integer) -> number,
435
    neg: @checked (value: integer) -> integer,
436
    add: @checked (x: integer, y: integer) -> integer,
437
    sub: @checked (x: integer, y: integer) -> integer,
438
    mul: @checked (x: integer, y: integer) -> integer,
439
    div: @checked (x: integer, y: integer) -> integer,
440
    rem: @checked (x: integer, y: integer) -> integer,
441
    idiv: @checked (x: integer, y: integer) -> integer,
442
    mod: @checked (x: integer, y: integer) -> integer,
443
    udiv: @checked (x: integer, y: integer) -> integer,
444
    urem: @checked (x: integer, y: integer) -> integer,
445
    min: @checked (integer, ...integer) -> integer,
446
    max: @checked (integer, ...integer) -> integer,
447
    band: @checked (...integer) -> integer,
448
    bor: @checked (...integer) -> integer,
449
    bnot: @checked (x: integer) -> integer,
450
    bxor: @checked (...integer) -> integer,
451
    lt: @checked (x: integer, y: integer) -> boolean,
452
    le: @checked (x: integer, y: integer) -> boolean,
453
    ult: @checked (x: integer, y: integer) -> boolean,
454
    ule: @checked (x: integer, y: integer) -> boolean,
455
    gt: @checked (x: integer, y: integer) -> boolean,
456
    ge: @checked (x: integer, y: integer) -> boolean,
457
    ugt: @checked (x: integer, y: integer) -> boolean,
458
    uge: @checked (x: integer, y: integer) -> boolean,
459
    lshift: @checked (x: integer, numBitPositions: integer) -> integer,
460
    rshift: @checked (x: integer, numBitPositions: integer) -> integer,
461
    arshift: @checked (x: integer, numBitPositions: integer) -> integer,
462
    lrotate: @checked (x: integer, numBitPositions: integer) -> integer,
463
    rrotate: @checked (x: integer, numBitPositions: integer) -> integer,
464
    extract: @checked (value: integer, bitPosition: integer, numBits: integer?) -> integer,
465
    replace: @checked (value: integer, replacement: integer, bitPosition: integer, numBits: integer?) -> integer,
466
    clamp: @checked (value: integer, min: integer, max: integer) -> integer,
467
    btest: @checked (...integer) -> boolean,
468
    countrz: @checked (x: integer) -> integer,
469
    countlz: @checked (x: integer) -> integer,
470
    bswap: @checked (x: integer) -> integer,
471
    fromstring: @checked (str: string, base: number?) -> integer,
472
    minsigned: integer,
473
    maxsigned: integer
474
}
475

476
)BUILTIN_SRC";
477

478
std::string getBuiltinDefinitionSource()
479
{
480
    std::string result = kBuiltinDefinitionBaseSrc;
481

482
    result += kBuiltinDefinitionBit32Src;
483
    if (FFlag::LuauNewMathConstantsAnalysis)
484
        result += kBuiltinDefinitionMathSrc;
485
    else
486
        result += kBuiltinDefinitionMathSrc_DEPRECATED;
487
    result += kBuiltinDefinitionOsSrc;
488
    result += kBuiltinDefinitionCoroutineSrc;
489
    result += kBuiltinDefinitionTableSrc;
490
    result += kBuiltinDefinitionDebugSrc;
491
    result += kBuiltinDefinitionUtf8Src;
492
    if (FFlag::LuauIntegerType && FFlag::LuauIntegerLibrary)
493
        result += kBuiltinDefinitionBufferSrc;
494
    else
495
        result += kBuiltinDefinitionBufferSrc_NOINTEGER;
496

497
    if (FFlag::LuauTypeCheckerVectorReadOnly)
498
    {
499
        result += kBuiltinDefinitionVectorSrc;
500
    }
501
    else
502
    {
503
        result += kBuiltinDefinitionVectorSrc_DEPRECATED;
504
    }
505

506
    if (FFlag::LuauIntegerType && FFlag::LuauIntegerLibrary)
507
    {
508
        result += kBuiltinDefinitionIntegerSrc;
509
    }
510

511
    return result;
512
}
513

514
// TODO: split into separate tagged unions when the new solver can appropriately handle that.
515
static constexpr const char* kBuiltinDefinitionTypeMethodSrc = R"BUILTIN_SRC(
516

517
export type type = {
518
    tag: "nil" | "unknown" | "never" | "any" | "boolean" | "number" | "integer" | "string" | "buffer" | "thread" |
519
         "singleton" | "negation" | "union" | "intersection" | "table" | "function" | "extern" | "generic",
520

521
    is: (self: type, arg: string) -> boolean,
522

523
    -- for singleton type
524
    value: (self: type) -> (string | boolean | nil),
525

526
    -- for negation type
527
    inner: (self: type) -> type,
528

529
    -- for union and intersection types
530
    components: (self: type) -> {type},
531

532
    -- for table type
533
    setproperty: (self: type, key: type, value: type?) -> (),
534
    setreadproperty: (self: type, key: type, value: type?) -> (),
535
    setwriteproperty: (self: type, key: type, value: type?) -> (),
536
    readproperty: (self: type, key: type) -> type?,
537
    writeproperty: (self: type, key: type) -> type?,
538
    properties: (self: type) -> { [type]: { read: type?, write: type? } },
539
    setindexer: (self: type, index: type, result: type) -> (),
540
    setreadindexer: (self: type, index: type, result: type) -> (),
541
    setwriteindexer: (self: type, index: type, result: type) -> (),
542
    indexer: (self: type) -> { index: type, readresult: type, writeresult: type }?,
543
    readindexer: (self: type) -> { index: type, result: type }?,
544
    writeindexer: (self: type) -> { index: type, result: type }?,
545
    setmetatable: (self: type, arg: type) -> (),
546
    metatable: (self: type) -> type?,
547

548
    -- for function type
549
    setparameters: (self: type, head: {type}?, tail: type?) -> (),
550
    parameters: (self: type) -> { head: {type}?, tail: type? },
551
    setreturns: (self: type, head: {type}?, tail: type? ) -> (),
552
    returns: (self: type) -> { head: {type}?, tail: type? },
553
    setgenerics: (self: type, {type}?) -> (),
554
    generics: (self: type) -> {type},
555

556
    -- for class type
557
    -- 'properties', 'metatable', 'indexer', 'readindexer' and 'writeindexer' are shared with table type
558
    readparent: (self: type) -> type?,
559
    writeparent: (self: type) -> type?,
560

561
    -- for generic type
562
    name: (self: type) -> string?,
563
    ispack: (self: type) -> boolean,
564
}
565

566
)BUILTIN_SRC";
567

568
static constexpr const char* kBuiltinDefinitionTypeMethodSrc_NOINTEGER = R"BUILTIN_SRC(
569

570
export type type = {
571
    tag: "nil" | "unknown" | "never" | "any" | "boolean" | "number" | "string" | "buffer" | "thread" |
572
         "singleton" | "negation" | "union" | "intersection" | "table" | "function" | "extern" | "generic",
573

574
    is: (self: type, arg: string) -> boolean,
575

576
    -- for singleton type
577
    value: (self: type) -> (string | boolean | nil),
578

579
    -- for negation type
580
    inner: (self: type) -> type,
581

582
    -- for union and intersection types
583
    components: (self: type) -> {type},
584

585
    -- for table type
586
    setproperty: (self: type, key: type, value: type?) -> (),
587
    setreadproperty: (self: type, key: type, value: type?) -> (),
588
    setwriteproperty: (self: type, key: type, value: type?) -> (),
589
    readproperty: (self: type, key: type) -> type?,
590
    writeproperty: (self: type, key: type) -> type?,
591
    properties: (self: type) -> { [type]: { read: type?, write: type? } },
592
    setindexer: (self: type, index: type, result: type) -> (),
593
    setreadindexer: (self: type, index: type, result: type) -> (),
594
    setwriteindexer: (self: type, index: type, result: type) -> (),
595
    indexer: (self: type) -> { index: type, readresult: type, writeresult: type }?,
596
    readindexer: (self: type) -> { index: type, result: type }?,
597
    writeindexer: (self: type) -> { index: type, result: type }?,
598
    setmetatable: (self: type, arg: type) -> (),
599
    metatable: (self: type) -> type?,
600

601
    -- for function type
602
    setparameters: (self: type, head: {type}?, tail: type?) -> (),
603
    parameters: (self: type) -> { head: {type}?, tail: type? },
604
    setreturns: (self: type, head: {type}?, tail: type? ) -> (),
605
    returns: (self: type) -> { head: {type}?, tail: type? },
606
    setgenerics: (self: type, {type}?) -> (),
607
    generics: (self: type) -> {type},
608

609
    -- for class type
610
    -- 'properties', 'metatable', 'indexer', 'readindexer' and 'writeindexer' are shared with table type
611
    readparent: (self: type) -> type?,
612
    writeparent: (self: type) -> type?,
613

614
    -- for generic type
615
    name: (self: type) -> string?,
616
    ispack: (self: type) -> boolean,
617
}
618

619
)BUILTIN_SRC";
620

621
static constexpr const char* kBuiltinDefinitionTypeMethodSrc_DEPRECATED = R"BUILTIN_SRC(
622

623
export type type = {
624
    tag: "nil" | "unknown" | "never" | "any" | "boolean" | "number" | "integer" | "string" | "buffer" | "thread" |
625
         "singleton" | "negation" | "union" | "intersection" | "table" | "function" | "class" | "generic",
626

627
    is: (self: type, arg: string) -> boolean,
628

629
    -- for singleton type
630
    value: (self: type) -> (string | boolean | nil),
631

632
    -- for negation type
633
    inner: (self: type) -> type,
634

635
    -- for union and intersection types
636
    components: (self: type) -> {type},
637

638
    -- for table type
639
    setproperty: (self: type, key: type, value: type?) -> (),
640
    setreadproperty: (self: type, key: type, value: type?) -> (),
641
    setwriteproperty: (self: type, key: type, value: type?) -> (),
642
    readproperty: (self: type, key: type) -> type?,
643
    writeproperty: (self: type, key: type) -> type?,
644
    properties: (self: type) -> { [type]: { read: type?, write: type? } },
645
    setindexer: (self: type, index: type, result: type) -> (),
646
    setreadindexer: (self: type, index: type, result: type) -> (),
647
    setwriteindexer: (self: type, index: type, result: type) -> (),
648
    indexer: (self: type) -> { index: type, readresult: type, writeresult: type }?,
649
    readindexer: (self: type) -> { index: type, result: type }?,
650
    writeindexer: (self: type) -> { index: type, result: type }?,
651
    setmetatable: (self: type, arg: type) -> (),
652
    metatable: (self: type) -> type?,
653

654
    -- for function type
655
    setparameters: (self: type, head: {type}?, tail: type?) -> (),
656
    parameters: (self: type) -> { head: {type}?, tail: type? },
657
    setreturns: (self: type, head: {type}?, tail: type? ) -> (),
658
    returns: (self: type) -> { head: {type}?, tail: type? },
659
    setgenerics: (self: type, {type}?) -> (),
660
    generics: (self: type) -> {type},
661

662
    -- for class type
663
    -- 'properties', 'metatable', 'indexer', 'readindexer' and 'writeindexer' are shared with table type
664
    readparent: (self: type) -> type?,
665
    writeparent: (self: type) -> type?,
666

667
    -- for generic type
668
    name: (self: type) -> string?,
669
    ispack: (self: type) -> boolean,
670
}
671

672
)BUILTIN_SRC";
673

674
static constexpr const char* kBuiltinDefinitionTypeMethodSrc_DEPRECATED_NOINTEGER = R"BUILTIN_SRC(
675

676
export type type = {
677
    tag: "nil" | "unknown" | "never" | "any" | "boolean" | "number" | "string" | "buffer" | "thread" |
678
         "singleton" | "negation" | "union" | "intersection" | "table" | "function" | "class" | "generic",
679

680
    is: (self: type, arg: string) -> boolean,
681

682
    -- for singleton type
683
    value: (self: type) -> (string | boolean | nil),
684

685
    -- for negation type
686
    inner: (self: type) -> type,
687

688
    -- for union and intersection types
689
    components: (self: type) -> {type},
690

691
    -- for table type
692
    setproperty: (self: type, key: type, value: type?) -> (),
693
    setreadproperty: (self: type, key: type, value: type?) -> (),
694
    setwriteproperty: (self: type, key: type, value: type?) -> (),
695
    readproperty: (self: type, key: type) -> type?,
696
    writeproperty: (self: type, key: type) -> type?,
697
    properties: (self: type) -> { [type]: { read: type?, write: type? } },
698
    setindexer: (self: type, index: type, result: type) -> (),
699
    setreadindexer: (self: type, index: type, result: type) -> (),
700
    setwriteindexer: (self: type, index: type, result: type) -> (),
701
    indexer: (self: type) -> { index: type, readresult: type, writeresult: type }?,
702
    readindexer: (self: type) -> { index: type, result: type }?,
703
    writeindexer: (self: type) -> { index: type, result: type }?,
704
    setmetatable: (self: type, arg: type) -> (),
705
    metatable: (self: type) -> type?,
706

707
    -- for function type
708
    setparameters: (self: type, head: {type}?, tail: type?) -> (),
709
    parameters: (self: type) -> { head: {type}?, tail: type? },
710
    setreturns: (self: type, head: {type}?, tail: type? ) -> (),
711
    returns: (self: type) -> { head: {type}?, tail: type? },
712
    setgenerics: (self: type, {type}?) -> (),
713
    generics: (self: type) -> {type},
714

715
    -- for class type
716
    -- 'properties', 'metatable', 'indexer', 'readindexer' and 'writeindexer' are shared with table type
717
    readparent: (self: type) -> type?,
718
    writeparent: (self: type) -> type?,
719

720
    -- for generic type
721
    name: (self: type) -> string?,
722
    ispack: (self: type) -> boolean,
723
}
724

725
)BUILTIN_SRC";
726

727
static constexpr const char* kBuiltinDefinitionTypesLibSrc = R"BUILTIN_SRC(
728

729
declare types: {
730
    unknown: type,
731
    never: type,
732
    any: type,
733
    boolean: type,
734
    number: type,
735
    string: type,
736
    thread: type,
737
    buffer: type,
738
    integer: type,
739

740
    singleton: @checked (arg: string | boolean | nil) -> type,
741
    optional: @checked (arg: type) -> type,
742
    generic: @checked (name: string, ispack: boolean?) -> type,
743
    negationof: @checked (arg: type) -> type,
744
    unionof: @checked (...type) -> type,
745
    intersectionof: @checked (...type) -> type,
746
    newtable: @checked (props: {[type]: type} | {[type]: { read: type?, write: type? } }?, indexer: { index: type, readresult: type, writeresult: type }?, metatable: type?) -> type,
747
    newfunction: @checked (parameters: { head: {type}?, tail: type? }?, returns: { head: {type}?, tail: type? }?, generics: {type}?) -> type,
748
    copy: @checked (arg: type) -> type,
749
}
750
)BUILTIN_SRC";
751

752
static constexpr const char* kBuiltinDefinitionTypesLibSrc_NOINTEGER = R"BUILTIN_SRC(
753

754
declare types: {
755
    unknown: type,
756
    never: type,
757
    any: type,
758
    boolean: type,
759
    number: type,
760
    string: type,
761
    thread: type,
762
    buffer: type,
763

764
    singleton: @checked (arg: string | boolean | nil) -> type,
765
    optional: @checked (arg: type) -> type,
766
    generic: @checked (name: string, ispack: boolean?) -> type,
767
    negationof: @checked (arg: type) -> type,
768
    unionof: @checked (...type) -> type,
769
    intersectionof: @checked (...type) -> type,
770
    newtable: @checked (props: {[type]: type} | {[type]: { read: type?, write: type? } }?, indexer: { index: type, readresult: type, writeresult: type }?, metatable: type?) -> type,
771
    newfunction: @checked (parameters: { head: {type}?, tail: type? }?, returns: { head: {type}?, tail: type? }?, generics: {type}?) -> type,
772
    copy: @checked (arg: type) -> type,
773
}
774
)BUILTIN_SRC";
775

776
std::string getTypeFunctionDefinitionSource()
777
{
778
    std::string result;
779

780
    if (FFlag::LuauTypeCheckerUdtfRenameClassToExtern)
781
    {
782
        if (FFlag::LuauIntegerType)
783
            result += kBuiltinDefinitionTypeMethodSrc;
784
        else
785
            result += kBuiltinDefinitionTypeMethodSrc_NOINTEGER;
786
    }
787
    else
788
    {
789
        if (FFlag::LuauIntegerType)
790
            result += kBuiltinDefinitionTypeMethodSrc_DEPRECATED;
791
        else
792
            result += kBuiltinDefinitionTypeMethodSrc_DEPRECATED_NOINTEGER;
793
    }
794

795
    if (FFlag::LuauIntegerType)
796
        result += kBuiltinDefinitionTypesLibSrc;
797
    else
798
        result += kBuiltinDefinitionTypesLibSrc_NOINTEGER;
799

800
    return result;
801
}
802

803
} // namespace Luau
804

805
Product

Resources

Company
