v0.18.2+luau708

Author: khvzak

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "luau0-src"
-version = "0.18.1+luau706"
+version = "0.18.2+luau708"
 authors = ["Aleksandr Orlenko <zxteam@protonmail.com>"]
 edition = "2024"
 repository = "https://github.com/mlua-rs/luau-src-rs"

luau/Ast/src/Ast.cpp

@@ -557,10 +557,11 @@ AstExprInstantiate::AstExprInstantiate(const Location& location, AstExpr* expr,
 
 void AstExprInstantiate::visit(AstVisitor* visitor)
 {
-    expr->visit(visitor);
+    LUAU_ASSERT(FFlag::LuauExplicitTypeInstantiationSyntax);
 
     if (visitor->visit(this))
     {
+        expr->visit(visitor);
         visitTypeOrPackArray(visitor, typeArguments);
     }
 }

luau/Ast/src/Parser.cpp

@@ -22,6 +22,7 @@ LUAU_DYNAMIC_FASTFLAGVARIABLE(DebugLuauReportReturnTypeVariadicWithTypeSuffix, f
 LUAU_FASTFLAGVARIABLE(LuauExplicitTypeInstantiationSyntax)
 LUAU_FASTFLAG(LuauStandaloneParseType)
 LUAU_FASTFLAGVARIABLE(LuauCstStatDoWithStatsStart)
+LUAU_FASTFLAGVARIABLE(DesugaredArrayTypeReferenceIsEmpty)
 
 // Clip with DebugLuauReportReturnTypeVariadicWithTypeSuffix
 bool luau_telemetry_parsed_return_type_variadic_with_type_suffix = false;
@@ -2189,8 +2190,17 @@ AstType* Parser::parseTableType(bool inDeclarationContext)
 
             // array-like table type: {T} desugars into {[number]: T}
             isArray = true;
-            AstType* index = allocator.alloc<AstTypeReference>(type->location, std::nullopt, nameNumber, std::nullopt, type->location);
-            indexer = allocator.alloc<AstTableIndexer>(AstTableIndexer{index, type, type->location, access, accessLocation});
+            if (FFlag::DesugaredArrayTypeReferenceIsEmpty)
+            {
+                Location nullTypeLocation = Location(start.begin, 0);
+                AstType* index = allocator.alloc<AstTypeReference>(nullTypeLocation, std::nullopt, nameNumber, std::nullopt, nullTypeLocation);
+                indexer = allocator.alloc<AstTableIndexer>(AstTableIndexer{index, type, type->location, access, accessLocation});
+            }
+            else
+            {
+                AstType* index = allocator.alloc<AstTypeReference>(type->location, std::nullopt, nameNumber, std::nullopt, type->location);
+                indexer = allocator.alloc<AstTableIndexer>(AstTableIndexer{index, type, type->location, access, accessLocation});
+            }
 
             break;
         }

luau/CodeGen/include/Luau/AssemblyBuilderA64.h

@@ -167,7 +167,9 @@ class AssemblyBuilderA64
     void umov_4s(RegisterA64 dst, RegisterA64 src, uint8_t index);
 
     void fcmeq_4s(RegisterA64 dst, RegisterA64 src1, RegisterA64 src2);
+    void fcmgt_4s(RegisterA64 dst, RegisterA64 src1, RegisterA64 src2);
     void bit(RegisterA64 dst, RegisterA64 src, RegisterA64 mask);
+    void bif(RegisterA64 dst, RegisterA64 src, RegisterA64 mask);
 
     // Floating-point rounding and conversions
     void frinta(RegisterA64 dst, RegisterA64 src);

luau/CodeGen/include/Luau/AssemblyBuilderX64.h

@@ -171,8 +171,10 @@ class AssemblyBuilderX64
     void vmovups(OperandX64 dst, OperandX64 src);
     void vmovq(OperandX64 lhs, OperandX64 rhs);
 
+    void vmaxps(OperandX64 dst, OperandX64 src1, OperandX64 src2);
     void vmaxsd(OperandX64 dst, OperandX64 src1, OperandX64 src2);
     void vmaxss(OperandX64 dst, OperandX64 src1, OperandX64 src2);
+    void vminps(OperandX64 dst, OperandX64 src1, OperandX64 src2);
     void vminsd(OperandX64 dst, OperandX64 src1, OperandX64 src2);
     void vminss(OperandX64 dst, OperandX64 src1, OperandX64 src2);
 

luau/CodeGen/include/Luau/IrAnalysis.h

@@ -25,8 +25,7 @@ void updateLastUseLocations(IrFunction& function, const std::vector<uint32_t>& s
 uint32_t getNextInstUse(IrFunction& function, uint32_t targetInstIdx, uint32_t startInstIdx);
 
 // Returns how many values are coming into the block (live in) and how many are coming out of the block (live out)
-std::pair<uint32_t, uint32_t> getLiveInOutValueCount_NEW(IrFunction& function, IrBlock& start, bool visitChain);
-std::pair<uint32_t, uint32_t> getLiveInOutValueCount_DEPRECATED(IrFunction& function, IrBlock& block);
+std::pair<uint32_t, uint32_t> getLiveInOutValueCount(IrFunction& function, IrBlock& start, bool visitChain);
 uint32_t getLiveInValueCount(IrFunction& function, IrBlock& block);
 uint32_t getLiveOutValueCount(IrFunction& function, IrBlock& block);
 

luau/CodeGen/include/Luau/IrBuilder.h

@@ -36,8 +36,7 @@ struct IrBuilder
 
     // Clones all instructions into the current block
     // Source block that is cloned cannot use values coming in from a predecessor
-    void clone_NEW(std::vector<uint32_t> sourceIdxs, bool removeCurrentTerminator);
-    void clone_DEPRECATED(const IrBlock& source, bool removeCurrentTerminator);
+    void clone(std::vector<uint32_t> sourceIdxs, bool removeCurrentTerminator);
 
     IrOp undef();
 

luau/CodeGen/include/Luau/IrData.h

@@ -24,15 +24,15 @@
 
 struct Proto;
 
-LUAU_FASTFLAG(LuauCodegenChainedSpills)
-
 namespace Luau
 {
 namespace CodeGen
 {
 
 struct LoweringStats;
 
+constexpr uint8_t kUnknownTag = 0xff;
+
 // IR extensions to LuauBuiltinFunction enum (these only exist inside IR, and start from 256 to avoid collisions)
 enum
 {
@@ -264,22 +264,40 @@ enum class IrCmd : uint8_t
     SELECT_IF_TRUTHY,
 
     // Add/Sub/Mul/Div/Idiv two vectors
-    // A, B: TValue
+    // A, B: TValue (vector)
     ADD_VEC,
     SUB_VEC,
     MUL_VEC,
     DIV_VEC,
     IDIV_VEC,
     // Lanewise A * B + C
-    // A, B, C: TValue
+    // A, B, C: TValue (vector)
     MULADD_VEC,
 
     // Negate a vector
-    // A: TValue
+    // A: TValue (vector)
     UNM_VEC,
 
+    // Get the minimum/maximum of two vector elements
+    // If one of the element values is NaN, 'B' is returned as the result
+    // A, B: TValue (vector)
+    MIN_VEC,
+    MAX_VEC,
+
+    // Round vector elements to negative infinity
+    // A: TValue (vector)
+    FLOOR_VEC,
+
+    // Round vector elements to positive infinity
+    // A: TValue (vector)
+    CEIL_VEC,
+
+    // Get absolute value of vector elements
+    // A: TValue (vector)
+    ABS_VEC,
+
     // Compute dot product between two vectors as a float number (use FLOAT_TO_NUM to convert to double)
-    // A, B: TValue
+    // A, B: TValue (vector)
     DOT_VEC,
 
     // Extract a component of a vector (use FLOAT_TO_NUM to convert to double)
@@ -444,10 +462,6 @@ enum class IrCmd : uint8_t
     // A: double
     NUM_TO_FLOAT,
 
-    // Converts a double number to a vector with the value in X/Y/Z
-    // A: double
-    NUM_TO_VEC_DEPRECATED,
-
     // Converts a float number to a vector with the value in X/Y/Z (use NUM_TO_FLOAT to convert from double)
     // A: float
     FLOAT_TO_VEC,
@@ -1024,7 +1038,7 @@ struct IrInst
     IrCmd cmd;
 
     // Operands
-    // All frequiently used instructions use only A-D slots.
+    // All frequently used instructions use only A-F slots.
     IrOps ops;
 
     uint32_t lastUse = 0;
@@ -1052,6 +1066,20 @@ inline IrOp& getOp(IrInst* inst, uint32_t idx)
     return getOp(*inst, idx);
 }
 
+inline bool hasOp(IrInst& inst, uint32_t idx)
+{
+    return idx < inst.ops.size();
+}
+
+// TODO: once we update kind checks to not use getOp, it will no longer cause a resize and second part can be removed
+#define HAS_OP_A(inst) (0 < (inst).ops.size() && (inst).ops[0].kind != IrOpKind::None)
+#define HAS_OP_B(inst) (1 < (inst).ops.size() && (inst).ops[1].kind != IrOpKind::None)
+#define HAS_OP_C(inst) (2 < (inst).ops.size() && (inst).ops[2].kind != IrOpKind::None)
+#define HAS_OP_D(inst) (3 < (inst).ops.size() && (inst).ops[3].kind != IrOpKind::None)
+#define HAS_OP_E(inst) (4 < (inst).ops.size() && (inst).ops[4].kind != IrOpKind::None)
+#define HAS_OP_F(inst) (5 < (inst).ops.size() && (inst).ops[5].kind != IrOpKind::None)
+#define HAS_OP_G(inst) (6 < (inst).ops.size() && (inst).ops[6].kind != IrOpKind::None)
+
 // When IrInst operands are used, current instruction index is often required to track lifetime
 inline constexpr uint32_t kInvalidInstIdx = ~0u;
 
@@ -1233,8 +1261,7 @@ struct IrFunction
     uint32_t endLocation = 0;
 
     // For each instruction, an operand that can be used to recompute the value
-    std::vector<IrOp> valueRestoreOps_DEPRECATED; // TODO: Remove with FFlagLuauCodegenChainedSpills
-    std::vector<ValueRestoreLocation> valueRestoreOps_NEW;
+    std::vector<ValueRestoreLocation> valueRestoreOps;
     std::vector<uint32_t> validRestoreOpBlocks;
 
     BytecodeTypeInfo bcOriginalTypeInfo; // Bytecode type information as loaded
@@ -1379,63 +1406,19 @@ struct IrFunction
         return uint32_t(&inst - instructions.data());
     }
 
-    void recordRestoreOp_DEPRECATED(uint32_t instIdx, IrOp location)
-    {
-        CODEGEN_ASSERT(!FFlag::LuauCodegenChainedSpills);
-
-        if (instIdx >= valueRestoreOps_DEPRECATED.size())
-            valueRestoreOps_DEPRECATED.resize(instIdx + 1);
-
-        valueRestoreOps_DEPRECATED[instIdx] = location;
-    }
-
-    IrOp findRestoreOp_DEPRECATED(uint32_t instIdx, bool limitToCurrentBlock) const
-    {
-        CODEGEN_ASSERT(!FFlag::LuauCodegenChainedSpills);
-
-        if (instIdx >= valueRestoreOps_DEPRECATED.size())
-            return {};
-
-        // When spilled, values can only reference restore operands in the current block chain
-        if (limitToCurrentBlock)
-        {
-            for (uint32_t blockIdx : validRestoreOpBlocks)
-            {
-                const IrBlock& block = blocks[blockIdx];
-
-                if (instIdx >= block.start && instIdx <= block.finish)
-                    return valueRestoreOps_DEPRECATED[instIdx];
-            }
-
-            return {};
-        }
-
-        return valueRestoreOps_DEPRECATED[instIdx];
-    }
-
-    IrOp findRestoreOp_DEPRECATED(const IrInst& inst, bool limitToCurrentBlock) const
-    {
-        CODEGEN_ASSERT(!FFlag::LuauCodegenChainedSpills);
-
-        return findRestoreOp_DEPRECATED(getInstIndex(inst), limitToCurrentBlock);
-    }
-
     void recordRestoreLocation(uint32_t instIdx, ValueRestoreLocation location)
     {
-        CODEGEN_ASSERT(FFlag::LuauCodegenChainedSpills);
         CODEGEN_ASSERT(location.op.kind == IrOpKind::None || location.op.kind == IrOpKind::VmReg || location.op.kind == IrOpKind::VmConst);
 
-        if (instIdx >= valueRestoreOps_NEW.size())
-            valueRestoreOps_NEW.resize(instIdx + 1);
+        if (instIdx >= valueRestoreOps.size())
+            valueRestoreOps.resize(instIdx + 1);
 
-        valueRestoreOps_NEW[instIdx] = location;
+        valueRestoreOps[instIdx] = location;
     }
 
     ValueRestoreLocation findRestoreLocation(uint32_t instIdx, bool limitToCurrentBlock) const
     {
-        CODEGEN_ASSERT(FFlag::LuauCodegenChainedSpills);
-
-        if (instIdx >= valueRestoreOps_NEW.size())
+        if (instIdx >= valueRestoreOps.size())
             return {};
 
         // When spilled, values can only reference restore operands in the current block chain
@@ -1446,26 +1429,22 @@ struct IrFunction
                 const IrBlock& block = blocks[blockIdx];
 
                 if (instIdx >= block.start && instIdx <= block.finish)
-                    return valueRestoreOps_NEW[instIdx];
+                    return valueRestoreOps[instIdx];
             }
 
             return {};
         }
 
-        return valueRestoreOps_NEW[instIdx];
+        return valueRestoreOps[instIdx];
     }
 
     ValueRestoreLocation findRestoreLocation(const IrInst& inst, bool limitToCurrentBlock) const
     {
-        CODEGEN_ASSERT(FFlag::LuauCodegenChainedSpills);
-
         return findRestoreLocation(getInstIndex(inst), limitToCurrentBlock);
     }
 
     bool hasRestoreLocation(const IrInst& inst, bool limitToCurrentBlock) const
     {
-        CODEGEN_ASSERT(FFlag::LuauCodegenChainedSpills);
-
         return findRestoreLocation(getInstIndex(inst), limitToCurrentBlock).op.kind != IrOpKind::None;
     }
 

luau/CodeGen/include/Luau/IrRegAllocX64.h

@@ -54,11 +54,6 @@ struct IrRegAllocX64
 
     unsigned findSpillStackSlot(IrValueKind valueKind);
 
-    // TODO: Remove with FFlagLuauCodegenChainedSpills
-    IrOp getRestoreOp_DEPRECATED(const IrInst& inst) const;
-    bool hasRestoreOp_DEPRECATED(const IrInst& inst) const;
-    OperandX64 getRestoreAddress_DEPRECATED(const IrInst& inst, IrOp restoreOp);
-
     OperandX64 getRestoreAddress(const IrInst& inst, ValueRestoreLocation restoreLocation);
 
     // Register used by instruction is about to be freed, have to find a way to restore value later
@@ -89,7 +84,6 @@ struct IrRegAllocX64
     std::array<uint32_t, 16> xmmInstUsers;
     uint8_t usableXmmRegCount = 0;
 
-    std::bitset<256> usedSpillSlots_DEPRECATED;
     std::bitset<512> usedSpillSlotHalfs; // A bit for every stack slot split in 4 byte halfs
     unsigned maxUsedSlot = 0;            // Maximum number of 8 byte stack slots used
 

luau/CodeGen/include/Luau/IrUtils.h

@@ -129,6 +129,11 @@ inline bool hasResult(IrCmd cmd)
     case IrCmd::DIV_VEC:
     case IrCmd::IDIV_VEC:
     case IrCmd::UNM_VEC:
+    case IrCmd::MIN_VEC:
+    case IrCmd::MAX_VEC:
+    case IrCmd::FLOOR_VEC:
+    case IrCmd::CEIL_VEC:
+    case IrCmd::ABS_VEC:
     case IrCmd::DOT_VEC:
     case IrCmd::EXTRACT_VEC:
     case IrCmd::NOT_ANY:
@@ -151,7 +156,6 @@ inline bool hasResult(IrCmd cmd)
     case IrCmd::NUM_TO_UINT:
     case IrCmd::FLOAT_TO_NUM:
     case IrCmd::NUM_TO_FLOAT:
-    case IrCmd::NUM_TO_VEC_DEPRECATED:
     case IrCmd::FLOAT_TO_VEC:
     case IrCmd::TAG_VECTOR:
     case IrCmd::TRUNCATE_UINT:
@@ -280,6 +284,7 @@ inline IrCondition getNegatedCondition(IrCondition cond)
 }
 
 IrValueKind getCmdValueKind(IrCmd cmd);
+IrValueKind getConstValueKind(const IrConst& constant);
 
 template<typename F>
 void visitArguments(IrInst& inst, F&& func)
@@ -367,5 +372,8 @@ IrBlock* tryGetNextBlockInChain(IrFunction& function, IrBlock& block);
 
 bool isEntryBlock(const IrBlock& block);
 
+// When an operand is an instruction, try to extract the tag which is contained inside that value
+std::optional<uint8_t> tryGetOperandTag(IrFunction& function, IrOp op);
+
 } // namespace CodeGen
 } // namespace Luau