v0.21.1+luau737

Author: khvzak

luau/Ast/include/Luau/Allocator.h

@@ -3,7 +3,7 @@
 
 #include "Luau/Ast.h"
 #include "Luau/Location.h"
-#include "Luau/DenseHash2.h"
+#include "Luau/DenseHash.h"
 #include "Luau/Common.h"
 
 #include <vector>

luau/Ast/include/Luau/Ast.h

@@ -742,6 +742,18 @@ class AstStatIf : public AstStat
         const std::optional<Location>& elseLocation
     );
 
+    AstStatIf(
+        const Location& location,
+        AstExpr* condition,
+        AstStatBlock* thenbody,
+        AstStat* elsebody,
+        const std::optional<Location>& thenLocation,
+        const std::optional<Location>& elseLocation,
+        AstLocal* conditionLocal,
+        bool conditionIsConst,
+        const std::optional<Location>& conditionKeywordLocation
+    );
+
     void visit(AstVisitor* visitor) override;
 
     AstExpr* condition;
@@ -752,6 +764,11 @@ class AstStatIf : public AstStat
 
     // Active for 'elseif' as well
     std::optional<Location> elseLocation;
+
+    // Active for 'if local' and 'if const' statements
+    AstLocal* conditionLocal = nullptr;
+    bool conditionIsConst = false;
+    std::optional<Location> conditionKeywordLocation;
 };
 
 class AstStatWhile : public AstStat

luau/Ast/include/Luau/Lexer.h

@@ -4,7 +4,7 @@
 #include "Luau/Allocator.h"
 #include "Luau/Ast.h"
 #include "Luau/Location.h"
-#include "Luau/DenseHash2.h"
+#include "Luau/DenseHash.h"
 #include "Luau/Common.h"
 
 #include <vector>
@@ -155,7 +155,7 @@ class AstNameTable
         size_t operator()(const Entry& e) const;
     };
 
-    DenseHashSet2<Entry, EntryHash> data;
+    DenseHashSet<Entry, EntryHash> data;
 
     Allocator& allocator;
 };

luau/Ast/include/Luau/ParseOptions.h

@@ -2,7 +2,7 @@
 #pragma once
 
 #include "Luau/Ast.h"
-#include "Luau/DenseHash2.h"
+#include "Luau/DenseHash.h"
 
 #include <vector>
 
@@ -19,7 +19,7 @@ enum class Mode
 
 struct FragmentParseResumeSettings
 {
-    DenseHashMap2<AstName, AstLocal*> localMap;
+    DenseHashMap<AstName, AstLocal*> localMap;
     std::vector<AstLocal*> localStack;
     Position resumePosition;
 };

luau/Ast/include/Luau/ParseResult.h

@@ -56,7 +56,7 @@ struct Comment
     Location location;
 };
 
-using CstNodeMap = DenseHashMap2<AstNode*, CstNode*>;
+using CstNodeMap = DenseHashMap<AstNode*, CstNode*>;
 
 struct ParseResult
 {

luau/Ast/include/Luau/Parser.h

@@ -5,7 +5,7 @@
 #include "Luau/Lexer.h"
 #include "Luau/ParseOptions.h"
 #include "Luau/ParseResult.h"
-#include "Luau/DenseHash2.h"
+#include "Luau/DenseHash.h"
 #include "Luau/Common.h"
 #include "Luau/Cst.h"
 
@@ -122,6 +122,12 @@ class Parser
     // if exp then block {elseif exp then block} [else block] end
     AstStat* parseIf();
 
+    // (`if' | `elseif') (`local' | `const') binding `=' exp then block ... end -- parses an entire `if local`/`if const`
+    AstStat* parseIfLocalCondition(const Location& start);
+
+    // Parse the trailing `{elseif exp then block} [else block] end` shared by `parseIf` and `parseIfLocalCondition`
+    AstStat* parseElseBody(const Location& start, const Lexeme& matchThen, AstStatBlock* thenbody, Location& end, std::optional<Location>& elseLocation);
+
     // while exp do block end
     AstStat* parseWhile();
 
@@ -543,15 +549,15 @@ class Parser
     std::vector<Function> functionStack;
     size_t typeFunctionDepth = 0;
 
-    DenseHashMap2<AstName, AstLocal*> localMap;
+    DenseHashMap<AstName, AstLocal*> localMap;
     std::vector<AstLocal*> localStack;
-    DenseHashMap2<AstName, AstStatClass*> classesWithinModule;
+    DenseHashMap<AstName, AstStatClass*> classesWithinModule;
 
     std::vector<ParseError> parseErrors;
 
     std::vector<unsigned int> matchRecoveryStopOnToken;
 
-    DenseHashMap2<AstName, Location> declaredExportBindings;
+    DenseHashMap<AstName, Location> declaredExportBindings;
     bool hasModuleReturn = false;
 
     std::vector<AstAttr*> scratchAttr;

luau/Ast/src/Ast.cpp

@@ -612,6 +612,29 @@ AstStatIf::AstStatIf(
 {
 }
 
+AstStatIf::AstStatIf(
+    const Location& location,
+    AstExpr* condition,
+    AstStatBlock* thenbody,
+    AstStat* elsebody,
+    const std::optional<Location>& thenLocation,
+    const std::optional<Location>& elseLocation,
+    AstLocal* conditionLocal,
+    bool conditionIsConst,
+    const std::optional<Location>& conditionKeywordLocation
+)
+    : AstStat(ClassIndex(), location)
+    , condition(condition)
+    , thenbody(thenbody)
+    , elsebody(elsebody)
+    , thenLocation(thenLocation)
+    , elseLocation(elseLocation)
+    , conditionLocal(conditionLocal)
+    , conditionIsConst(conditionIsConst)
+    , conditionKeywordLocation(conditionKeywordLocation)
+{
+}
+
 void AstStatIf::visit(AstVisitor* visitor)
 {
     if (visitor->visit(this))

luau/Ast/src/Parser.cpp

@@ -28,10 +28,10 @@ LUAU_FLAGVERSION(LuauExportValueSyntax, 4)
 LUAU_FASTFLAGVARIABLE(DebugLuauNoInline)
 LUAU_FASTFLAGVARIABLE(DebugLuauUserDefinedClasses)
 LUAU_FASTFLAGVARIABLE(LuauAllowGlobalDeclarationToBeCalledClass)
-LUAU_FASTFLAGVARIABLE(LuauStoreConstKeywordBegin)
 LUAU_FASTFLAGVARIABLE(LuauTrackPrefixLocal)
 LUAU_FASTFLAGVARIABLE(LuauNoDuplicateBinaryPrefix)
 LUAU_FASTFLAGVARIABLE(LuauSingleTypeOptionalPackReturnsAttributeParens)
+LUAU_FASTFLAGVARIABLE(DebugLuauIfLocalSyntax)
 
 // Clip with DebugLuauReportReturnTypeVariadicWithTypeSuffix
 bool luau_telemetry_parsed_return_type_variadic_with_type_suffix = false;
@@ -580,6 +580,10 @@ AstStat* Parser::parseIf()
 
     nextLexeme(); // if / elseif
 
+    if (FFlag::DebugLuauIfLocalSyntax &&
+        (lexer.current().type == Lexeme::ReservedLocal || (lexer.current().type == Lexeme::Name && AstName(lexer.current().name) == "const")))
+        return parseIfLocalCondition(start);
+
     AstExpr* cond = parseExpr();
 
     Lexeme matchThen = lexer.current();
@@ -589,9 +593,62 @@ AstStat* Parser::parseIf()
 
     AstStatBlock* thenbody = parseBlock();
 
-    AstStat* elsebody = nullptr;
     Location end = start;
     std::optional<Location> elseLocation;
+    AstStat* elsebody = parseElseBody(start, matchThen, thenbody, end, elseLocation);
+
+    return allocator.alloc<AstStatIf>(Location(start, end), cond, thenbody, elsebody, thenLocation, elseLocation);
+}
+
+// (`if' | `elseif') (`local' | `const') binding `=' exp then block {elseif exp then block} [else block] end
+//
+// LUAU_NOINLINE keeps the `if local`/`if const` locals off parseIf's frame: parseIf recurses through
+// long if/elseif chains and this variant is rarely taken. `start` is the location of the already-
+// consumed `if`/`elseif` keyword; the current lexeme is the `local`/`const` keyword.
+LUAU_NOINLINE AstStat* Parser::parseIfLocalCondition(const Location& start)
+{
+    LUAU_ASSERT(FFlag::DebugLuauIfLocalSyntax);
+
+    bool condIsConst = (lexer.current().type == Lexeme::Name && AstName(lexer.current().name) == "const");
+    std::optional<Location> condKeywordLocation = lexer.current().location;
+    nextLexeme(); // consume 'local' or 'const'
+
+    Binding binding = parseBinding(condIsConst);
+
+    if (lexer.current().type == ',')
+        report(lexer.current().location, "Expected '=' after variable name in 'if local', got ','; only a single binding is allowed");
+
+    expectAndConsume('=', "if local declaration");
+
+    AstExpr* cond = parseExpr();
+
+    unsigned int localsBegin = saveLocals();
+    AstLocal* condLocal = pushLocal(binding);
+
+    Lexeme matchThen = lexer.current();
+    std::optional<Location> thenLocation;
+    if (expectAndConsume(Lexeme::ReservedThen, "if statement"))
+        thenLocation = matchThen.location;
+
+    AstStatBlock* thenbody = parseBlock();
+
+    // Restore locals after then-block so condLocal is not visible in else/elseif
+    restoreLocals(localsBegin);
+
+    Location end = start;
+    std::optional<Location> elseLocation;
+    AstStat* elsebody = parseElseBody(start, matchThen, thenbody, end, elseLocation);
+
+    return allocator.alloc<AstStatIf>(
+        Location(start, end), cond, thenbody, elsebody, thenLocation, elseLocation, condLocal, condIsConst, condKeywordLocation
+    );
+}
+
+AstStat* Parser::parseElseBody(const Location& start, const Lexeme& matchThen, AstStatBlock* thenbody, Location& end, std::optional<Location>& elseLocation)
+{
+    AstStat* elsebody = nullptr;
+    end = start;
+    elseLocation = std::nullopt;
 
     if (lexer.current().type == Lexeme::ReservedElseif)
     {
@@ -631,7 +688,7 @@ AstStat* Parser::parseIf()
             thenbody->hasEnd = hasEnd;
     }
 
-    return allocator.alloc<AstStatIf>(Location(start, end), cond, thenbody, elsebody, thenLocation, elseLocation);
+    return elsebody;
 }
 
 // while exp do block end
@@ -1285,9 +1342,7 @@ AstStat* Parser::parseLocal(
 
         Location location{start.begin, body->location.end};
 
-        AstStatLocalFunction* node = allocator.alloc<AstStatLocalFunction>(
-            location, var, body, isConst, isConst && FFlag::LuauStoreConstKeywordBegin ? keywordPosition : Position::missing()
-        );
+        AstStatLocalFunction* node = allocator.alloc<AstStatLocalFunction>(location, var, body, isConst, isConst ? keywordPosition : Position::missing());
         if (options.storeCstData)
         {
             cstNodeMap[node] = cstAttrLists != nullptr
@@ -1502,7 +1557,7 @@ LUAU_NOINLINE AstStat* Parser::parseClassStat(const Location& start, bool export
     //
     // ... must fail. This gets the job done but maybe we can do something
     // slightly more performant here (e.g.: a "scratch" set).
-    DenseHashSet2<AstName> classMemberNamespace;
+    DenseHashSet<AstName> classMemberNamespace;
 
     while (lexer.current().type != Lexeme::ReservedEnd && lexer.current().type != Lexeme::Eof)
     {
@@ -1593,14 +1648,6 @@ LUAU_NOINLINE AstStat* Parser::parseClassStat(const Location& start, bool export
                     report(name.location, "Cannot use '%s' as a method name: names starting with '__' are reserved", name.name.value);
             }
 
-            if (name.name == "__init")
-            {
-                if (body->args.size < 1)
-                    report(name.location, "__init must have at least one parameter");
-                else if (body->args.data[0]->name != "self")
-                    report(body->args.data[0]->location, "__init's first parameter must be named self");
-            }
-
             // TODO CLI-200853: We should support attributes, we do not need
             // to support them prior to the full launch.
             if (classMemberNamespace.contains(name.name))

luau/Ast/src/PrettyPrinter.cpp

@@ -13,6 +13,7 @@
 LUAU_FASTFLAG(DebugLuauUserDefinedClasses)
 LUAU_FASTFLAG(LuauExportValueSyntax)
 LUAU_FASTFLAGVARIABLE(LuauPrettyPrintVisualizeIndexerAccess)
+LUAU_FASTFLAG(DebugLuauIfLocalSyntax)
 
 namespace
 {
@@ -1546,7 +1547,22 @@ struct Printer
 
     void visualizeElseIf(AstStatIf& elseif)
     {
-        visualize(*elseif.condition);
+        if (FFlag::DebugLuauIfLocalSyntax && elseif.conditionLocal)
+        {
+            writer.keyword(elseif.conditionIsConst ? "const" : "local");
+            writer.write(elseif.conditionLocal->name.value);
+            if (elseif.conditionLocal->annotation)
+            {
+                writer.symbol(":");
+                visualizeTypeAnnotation(*elseif.conditionLocal->annotation);
+            }
+            writer.symbol("=");
+            visualize(*elseif.condition);
+        }
+        else
+        {
+            visualize(*elseif.condition);
+        }
         if (elseif.thenLocation)
             advance(elseif.thenLocation->begin);
         writer.keyword("then");

luau/Bytecode/include/Luau/BytecodeBuilder.h

@@ -2,14 +2,26 @@
 #pragma once
 
 #include "Luau/Bytecode.h"
-#include "Luau/DenseHash2.h"
+#include "Luau/DenseHash.h"
 #include "Luau/StringUtils.h"
 
 #include <string>
 
 namespace Luau
 {
 
+static const uint32_t kMaxRegisterCount = 255;
+static const uint32_t kMaxUpvalueCount = 200;
+static const uint32_t kMaxLocalCount = 200;
+static const uint32_t kMaxInstructionCount = 1'000'000'000;
+
+static const uint8_t kInvalidReg = 255;
+
+static const uint32_t kMaxConstantCount = 1 << 23;
+static const uint32_t kMaxClosureCount = 1 << 15;
+
+static const int kMaxJumpDistance = 1 << 23;
+
 class BytecodeEncoder
 {
 public:
@@ -95,7 +107,7 @@ class BytecodeBuilder
     void patchAux(size_t targetAux, int32_t newValue);
 
     void foldJumps();
-    std::vector<uint32_t> expandJumps();
+    std::vector<uint32_t> expandJumps(bool& hasLongJumpError);
 
     void setFunctionTypeInfo(std::string value);
     void pushLocalTypeInfo(LuauBytecodeType type, uint8_t reg, uint32_t startpc, uint32_t endpc);
@@ -328,9 +340,9 @@ class BytecodeBuilder
 
     bool hasLongJumps = false;
 
-    DenseHashMap2<ConstantKey, int32_t, ConstantKeyHash> constantMap;
-    DenseHashMap2<TableShape, int32_t, TableShapeHash> tableShapeMap;
-    DenseHashMap2<uint32_t, int16_t> protoMap;
+    DenseHashMap<ConstantKey, int32_t, ConstantKeyHash> constantMap;
+    DenseHashMap<TableShape, int32_t, TableShapeHash> tableShapeMap;
+    DenseHashMap<uint32_t, int16_t> protoMap;
 
     int debugLine = 0;
 
@@ -342,7 +354,7 @@ class BytecodeBuilder
 
     std::vector<UserdataType> userdataTypes;
 
-    DenseHashMap2<StringRef, unsigned int, StringRefHash> stringTable;
+    DenseHashMap<StringRef, unsigned int, StringRefHash> stringTable;
     std::vector<StringRef> debugStrings;
 
     std::vector<std::pair<uint32_t, uint32_t>> debugRemarks;
@@ -362,6 +374,7 @@ class BytecodeBuilder
     void validate() const;
     void validateInstructions() const;
     void validateVariadic() const;
+    void validateCaptures() const;
     virtual void validateConst(int32_t cid) const;
     virtual void validateConst(int32_t cid, Constant::Type constType) const;
     virtual uint8_t validateProto(int32_t pid) const;