v0.20.2+luau722

Author: khvzak

Cargo.toml

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

luau/Ast/include/Luau/Ast.h

@@ -1,7 +1,9 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
+#include "Luau/Common.h"
 #include "Luau/Location.h"
+#include "Luau/Variant.h"
 
 #include <iterator>
 #include <optional>
@@ -11,6 +13,8 @@
 #include <string.h>
 #include <stdint.h>
 
+LUAU_FASTFLAG(DebugLuauUserDefinedClasses)
+
 namespace Luau
 {
 
@@ -1085,6 +1089,40 @@ struct AstDeclaredExternTypeProperty
     AstTableAccess access = AstTableAccess::ReadWrite;
 };
 
+struct AstClassProperty
+{
+    Location qualifierLocation;
+    AstName name;
+    Location nameLocation;
+    std::optional<Location> typeColonLocation = std::nullopt;
+    AstType* ty = nullptr;
+};
+
+struct AstClassMethod
+{
+    std::optional<Location> qualifierLocation;
+    Location keywordLocation;
+    AstName functionName;
+    Location nameLocation;
+    AstExprFunction* function;
+};
+
+using AstClassMember = Variant<AstClassProperty, AstClassMethod>;
+
+class AstStatClass : public AstStat
+{
+public:
+    LUAU_RTTI(AstStatClass)
+
+    AstLocal* name;
+    AstArray<AstClassMember> members;
+    bool exported;
+
+    AstStatClass(const Location& location, AstLocal* name, AstArray<AstClassMember> members, bool exported);
+
+    void visit(AstVisitor* visitor) override;
+};
+
 struct AstTableIndexer
 {
     AstType* indexType;
@@ -1580,6 +1618,11 @@ class AstVisitor
     {
         return visit(static_cast<AstStat*>(node));
     }
+    virtual bool visit(class AstStatClass* node)
+    {
+        LUAU_ASSERT(FFlag::DebugLuauUserDefinedClasses);
+        return visit(static_cast<AstStat*>(node));
+    }
     virtual bool visit(class AstStatDeclareExternType* node)
     {
         return visit(static_cast<AstStat*>(node));

luau/Ast/include/Luau/Cst.h

@@ -51,6 +51,16 @@ class CstNode
     const int classIndex;
 };
 
+class CstExprGroup : public CstNode
+{
+public:
+    LUAU_CST_RTTI(CstExprGroup)
+
+    explicit CstExprGroup(Position closePosition);
+
+    Position closePosition;
+};
+
 class CstExprConstantNumber : public CstNode
 {
 public:
@@ -506,6 +516,16 @@ class CstTypeSingletonString : public CstNode
     unsigned int blockDepth;
 };
 
+class CstTypeGroup : public CstNode
+{
+public:
+    LUAU_CST_RTTI(CstTypeGroup)
+
+    CstTypeGroup(Position closePosition);
+
+    Position closePosition;
+};
+
 class CstTypePackExplicit : public CstNode
 {
 public:

luau/Ast/include/Luau/Location.h

@@ -1,6 +1,8 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
+#include <climits>
+
 namespace Luau
 {
 
@@ -14,6 +16,11 @@ struct Position
     {
     }
 
+    static Position missing()
+    {
+        return {UINT_MAX, UINT_MAX};
+    }
+
     bool operator==(const Position& rhs) const
     {
         return this->column == rhs.column && this->line == rhs.line;
@@ -47,6 +54,11 @@ struct Position
     }
 
     void shift(const Position& start, const Position& oldEnd, const Position& newEnd);
+
+    bool hasValue() const
+    {
+        return line != UINT_MAX || column != UINT_MAX;
+    }
 };
 
 struct Location

luau/Ast/include/Luau/Parser.h

@@ -146,7 +146,7 @@ class Parser
     AstExpr* parseFunctionName(bool& hasself, AstName& debugname);
 
     // function funcname funcbody
-    LUAU_FORCEINLINE AstStat* parseFunctionStat(const AstArray<AstAttr*>& attributes = {nullptr, 0});
+    LUAU_FORCEINLINE AstStatFunction* parseFunctionStat(const AstArray<AstAttr*>& attributes = {nullptr, 0});
 
     std::optional<AstAttr::Type> validateAttribute(
         Location loc,
@@ -178,6 +178,8 @@ class Parser
     // type Name `=' Type
     AstStat* parseTypeAlias(const Location& start, bool exported, Position typeKeywordPosition);
 
+    AstStat* parseClassStat(const Location& start, bool exported);
+
     // type function Name ... end
     AstStat* parseTypeFunction(const Location& start, bool exported, Position typeKeywordPosition);
 
@@ -514,6 +516,7 @@ class Parser
 
     DenseHashMap<AstName, AstLocal*> localMap;
     std::vector<AstLocal*> localStack;
+    DenseHashSet<AstName> classesWithinModule{{}};
 
     std::vector<ParseError> parseErrors;
 
@@ -534,6 +537,7 @@ class Parser
     std::vector<AstType*> scratchType;
     std::vector<AstTypeOrPack> scratchTypeOrPack;
     std::vector<AstDeclaredExternTypeProperty> scratchDeclaredClassProps;
+    std::vector<AstClassMember> scratchClassDeclarations;
     std::vector<AstExprTable::Item> scratchItem;
     std::vector<CstExprTable::Item> scratchCstItem;
     std::vector<AstArgumentName> scratchArgName;

luau/Ast/include/Luau/PrettyPrinter.h

@@ -27,7 +27,7 @@ std::string prettyPrint(AstStatBlock& ast);
 std::string prettyPrintWithTypes(AstStatBlock& block);
 std::string prettyPrintWithTypes(AstStatBlock& block, const CstNodeMap& cstNodeMap);
 
-// Only fails when parsing fails
-PrettyPrintResult prettyPrint(std::string_view source, ParseOptions options = ParseOptions{}, bool withTypes = false);
+// Only fails when parsing fails and we're not ignoring parse errors.
+PrettyPrintResult prettyPrint(std::string_view source, ParseOptions options = ParseOptions{}, bool withTypes = false, bool ignoreParseErrors = false);
 
 } // namespace Luau

luau/Ast/src/Ast.cpp

@@ -978,6 +978,40 @@ AstStatDeclareFunction::AstStatDeclareFunction(
 {
 }
 
+AstStatClass::AstStatClass(const Location& location, AstLocal* name, AstArray<AstClassMember> members, bool exported)
+    : AstStat(ClassIndex(), location)
+    , name(name)
+    , members(members)
+    , exported(exported)
+{
+    LUAU_ASSERT(FFlag::DebugLuauUserDefinedClasses);
+}
+
+void AstStatClass::visit(AstVisitor* visitor)
+{
+    LUAU_ASSERT(FFlag::DebugLuauUserDefinedClasses);
+    if (visitor->visit(this))
+    {
+        for (const auto& member : members)
+        {
+            Luau::visit(
+                overloaded{
+                    [&](const AstClassProperty& prop)
+                    {
+                        if (prop.ty)
+                            prop.ty->visit(visitor);
+                    },
+                    [&](const AstClassMethod& method)
+                    {
+                        method.function->visit(visitor);
+                    }
+                },
+                member
+            );
+        }
+    }
+}
+
 AstStatDeclareFunction::AstStatDeclareFunction(
     const Location& location,
     const AstArray<AstAttr*>& attributes,

luau/Ast/src/Cst.cpp

@@ -3,11 +3,21 @@
 #include "Luau/Cst.h"
 #include "Luau/Common.h"
 
+LUAU_FASTFLAG(LuauCstExprGroup)
+LUAU_FASTFLAG(LuauCstTypeGroup)
+
 namespace Luau
 {
 
 int gCstRttiIndex = 0;
 
+CstExprGroup::CstExprGroup(Position closePosition)
+    : CstNode(CstClassIndex())
+    , closePosition(closePosition)
+{
+    LUAU_ASSERT(FFlag::LuauCstExprGroup);
+}
+
 CstExprConstantNumber::CstExprConstantNumber(const AstArray<char>& value)
     : CstNode(CstClassIndex())
     , value(value)
@@ -281,6 +291,13 @@ CstTypeSingletonString::CstTypeSingletonString(AstArray<char> sourceString, CstE
     LUAU_ASSERT(quoteStyle != CstExprConstantString::QuotedInterp);
 }
 
+CstTypeGroup::CstTypeGroup(Position closePosition)
+    : CstNode(CstClassIndex())
+    , closePosition(closePosition)
+{
+    LUAU_ASSERT(FFlag::LuauCstTypeGroup);
+}
+
 CstTypePackExplicit::CstTypePackExplicit()
     : CstNode(CstClassIndex())
     , hasParentheses(false)