v0.15.6+luau688

Author: khvzak

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "luau0-src"
-version = "0.15.5+luau686"
+version = "0.15.6+luau688"
 authors = ["Aleksandr Orlenko <[email protected]>"]
 edition = "2021"
 repository = "https://github.com/mlua-rs/luau-src-rs"

luau/Ast/include/Luau/Ast.h

@@ -197,7 +197,14 @@ class AstAttr : public AstNode
         Deprecated,
     };
 
-    AstAttr(const Location& location, Type type);
+    struct DeprecatedInfo
+    {
+        bool deprecated = false;
+        std::optional<std::string> use;
+        std::optional<std::string> reason;
+    };
+
+    AstAttr(const Location& location, Type type, AstArray<AstExpr*> args);
 
     AstAttr* asAttr() override
     {
@@ -206,7 +213,10 @@ class AstAttr : public AstNode
 
     void visit(AstVisitor* visitor) override;
 
+    DeprecatedInfo deprecatedInfo() const;
+
     Type type;
+    AstArray<AstExpr*> args;
 };
 
 class AstExpr : public AstNode
@@ -329,9 +339,28 @@ class AstExprConstantString : public AstExpr
 
     enum QuoteStyle
     {
+        // A string created using double quotes or an interpolated string,
+        // as in:
+        //
+        //  "foo", `My name is {protagonist}! / And I'm {antagonist}!`
+        //
         QuotedSimple,
+        // A string created using single quotes, as in:
+        //
+        //  'bar'
+        //
+        QuotedSingle,
+        // A string created using `[[ ... ]]` as in:
+        //
+        //   [[ Gee, this sure is a long string.
+        //   it even has a new line in it! ]]
+        //
         QuotedRaw,
-        Unquoted
+        // A "string" in the context of a table literal, as in:
+        //
+        //  { foo = 42 } -- `foo` here is a "constant string"
+        //
+        Unquoted,
     };
 
     AstExprConstantString(const Location& location, const AstArray<char>& value, QuoteStyle quoteStyle);
@@ -455,6 +484,7 @@ class AstExprFunction : public AstExpr
 
     bool hasNativeAttribute() const;
     bool hasAttribute(AstAttr::Type attributeType) const;
+    AstAttr* getAttribute(AstAttr::Type attributeType) const;
 
     AstArray<AstAttr*> attributes;
     AstArray<AstGenericType*> generics;
@@ -499,6 +529,8 @@ class AstExprTable : public AstExpr
 
     void visit(AstVisitor* visitor) override;
 
+    std::optional<AstExpr*> getRecord(const char* key) const;
+
     AstArray<Item> items;
 };
 
@@ -960,6 +992,7 @@ class AstStatDeclareFunction : public AstStat
 
     bool isCheckedFunction() const;
     bool hasAttribute(AstAttr::Type attributeType) const;
+    AstAttr* getAttribute(AstAttr::Type attributeType) const;
 
     AstArray<AstAttr*> attributes;
     AstName name;
@@ -1117,6 +1150,7 @@ class AstTypeFunction : public AstType
 
     bool isCheckedFunction() const;
     bool hasAttribute(AstAttr::Type attributeType) const;
+    AstAttr* getAttribute(AstAttr::Type attributeType) const;
 
     AstArray<AstAttr*> attributes;
     AstArray<AstGenericType*> generics;
@@ -1561,6 +1595,8 @@ class AstVisitor
 };
 
 bool isLValue(const AstExpr*);
+bool isConstantLiteral(const AstExpr*);
+bool isLiteralTable(const AstExpr*);
 AstName getIdentifier(AstExpr*);
 Location getLocation(const AstTypeList& typeList);
 

luau/Ast/include/Luau/Lexer.h

@@ -55,6 +55,7 @@ struct Lexeme
         BlockComment,
 
         Attribute,
+        AttributeOpen,
 
         BrokenString,
         BrokenComment,

luau/Ast/include/Luau/Parser.h

@@ -130,7 +130,13 @@ class Parser
     // function funcname funcbody
     LUAU_FORCEINLINE AstStat* parseFunctionStat(const AstArray<AstAttr*>& attributes = {nullptr, 0});
 
-    std::optional<AstAttr::Type> validateAttribute(const char* attributeName, const TempVector<AstAttr*>& attributes);
+    std::optional<AstAttr::Type> validateAttribute(
+        Location loc,
+        const char* attributeName,
+        const TempVector<AstAttr*>& attributes,
+        const AstArray<AstExpr*>& args
+    );
+    std::optional<AstAttr::Type> validateAttribute_DEPRECATED(const char* attributeName, const TempVector<AstAttr*>& attributes);
 
     // attribute ::= '@' NAME
     void parseAttribute(TempVector<AstAttr*>& attribute);
@@ -287,6 +293,7 @@ class Parser
     // simpleexp -> NUMBER | STRING | NIL | true | false | ... | constructor | [attributes] FUNCTION body | primaryexp
     AstExpr* parseSimpleExpr();
 
+    std::tuple<AstArray<AstExpr*>, Location, Location> parseCallList(TempVector<Position>* commaPositions);
     // args ::=  `(' [explist] `)' | tableconstructor | String
     AstExpr* parseFunctionArgs(AstExpr* func, bool self);
 

luau/Ast/src/Ast.cpp

@@ -2,19 +2,40 @@
 #include "Luau/Ast.h"
 
 #include "Luau/Common.h"
+#include "Luau/StringUtils.h"
+
+LUAU_FASTFLAG(LuauParametrizedAttributeSyntax)
 
 namespace Luau
 {
 
-static bool hasAttributeInArray(const AstArray<AstAttr*> attributes, AstAttr::Type attributeType)
+static AstAttr* findAttributeInArray(const AstArray<AstAttr*> attributes, AstAttr::Type attributeType)
 {
     for (const auto attribute : attributes)
     {
         if (attribute->type == attributeType)
-            return true;
+            return attribute;
     }
 
-    return false;
+    return nullptr;
+}
+
+static bool hasAttributeInArray(const AstArray<AstAttr*> attributes, AstAttr::Type attributeType)
+{
+    if (FFlag::LuauParametrizedAttributeSyntax)
+    {
+        return findAttributeInArray(attributes, attributeType) != nullptr;
+    }
+    else
+    {
+        for (const auto attribute : attributes)
+        {
+            if (attribute->type == attributeType)
+                return true;
+        }
+
+        return false;
+    }
 }
 
 static void visitTypeList(AstVisitor* visitor, const AstTypeList& list)
@@ -26,9 +47,10 @@ static void visitTypeList(AstVisitor* visitor, const AstTypeList& list)
         list.tailType->visit(visitor);
 }
 
-AstAttr::AstAttr(const Location& location, Type type)
+AstAttr::AstAttr(const Location& location, Type type, AstArray<AstExpr*> args)
     : AstNode(ClassIndex(), location)
     , type(type)
+    , args(args)
 {
 }
 
@@ -37,6 +59,29 @@ void AstAttr::visit(AstVisitor* visitor)
     visitor->visit(this);
 }
 
+AstAttr::DeprecatedInfo AstAttr::deprecatedInfo() const
+{
+    AstAttr::DeprecatedInfo info;
+    info.deprecated = type == AstAttr::Type::Deprecated;
+
+    if (info.deprecated && args.size > 0)
+    {
+        AstExprTable* table = args.data[0]->as<AstExprTable>();
+        if (auto useValue = table->getRecord("use"))
+        {
+            AstArray<char> use = (*useValue)->as<AstExprConstantString>()->value;
+            info.use = {{use.data, use.size}};
+        }
+        if (auto reasonValue = table->getRecord("reason"))
+        {
+            AstArray<char> reason = (*reasonValue)->as<AstExprConstantString>()->value;
+            info.reason = {{reason.data, reason.size}};
+        }
+    }
+
+    return info;
+}
+
 int gAstRttiIndex = 0;
 
 AstGenericType::AstGenericType(const Location& location, AstName name, AstType* defaultValue)
@@ -293,6 +338,11 @@ bool AstExprFunction::hasAttribute(const AstAttr::Type attributeType) const
     return hasAttributeInArray(attributes, attributeType);
 }
 
+AstAttr* AstExprFunction::getAttribute(const AstAttr::Type attributeType) const
+{
+    return findAttributeInArray(attributes, attributeType);
+}
+
 AstExprTable::AstExprTable(const Location& location, const AstArray<Item>& items)
     : AstExpr(ClassIndex(), location)
     , items(items)
@@ -313,6 +363,19 @@ void AstExprTable::visit(AstVisitor* visitor)
     }
 }
 
+std::optional<AstExpr*> AstExprTable::getRecord(const char* key) const
+{
+    for (const AstExprTable::Item& item : items)
+    {
+        if (item.kind == AstExprTable::Item::Kind::Record)
+        {
+            if (strcmp(item.key->as<AstExprConstantString>()->value.data, key) == 0)
+                return item.value;
+        }
+    }
+    return {};
+}
+
 AstExprUnary::AstExprUnary(const Location& location, Op op, AstExpr* expr)
     : AstExpr(ClassIndex(), location)
     , op(op)
@@ -917,6 +980,11 @@ bool AstStatDeclareFunction::hasAttribute(AstAttr::Type attributeType) const
     return hasAttributeInArray(attributes, attributeType);
 }
 
+AstAttr* AstStatDeclareFunction::getAttribute(const AstAttr::Type attributeType) const
+{
+    return findAttributeInArray(attributes, attributeType);
+}
+
 AstStatDeclareExternType::AstStatDeclareExternType(
     const Location& location,
     const AstName& name,
@@ -1085,6 +1153,11 @@ bool AstTypeFunction::hasAttribute(AstAttr::Type attributeType) const
     return hasAttributeInArray(attributes, attributeType);
 }
 
+AstAttr* AstTypeFunction::getAttribute(AstAttr::Type attributeType) const
+{
+    return findAttributeInArray(attributes, attributeType);
+}
+
 AstTypeTypeof::AstTypeTypeof(const Location& location, AstExpr* expr)
     : AstType(ClassIndex(), location)
     , expr(expr)
@@ -1234,6 +1307,34 @@ bool isLValue(const AstExpr* expr)
     return expr->is<AstExprLocal>() || expr->is<AstExprGlobal>() || expr->is<AstExprIndexName>() || expr->is<AstExprIndexExpr>();
 }
 
+bool isConstantLiteral(const AstExpr* expr)
+{
+    return expr->is<AstExprConstantNil>() || expr->is<AstExprConstantBool>() || expr->is<AstExprConstantNumber>() ||
+           expr->is<AstExprConstantString>();
+}
+
+bool isLiteralTable(const AstExpr* expr)
+{
+    if (!expr->is<AstExprTable>())
+        return false;
+
+    for (const AstExprTable::Item& item : expr->as<AstExprTable>()->items)
+    {
+        switch (item.kind)
+        {
+        case AstExprTable::Item::Kind::General:
+            return false;
+            break;
+        case AstExprTable::Item::Kind::Record:
+        case AstExprTable::Item::Kind::List:
+            if (!isConstantLiteral(item.value) && !isLiteralTable(item.value))
+                return false;
+            break;
+        }
+    }
+    return true;
+}
+
 AstName getIdentifier(AstExpr* node)
 {
     if (AstExprGlobal* expr = node->as<AstExprGlobal>())

luau/Ast/src/Lexer.cpp

@@ -8,6 +8,8 @@
 
 #include <limits.h>
 
+LUAU_FASTFLAG(LuauParametrizedAttributeSyntax)
+
 namespace Luau
 {
 
@@ -147,6 +149,9 @@ std::string Lexeme::toString() const
     case Attribute:
         return name ? format("'%s'", name) : "attribute";
 
+    case AttributeOpen:
+        return "'@['";
+
     case BrokenString:
         return "malformed string";
 
@@ -981,8 +986,36 @@ Lexeme Lexer::readNext()
     }
     case '@':
     {
-        std::pair<AstName, Lexeme::Type> attribute = readName();
-        return Lexeme(Location(start, position()), Lexeme::Attribute, attribute.first.value);
+        if (FFlag::LuauParametrizedAttributeSyntax)
+        {
+            if (peekch(1) == '[')
+            {
+                consume();
+                consume();
+
+                return Lexeme(Location(start, 2), Lexeme::AttributeOpen);
+            }
+            else
+            {
+                // consume @ first
+                consume();
+
+                if (isAlpha(peekch()) || peekch() == '_')
+                {
+                    std::pair<AstName, Lexeme::Type> attribute = readName();
+                    return Lexeme(Location(start, position()), Lexeme::Attribute, attribute.first.value);
+                }
+                else
+                {
+                    return Lexeme(Location(start, position()), Lexeme::Attribute, "");
+                }
+            }
+        }
+        else
+        {
+            std::pair<AstName, Lexeme::Type> attribute = readName();
+            return Lexeme(Location(start, position()), Lexeme::Attribute, attribute.first.value);
+        }
     }
     default:
         if (isDigit(peekch()))