Merge branch 'master' into merge

Common/include/Luau/Bytecode.h

@@ -28,7 +28,7 @@
 // Upvalues: 0-254. Upvalues refer to the values stored in the closure object.
 // Constants: 0-2^23-1. Constants are stored in a table allocated with each proto; to allow for future bytecode tweaks the encodable value is limited to 23 bits.
 // Closures: 0-2^15-1. Closures are created from child protos via a child index; the limit is for the number of closures immediately referenced in each function.
-// Jumps: -2^23..2^23. Jump offsets are specified in word increments, so jumping over an instruction may sometimes require an offset of 2 or more.
+// Jumps: -2^23..2^23. Jump offsets are specified in word increments, so jumping over an instruction may sometimes require an offset of 2 or more. Note that for jump instructions with AUX, the AUX word is included as part of the jump offset.
 
 // # Bytecode versions
 // Bytecode serialized format embeds a version number, that dictates both the serialized form as well as the allowed instructions. As long as the bytecode version falls into supported
@@ -194,7 +194,7 @@ enum LuauOpcode
 
     // JUMPIFEQ, JUMPIFLE, JUMPIFLT, JUMPIFNOTEQ, JUMPIFNOTLE, JUMPIFNOTLT: jumps to target offset if the comparison is true (or false, for NOT variants)
     // A: source register 1
-    // D: jump offset (-32768..32767; 0 means "next instruction" aka "don't jump")
+    // D: jump offset (-32768..32767; 1 means "next instruction" aka "don't jump")
     // AUX: source register 2
     LOP_JUMPIFEQ,
     LOP_JUMPIFLE,
@@ -376,14 +376,14 @@ enum LuauOpcode
 
     // JUMPXEQKNIL, JUMPXEQKB: jumps to target offset if the comparison with constant is true (or false, see AUX)
     // A: source register 1
-    // D: jump offset (-32768..32767; 0 means "next instruction" aka "don't jump")
+    // D: jump offset (-32768..32767; 1 means "next instruction" aka "don't jump")
     // AUX: constant value (for boolean) in low bit, NOT flag (that flips comparison result) in high bit
     LOP_JUMPXEQKNIL,
     LOP_JUMPXEQKB,
 
     // JUMPXEQKN, JUMPXEQKS: jumps to target offset if the comparison with constant is true (or false, see AUX)
     // A: source register 1
-    // D: jump offset (-32768..32767; 0 means "next instruction" aka "don't jump")
+    // D: jump offset (-32768..32767; 1 means "next instruction" aka "don't jump")
     // AUX: constant table index in low 24 bits, NOT flag (that flips comparison result) in high bit
     LOP_JUMPXEQKN,
     LOP_JUMPXEQKS,

docs/_pages/syntax.md

@@ -219,3 +219,57 @@ end
 ```
 
 The default iteration order for tables is specified to be consecutive for elements `1..#t` and unordered after that, visiting every element; similarly to iteration using `pairs`, modifying the table entries for keys other than the current one results in unspecified behavior.
+
+## String interpolation
+
+Luau adds an additional way to define string values that allows you to place runtime expressions directly inside specific spots of the literal.
+
+This is a more ergonomic alternative over using `string.format` or `("literal"):format`.
+
+To use string interpolation, use a backtick string literal:
+
+```lua
+local count = 3
+print(`Bob has {count} apple(s)!`)
+--> Bob has 3 apple(s)!
+```
+
+Any expression can be used inside `{}`:
+
+```lua
+local combos = {2, 7, 1, 8, 5}
+print(`The lock combination is {table.concat(combos)}.`)
+--> The lock combination is 27185.
+```
+
+Inside backtick string literal, `\` is used to escape `` ` ``, `{`, `\` itself and a newline:
+
+```lua
+print(`Some example escaping the braces \{like so}`)
+--> Some example escaping the braces {like so}
+
+print(`Backslash \ that escapes the space is not a part of the string...`)
+--> Backslash  that escapes the space is not a part of the string...
+
+print(`Backslash \\ will escape the second backslash...`)
+--> Backslash \ will escape the second backslash...
+
+print(`Some text that also includes \`...`)
+--> Some text that also includes `...
+
+local name = "Luau"
+
+print(`Welcome to {
+    name
+}!`)
+--> Welcome to Luau!
+```
+
+### Restrictions and limitations
+
+The sequence of two opening braces {{"`{{`"}} is rejected with a parse error.
+This restriction is made to prevent developers using other programming languages with a similar feature from trying to attempt that as a way to escape a single `{` and getting unexpected results in Luau.
+
+Luau currently does not support backtick string literals as a type annotation, so `` type Foo = `Foo` `` is invalid.
+
+Function calls with a backtick string literal without parenthesis is not supported, so `` print`hello` `` is invalid.

docs/_posts/2023-02-02-luau-string-interpolation.md

@@ -0,0 +1,33 @@
+---
+layout: single
+title: "String Interpolation"
+---
+
+String interpolation is the new syntax introduced to Luau that allows you to create a string literal with expressions inside of that string literal.
+
+In short, it's a safer and more ergonomic alternative over `string.format`.
+
+Here's a quick example of a string interpolation:
+
+```lua
+local combos = {2, 7, 1, 8, 5}
+print(`The lock combination is {table.concat(combos)}. Again, {table.concat(combos, ", ")}.`)
+--> The lock combination is 27185. Again, 2, 7, 1, 8, 5.
+```
+
+String interpolation also composes well with the `__tostring` metamethod.
+
+```lua
+local balance = setmetatable({ value = 500 }, {
+    __tostring = function(self)
+        return "$" .. tostring(self.value)
+    end
+})
+
+print(`You have {balance}!`)
+--> You have $500!
+```
+
+To find out more details about this feature, check out [Luau Syntax page](/syntax#string-interpolation).
+
+This is also the first major language feature implemented in a [contribution](https://github.com/Roblox/luau/pull/614) from the open-source community. Thanks [Kampfkarren](https://github.com/Kampfkarren)!