v0.15.4+luau682

Author: khvzak

Cargo.toml

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

luau/Ast/src/Parser.cpp

@@ -20,7 +20,6 @@ LUAU_FASTINTVARIABLE(LuauParseErrorLimit, 100)
 LUAU_FASTFLAGVARIABLE(LuauSolverV2)
 LUAU_FASTFLAGVARIABLE(LuauDeclareExternType)
 LUAU_FASTFLAGVARIABLE(LuauParseStringIndexer)
-LUAU_FASTFLAGVARIABLE(LuauCSTForReturnTypeFunctionTail)
 LUAU_FASTFLAGVARIABLE(LuauParseAttributeFixUninit)
 LUAU_DYNAMIC_FASTFLAGVARIABLE(DebugLuauReportReturnTypeVariadicWithTypeSuffix, false)
 
@@ -1903,10 +1902,8 @@ AstTypePack* Parser::parseReturnType()
     // possibly () -> ReturnType
     if (lexer.current().type != ')')
     {
-        if (FFlag::LuauCSTForReturnTypeFunctionTail && options.storeCstData)
+        if (options.storeCstData)
             varargAnnotation = parseTypeList(result, resultNames, &commaPositions, &nameColonPositions);
-        else if (options.storeCstData)
-            varargAnnotation = parseTypeList(result, resultNames, &commaPositions);
         else
             varargAnnotation = parseTypeList(result, resultNames);
     }
@@ -1950,7 +1947,7 @@ AstTypePack* Parser::parseReturnType()
     Position returnArrowPosition = lexer.current().location.begin;
     AstType* tail = parseFunctionTypeTail(begin, {nullptr, 0}, {}, {}, copy(result), copy(resultNames), varargAnnotation);
 
-    if (FFlag::LuauCSTForReturnTypeFunctionTail && options.storeCstData && tail->is<AstTypeFunction>())
+    if (options.storeCstData && tail->is<AstTypeFunction>())
     {
         cstNodeMap[tail] = allocator.alloc<CstTypeFunction>(
             Position{0, 0},

luau/CodeGen/include/Luau/IrData.h

@@ -392,7 +392,7 @@ enum class IrCmd : uint8_t
     // C: Rn or unsigned int (key)
     SET_TABLE,
 
-    // TODO: remove with FFlagLuauCodeGenSimplifyImport
+    // TODO: remove with FFlagLuauCodeGenSimplifyImport2
     // Lookup a value in the environment
     // A: Rn (where to store the result)
     // B: unsigned int (import path)

luau/CodeGen/src/IrLoweringA64.cpp

@@ -1384,7 +1384,10 @@ void IrLoweringA64::lowerInst(IrInst& inst, uint32_t index, const IrBlock& next)
         break;
     case IrCmd::GET_CACHED_IMPORT:
     {
+        regs.spill(build, index);
+
         Label skip, exit;
+
         RegisterA64 tempTag = regs.allocTemp(KindA64::w);
 
         AddressA64 addrConstTag = tempAddr(inst.b, offsetof(TValue, tt));
@@ -1395,25 +1398,21 @@ void IrLoweringA64::lowerInst(IrInst& inst, uint32_t index, const IrBlock& next)
         build.cbnz(tempTag, skip);
 
         {
-            size_t spills = regs.spill(build, index);
-
             build.mov(x0, rState);
             build.add(x1, rBase, uint16_t(vmRegOp(inst.a) * sizeof(TValue)));
             build.mov(w2, importOp(inst.c));
             build.mov(w3, uintOp(inst.d));
             build.ldr(x4, mem(rNativeContext, offsetof(NativeContext, getImport)));
             build.blr(x4);
 
-            regs.restore(build, spills); // Need to restore before skip so that registers are in a consistent state
-
             emitUpdateBase(build);
             build.b(exit);
         }
 
-        RegisterA64 tempTv = regs.allocTemp(KindA64::q);
-
         build.setLabel(skip);
 
+        RegisterA64 tempTv = regs.allocTemp(KindA64::q);
+
         AddressA64 addrConst = tempAddr(inst.b, 0);
         build.ldr(tempTv, addrConst);
 

luau/CodeGen/src/IrLoweringX64.cpp

@@ -1221,6 +1221,9 @@ void IrLoweringX64::lowerInst(IrInst& inst, uint32_t index, const IrBlock& next)
     }
     case IrCmd::GET_CACHED_IMPORT:
     {
+        regs.assertAllFree();
+        regs.assertNoSpills();
+
         Label skip, exit;
 
         // If the constant for the import is set, we will use it directly, otherwise we have to call an import path lookup function
@@ -1241,9 +1244,10 @@ void IrLoweringX64::lowerInst(IrInst& inst, uint32_t index, const IrBlock& next)
         emitUpdateBase(build);
         build.jmp(exit);
 
+        build.setLabel(skip);
+
         ScopedRegX64 tmp1{regs, SizeX64::xmmword};
 
-        build.setLabel(skip);
         build.vmovups(tmp1.reg, luauConstant(vmConstOp(inst.b)));
         build.vmovups(luauReg(vmRegOp(inst.a)), tmp1.reg);
         build.setLabel(exit);

luau/CodeGen/src/IrTranslation.cpp

@@ -12,7 +12,7 @@
 #include "lstate.h"
 #include "ltm.h"
 
-LUAU_FASTFLAGVARIABLE(LuauCodeGenSimplifyImport)
+LUAU_FASTFLAGVARIABLE(LuauCodeGenSimplifyImport2)
 
 namespace Luau
 {
@@ -1217,7 +1217,7 @@ void translateInstGetImport(IrBuilder& build, const Instruction* pc, int pcpos)
     int k = LUAU_INSN_D(*pc);
     uint32_t aux = pc[1];
 
-    if (FFlag::LuauCodeGenSimplifyImport)
+    if (FFlag::LuauCodeGenSimplifyImport2)
     {
         build.inst(IrCmd::CHECK_SAFE_ENV, build.vmExit(pcpos));
         build.inst(IrCmd::GET_CACHED_IMPORT, build.vmReg(ra), build.vmConst(k), build.constImport(aux), build.constUint(pcpos + 1));

luau/CodeGen/src/OptimizeConstProp.cpp

@@ -1545,6 +1545,8 @@ static void constPropInInst(ConstPropState& state, IrBuilder& build, IrFunction&
         // Outside of safe environment, environment traversal for an import can execute custom code
         if (!state.inSafeEnv)
             state.invalidateUserCall();
+
+        state.invalidateValuePropagation();
         break;
     case IrCmd::CONCAT:
         state.invalidateRegisterRange(vmRegOp(inst.a), function.uintOp(inst.b));

luau/Compiler/src/Compiler.cpp

@@ -4300,40 +4300,20 @@ void compileOrThrow(BytecodeBuilder& bytecode, const ParseResult& parseResult, c
     }
 
     // computes type information for all functions based on type annotations
-    if (FFlag::LuauSeparateCompilerTypeInfo)
-    {
-        if (options.typeInfoLevel >= 1 || options.optimizationLevel >= 2)
-            buildTypeMap(
-                compiler.functionTypes,
-                compiler.localTypes,
-                compiler.exprTypes,
-                root,
-                options.vectorType,
-                compiler.userdataTypes,
-                compiler.builtinTypes,
-                compiler.builtins,
-                compiler.globals,
-                options.libraryMemberTypeCb,
-                bytecode
-            );
-    }
-    else
-    {
-        if (options.typeInfoLevel >= 1)
-            buildTypeMap(
-                compiler.functionTypes,
-                compiler.localTypes,
-                compiler.exprTypes,
-                root,
-                options.vectorType,
-                compiler.userdataTypes,
-                compiler.builtinTypes,
-                compiler.builtins,
-                compiler.globals,
-                options.libraryMemberTypeCb,
-                bytecode
-            );
-    }
+    if (options.typeInfoLevel >= 1 || options.optimizationLevel >= 2)
+        buildTypeMap(
+            compiler.functionTypes,
+            compiler.localTypes,
+            compiler.exprTypes,
+            root,
+            options.vectorType,
+            compiler.userdataTypes,
+            compiler.builtinTypes,
+            compiler.builtins,
+            compiler.globals,
+            options.libraryMemberTypeCb,
+            bytecode
+        );
 
     for (AstExprFunction* expr : functions)
     {