Bump Luau to 0.678

Author: khvzak

luau/Ast/include/Luau/Parser.h

@@ -130,7 +130,8 @@ class Parser
     // function funcname funcbody
     LUAU_FORCEINLINE AstStat* parseFunctionStat(const AstArray<AstAttr*>& attributes = {nullptr, 0});
 
-    std::pair<bool, AstAttr::Type> validateAttribute(const char* attributeName, const TempVector<AstAttr*>& attributes);
+    std::pair<bool, AstAttr::Type> validateAttribute_DEPRECATED(const char* attributeName, const TempVector<AstAttr*>& attributes);
+    std::optional<AstAttr::Type> validateAttribute(const char* attributeName, const TempVector<AstAttr*>& attributes);
 
     // attribute ::= '@' NAME
     void parseAttribute(TempVector<AstAttr*>& attribute);

luau/Ast/src/Parser.cpp

@@ -24,6 +24,7 @@ LUAU_FASTFLAGVARIABLE(LuauParseStringIndexer)
 LUAU_FASTFLAGVARIABLE(LuauStoreReturnTypesAsPackOnAst)
 LUAU_FASTFLAGVARIABLE(LuauStoreLocalAnnotationColonPositions)
 LUAU_FASTFLAGVARIABLE(LuauCSTForReturnTypeFunctionTail)
+LUAU_FASTFLAGVARIABLE(LuauParseAttributeFixUninit)
 LUAU_DYNAMIC_FASTFLAGVARIABLE(DebugLuauReportReturnTypeVariadicWithTypeSuffix, false)
 
 // Clip with DebugLuauReportReturnTypeVariadicWithTypeSuffix
@@ -808,8 +809,10 @@ AstStat* Parser::parseFunctionStat(const AstArray<AstAttr*>& attributes)
 }
 
 
-std::pair<bool, AstAttr::Type> Parser::validateAttribute(const char* attributeName, const TempVector<AstAttr*>& attributes)
+std::pair<bool, AstAttr::Type> Parser::validateAttribute_DEPRECATED(const char* attributeName, const TempVector<AstAttr*>& attributes)
 {
+    LUAU_ASSERT(!FFlag::LuauParseAttributeFixUninit);
+
     AstAttr::Type type;
 
     // check if the attribute name is valid
@@ -848,20 +851,69 @@ std::pair<bool, AstAttr::Type> Parser::validateAttribute(const char* attributeNa
     return {found, type};
 }
 
+std::optional<AstAttr::Type> Parser::validateAttribute(const char* attributeName, const TempVector<AstAttr*>& attributes)
+{
+    LUAU_ASSERT(FFlag::LuauParseAttributeFixUninit);
+
+    // check if the attribute name is valid
+    std::optional<AstAttr::Type> type;
+
+    for (int i = 0; kAttributeEntries[i].name; ++i)
+    {
+        if (strcmp(attributeName, kAttributeEntries[i].name) == 0)
+        {
+            type = kAttributeEntries[i].type;
+            break;
+        }
+    }
+
+    if (!type)
+    {
+        if (strlen(attributeName) == 1)
+            report(lexer.current().location, "Attribute name is missing");
+        else
+            report(lexer.current().location, "Invalid attribute '%s'", attributeName);
+    }
+    else
+    {
+        // check that attribute is not duplicated
+        for (const AstAttr* attr : attributes)
+        {
+            if (attr->type == *type)
+                report(lexer.current().location, "Cannot duplicate attribute '%s'", attributeName);
+        }
+    }
+
+    return type;
+}
+
 // attribute ::= '@' NAME
 void Parser::parseAttribute(TempVector<AstAttr*>& attributes)
 {
     LUAU_ASSERT(lexer.current().type == Lexeme::Type::Attribute);
 
     Location loc = lexer.current().location;
 
-    const char* name = lexer.current().name;
-    const auto [found, type] = validateAttribute(name, attributes);
+    if (FFlag::LuauParseAttributeFixUninit)
+    {
+        const char* name = lexer.current().name;
+        std::optional<AstAttr::Type> type = validateAttribute(name, attributes);
+
+        nextLexeme();
 
-    nextLexeme();
+        if (type)
+            attributes.push_back(allocator.alloc<AstAttr>(loc, *type));
+    }
+    else
+    {
+        const char* name = lexer.current().name;
+        const auto [found, type] = validateAttribute_DEPRECATED(name, attributes);
+
+        nextLexeme();
 
-    if (found)
-        attributes.push_back(allocator.alloc<AstAttr>(loc, type));
+        if (found)
+            attributes.push_back(allocator.alloc<AstAttr>(loc, type));
+    }
 }
 
 // attributes ::= {attribute}

luau/CodeGen/include/Luau/IrBuilder.h

@@ -41,6 +41,7 @@ struct IrBuilder
 
     IrOp constInt(int value);
     IrOp constUint(unsigned value);
+    IrOp constImport(unsigned value);
     IrOp constDouble(double value);
     IrOp constTag(uint8_t value);
     IrOp constAny(IrConst constant, uint64_t asCommonKey);

luau/CodeGen/include/Luau/IrData.h

@@ -392,11 +392,19 @@ enum class IrCmd : uint8_t
     // C: Rn or unsigned int (key)
     SET_TABLE,
 
+    // TODO: remove with FFlagLuauCodeGenSimplifyImport
     // Lookup a value in the environment
     // A: Rn (where to store the result)
     // B: unsigned int (import path)
     GET_IMPORT,
 
+    // Store an import from constant or the import path
+    // A: Rn (where to store the result)
+    // B: Kn
+    // C: unsigned int (import path)
+    // D: unsigned int (pcpos)
+    GET_CACHED_IMPORT,
+
     // Concatenate multiple TValues into a string
     // A: Rn (value start)
     // B: unsigned int (number of registers to go over)
@@ -763,6 +771,7 @@ enum class IrConstKind : uint8_t
     Uint,
     Double,
     Tag,
+    Import,
 };
 
 struct IrConst
@@ -1129,6 +1138,14 @@ struct IrFunction
         return value.valueUint;
     }
 
+    unsigned importOp(IrOp op)
+    {
+        IrConst& value = constOp(op);
+
+        CODEGEN_ASSERT(value.kind == IrConstKind::Import);
+        return value.valueUint;
+    }
+
     std::optional<unsigned> asUintOp(IrOp op)
     {
         if (op.kind != IrOpKind::Constant)

luau/CodeGen/include/Luau/IrDump.h

@@ -32,7 +32,7 @@ void toString(IrToStringContext& ctx, const IrInst& inst, uint32_t index);
 void toString(IrToStringContext& ctx, const IrBlock& block, uint32_t index); // Block title
 void toString(IrToStringContext& ctx, IrOp op);
 
-void toString(std::string& result, IrConst constant);
+void toString(std::string& result, Proto* proto, IrConst constant);
 
 const char* getBytecodeTypeName(uint8_t type, const char* const* userdataTypes);
 

luau/CodeGen/include/Luau/IrVisitUseDef.h

@@ -68,6 +68,9 @@ static void visitVmRegDefsUses(T& visitor, IrFunction& function, const IrInst& i
     case IrCmd::GET_IMPORT:
         visitor.def(inst.a);
         break;
+    case IrCmd::GET_CACHED_IMPORT:
+        visitor.def(inst.a);
+        break;
     case IrCmd::CONCAT:
         visitor.useRange(vmRegOp(inst.a), function.uintOp(inst.b));
 

luau/CodeGen/src/CodeGenUtils.cpp

@@ -235,6 +235,14 @@ Udata* newUserdata(lua_State* L, size_t s, int tag)
     return u;
 }
 
+void getImport(lua_State* L, StkId res, unsigned id, unsigned pc)
+{
+    Closure* cl = clvalue(L->ci->func);
+    L->ci->savedpc = cl->l.p->code + pc;
+
+    luaV_getimport(L, cl->env, cl->l.p->k, res, id, /*propagatenil*/ false);
+}
+
 // Extracted as-is from lvmexecute.cpp with the exception of control flow (reentry) and removed interrupts/savedpc
 Closure* callFallback(lua_State* L, StkId ra, StkId argtop, int nresults)
 {

luau/CodeGen/src/CodeGenUtils.h

@@ -18,6 +18,7 @@ Closure* callProlog(lua_State* L, TValue* ra, StkId argtop, int nresults);
 void callEpilogC(lua_State* L, int nresults, int n);
 
 Udata* newUserdata(lua_State* L, size_t s, int tag);
+void getImport(lua_State* L, StkId res, unsigned id, unsigned pc);
 
 #define CALL_FALLBACK_YIELD 1
 

luau/CodeGen/src/IrBuilder.cpp

@@ -676,6 +676,14 @@ IrOp IrBuilder::constUint(unsigned value)
     return constAny(constant, uint64_t(value));
 }
 
+IrOp IrBuilder::constImport(unsigned value)
+{
+    IrConst constant;
+    constant.kind = IrConstKind::Import;
+    constant.valueUint = value;
+    return constAny(constant, uint64_t(value));
+}
+
 IrOp IrBuilder::constDouble(double value)
 {
     IrConst constant;

luau/CodeGen/src/IrDump.cpp

@@ -251,6 +251,8 @@ const char* getCmdName(IrCmd cmd)
         return "SET_TABLE";
     case IrCmd::GET_IMPORT:
         return "GET_IMPORT";
+    case IrCmd::GET_CACHED_IMPORT:
+        return "GET_CACHED_IMPORT";
     case IrCmd::CONCAT:
         return "CONCAT";
     case IrCmd::GET_UPVALUE:
@@ -501,7 +503,7 @@ void toString(IrToStringContext& ctx, IrOp op)
         append(ctx.result, "undef");
         break;
     case IrOpKind::Constant:
-        toString(ctx.result, ctx.constants[op.index]);
+        toString(ctx.result, ctx.proto, ctx.constants[op.index]);
         break;
     case IrOpKind::Condition:
         CODEGEN_ASSERT(op.index < uint32_t(IrCondition::Count));
@@ -539,7 +541,7 @@ void toString(IrToStringContext& ctx, IrOp op)
     }
 }
 
-void toString(std::string& result, IrConst constant)
+void toString(std::string& result, Proto* proto, IrConst constant)
 {
     switch (constant.kind)
     {
@@ -558,6 +560,36 @@ void toString(std::string& result, IrConst constant)
     case IrConstKind::Tag:
         result.append(getTagName(constant.valueTag));
         break;
+    case IrConstKind::Import:
+        append(result, "%uu", constant.valueUint);
+
+        if (proto)
+        {
+            append(result, " (");
+
+            int count = constant.valueUint >> 30;
+            int id0 = count > 0 ? int(constant.valueUint >> 20) & 1023 : -1;
+            int id1 = count > 1 ? int(constant.valueUint >> 10) & 1023 : -1;
+            int id2 = count > 2 ? int(constant.valueUint) & 1023 : -1;
+
+            if (id0 != -1)
+                appendVmConstant(result, proto, id0);
+
+            if (id1 != -1)
+            {
+                append(result, ".");
+                appendVmConstant(result, proto, id1);
+            }
+
+            if (id2 != -1)
+            {
+                append(result, ".");
+                appendVmConstant(result, proto, id2);
+            }
+
+            append(result, ")");
+        }
+        break;
     }
 }