Merge branch 'master' into merge

LICENSE.txt

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2019-2021 Roblox Corporation
+Copyright (c) 2019-2022 Roblox Corporation
 Copyright (c) 1994–2019 Lua.org, PUC-Rio.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of

VM/include/lua.h

@@ -382,7 +382,7 @@ typedef struct lua_Callbacks lua_Callbacks;
 LUA_API lua_Callbacks* lua_callbacks(lua_State* L);
 
 /******************************************************************************
- * Copyright (c) 2019-2021 Roblox Corporation
+ * Copyright (c) 2019-2022 Roblox Corporation
  * Copyright (C) 1994-2008 Lua.org, PUC-Rio.  All rights reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining

VM/src/lapi.cpp

@@ -18,7 +18,7 @@ const char* lua_ident = "$Lua: Lua 5.1.4 Copyright (C) 1994-2008 Lua.org, PUC-Ri
                         "$Authors: R. Ierusalimschy, L. H. de Figueiredo & W. Celes $\n"
                         "$URL: www.lua.org $\n";
 
-const char* luau_ident = "$Luau: Copyright (C) 2019-2021 Roblox Corporation $\n"
+const char* luau_ident = "$Luau: Copyright (C) 2019-2022 Roblox Corporation $\n"
                          "$URL: luau-lang.org $\n";
 
 #define api_checknelems(L, n) api_check(L, (n) <= (L->top - L->base))

docs/_pages/compatibility.md

@@ -116,7 +116,7 @@ Floor division is less harmful, but it's used rarely enough that `math.floor(a/b
 | The function print calls `__tostring` instead of tostring to format its arguments. | ✔️ | |
 | By default, the decoding functions in the utf8 library do not accept surrogates. | 😞 | breaks compatibility and doesn't seem very interesting otherwise |
 
-Lua has a beautiful syntax and frankly we're disappointed in the `<const>`/`<toclose>` which takes away from that beauty. Taking syntax aside, `<toclose>` isn't very useful in Luau - its dominant use case is for code that works with external resources like files or sockets, but we don't provide such APIs - and has a very large complexity cost, evidences by a lot of bug fixes since the initial implementation in 5.4 work versions. `<const>` in Luau doesn't matter for performance - our multi-pass compiler is already able to analyze the usage of the variable to know if it's modified or not and extract all performance gains from it - so the only use here is for code readability, where the `<const>` syntax is... suboptimal.
+Lua has a beautiful syntax and frankly we're disappointed in the `<const>`/`<close>` which takes away from that beauty. Taking syntax aside, `<close>` isn't very useful in Luau - its dominant use case is for code that works with external resources like files or sockets, but we don't provide such APIs - and has a very large complexity cost, evidences by a lot of bug fixes since the initial implementation in 5.4 work versions. `<const>` in Luau doesn't matter for performance - our multi-pass compiler is already able to analyze the usage of the variable to know if it's modified or not and extract all performance gains from it - so the only use here is for code readability, where the `<const>` syntax is... suboptimal.
 
 If we do end up introducing const variables, it would be through a `const var = value` syntax, which is backwards compatible through a context-sensitive keyword similar to `type`.
 
@@ -127,5 +127,5 @@ We have a few behavior deviations from Lua 5.x that come from either a different
 * Tail calls are not supported to simplify implementation, make debugging/stack traces more predictable and allow deep validation of caller identity for security
 * Order of table assignment in table literals follows program order in mixed tables (Lua 5.x assigns array elements first in some cases)
 * Equality comparisons call `__eq` metamethod even when objects are rawequal (which matches other metamethods like `<=` and facilitates NaN checking)
-* `function()` expressions may reuse a previosly created closure in certain scenarios (when all upvalues captured are the same) for efficiency, which changes object identity but doesn't change call semantics -- this is different from Lua 5.1 but similar to Lua 5.2/5.3
+* `function()` expressions may reuse a previously created closure in certain scenarios (when all upvalues captured are the same) for efficiency, which changes object identity but doesn't change call semantics -- this is different from Lua 5.1 but similar to Lua 5.2/5.3
 * `os.time` returns UTC timestamp when called with a table for consistency

docs/_pages/grammar.md

@@ -7,8 +7,6 @@ classes: wide
 This is the complete syntax grammar for Luau in EBNF. More information about the terminal nodes String and Number
 is available in the [syntax section](syntax).
 
-> Note: this grammar is currently missing type pack syntax for generic arguments
-
 ```ebnf
 chunk = block
 block = {stat [';']} [laststat [';']]
@@ -24,12 +22,12 @@ stat = varlist '=' explist |
     'function' funcname funcbody |
     'local' 'function' NAME funcbody |
     'local' bindinglist ['=' explist] |
-    ['export'] 'type' NAME ['<' GenericTypeList '>'] '=' Type
+    ['export'] 'type' NAME ['<' GenericTypeParameterList '>'] '=' Type
 
 laststat = 'return' [explist] | 'break' | 'continue'
 
 funcname = NAME {'.' NAME} [':' NAME]
-funcbody = '(' [parlist] ')' [':' ReturnType] block 'end'
+funcbody = ['<' GenericTypeParameterList '>'] '(' [parlist] ')' [':' ReturnType] block 'end'
 parlist = bindinglist [',' '...'] | '...'
 
 explist = {exp ','} exp
@@ -60,19 +58,27 @@ unop = '-' | 'not' | '#'
 
 SimpleType =
     'nil' |
-    NAME ['.' NAME] [ '<' TypeList '>' ] |
+    SingletonType |
+    NAME ['.' NAME] [ '<' [TypeParams] '>' ] |
     'typeof' '(' exp ')' |
     TableType |
     FunctionType
 
+SingletonType = STRING | 'true' | 'false'
+
 Type =
     SimpleType ['?'] |
     SimpleType ['|' Type] |
     SimpleType ['&' Type]
 
-GenericTypeList = NAME ['...'] {',' NAME ['...']}
+GenericTypePackParameter = NAME '...' ['=' (TypePack | VariadicTypePack | GenericTypePack)]
+GenericTypeParameterList = NAME ['=' Type] [',' GenericTypeParameterList] | GenericTypePackParameter {',' GenericTypePackParameter}
 TypeList = Type [',' TypeList] | '...' Type
-ReturnType = Type | '(' TypeList ')'
+TypeParams = (Type | TypePack | VariadicTypePack | GenericTypePack) [',' TypeParams]
+TypePack = '(' [TypeList] ')'
+GenericTypePack = NAME '...'
+VariadicTypePack = '...' Type
+ReturnType = Type | TypePack
 TableIndexer = '[' Type ']' ':' Type
 TableProp = NAME ':' Type
 TablePropOrIndexer = TableProp | TableIndexer

docs/_pages/lint.md

@@ -145,7 +145,7 @@ In some cases the linter can detect code that is never executed, because all exe
 ```lua
 function cbrt(v)
     if v >= 0 then
-        return v ^ 1/3
+        return v ^ (1/3)
     else
         error('cbrt expects a non-negative argument')
     end

docs/_pages/profile.md

@@ -8,7 +8,7 @@ One of main goals of Luau is to enable high performance code. To help with that
 code is in developers' hands, and is a combination of good algorithm design and implementation that adheres to the strengths of the language. To help write efficient code, Luau
 provides a built-in profiler that samples the execution of the program and outputs a profiler dump that can be converted to an interactive flamegraph.
 
-To run the profiler, make sure you have an optimized build of the intepreter (otherwise profiling results are going to be very skewed) and run it with `--profile` argument:
+To run the profiler, make sure you have an optimized build of the interpreter (otherwise profiling results are going to be very skewed) and run it with `--profile` argument:
 
 ```
 $ luau --profile tests/chess.lua

docs/_pages/syntax.md

@@ -27,7 +27,7 @@ The rest of this document documents additional syntax used in Luau.
 
 ## String literals
 
-Luau implements support for hexadecimal (`\0x`), Unicode (`\u`) and `\z` escapes for string literals. This syntax follows [Lua 5.3 syntax](https://www.lua.org/manual/5.3/manual.html#3.1):
+Luau implements support for hexadecimal (`\x`), Unicode (`\u`) and `\z` escapes for string literals. This syntax follows [Lua 5.3 syntax](https://www.lua.org/manual/5.3/manual.html#3.1):
 
 - `\xAB` inserts a character with the code 0xAB into the string
 - `\u{ABC}` inserts a UTF8 byte sequence that encodes U+0ABC character into the string (note that braces are mandatory)
@@ -158,7 +158,7 @@ In addition to declaring types for a given value, Luau supports declaring type a
 ```lua
 type Point = { x: number, y: number }
 type Array<T> = { [number]: T }
-type Something = typeof(string.gmatch("", "\d"))
+type Something = typeof(string.gmatch("", "%d"))
 ```
 
 The right hand side of the type alias can be a type definition or a `typeof` expression; `typeof` expression doesn't evaluate its argument at runtime.