Update Luau to 0.647

Author: khvzak

luau/Ast/include/Luau/ParseOptions.h

@@ -1,6 +1,11 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
+#include "Luau/Ast.h"
+#include "Luau/DenseHash.h"
+
+#include <vector>
+
 namespace Luau
 {
 
@@ -12,10 +17,17 @@ enum class Mode
     Definition, // Type definition module, has special parsing rules
 };
 
+struct FragmentParseResumeSettings
+{
+    DenseHashMap<AstName, AstLocal*> localMap{AstName()};
+    std::vector<AstLocal*> localStack;
+};
+
 struct ParseOptions
 {
     bool allowDeclarationSyntax = false;
     bool captureComments = false;
+    std::optional<FragmentParseResumeSettings> parseFragment = std::nullopt;
 };
 
 } // namespace Luau

luau/Ast/include/Luau/Parser.h

@@ -146,7 +146,7 @@ class Parser
     AstStat* parseTypeAlias(const Location& start, bool exported);
 
     // type function Name ... end
-    AstStat* parseTypeFunction(const Location& start);
+    AstStat* parseTypeFunction(const Location& start, bool exported);
 
     AstDeclaredClassProp parseDeclaredClassMethod();
 
@@ -423,6 +423,7 @@ class Parser
     MatchLexeme endMismatchSuspect;
 
     std::vector<Function> functionStack;
+    size_t typeFunctionDepth = 0;
 
     DenseHashMap<AstName, AstLocal*> localMap;
     std::vector<AstLocal*> localStack;
@@ -452,4 +453,4 @@ class Parser
     std::string scratchData;
 };
 
-} // namespace Luau
+} // namespace Luau

luau/Ast/include/Luau/TimeTrace.h

@@ -7,6 +7,7 @@
 #include <memory>
 
 #include <stdint.h>
+#include <string.h>
 
 LUAU_FASTFLAG(DebugLuauTimeTracing)
 

luau/Ast/src/Ast.cpp

@@ -5,6 +5,11 @@
 
 LUAU_FASTFLAG(LuauNativeAttribute);
 
+// The default value here is 643 because the first release in which this was implemented is 644,
+// and actively we want new changes to be off by default until they're enabled consciously.
+// The flag is placed in AST project here to be common in all Luau libraries
+LUAU_DYNAMIC_FASTINTVARIABLE(LuauTypeSolverRelease, 643)
+
 namespace Luau
 {
 

luau/Ast/src/Lexer.cpp

@@ -7,8 +7,6 @@
 
 #include <limits.h>
 
-LUAU_FASTFLAGVARIABLE(LuauLexerLookaheadRemembersBraceType, false)
-
 namespace Luau
 {
 
@@ -434,13 +432,11 @@ Lexeme Lexer::lookahead()
     lineOffset = currentLineOffset;
     lexeme = currentLexeme;
     prevLocation = currentPrevLocation;
-    if (FFlag::LuauLexerLookaheadRemembersBraceType)
-    {
-        if (braceStack.size() < currentBraceStackSize)
-            braceStack.push_back(currentBraceType);
-        else if (braceStack.size() > currentBraceStackSize)
-            braceStack.pop_back();
-    }
+
+    if (braceStack.size() < currentBraceStackSize)
+        braceStack.push_back(currentBraceType);
+    else if (braceStack.size() > currentBraceStackSize)
+        braceStack.pop_back();
 
     return result;
 }

luau/Ast/src/Parser.cpp

@@ -16,10 +16,11 @@ LUAU_FASTINTVARIABLE(LuauParseErrorLimit, 100)
 // Warning: If you are introducing new syntax, ensure that it is behind a separate
 // flag so that we don't break production games by reverting syntax changes.
 // See docs/SyntaxChanges.md for an explanation.
-LUAU_FASTFLAGVARIABLE(DebugLuauDeferredConstraintResolution, false)
+LUAU_FASTFLAGVARIABLE(LuauSolverV2, false)
 LUAU_FASTFLAGVARIABLE(LuauNativeAttribute, false)
 LUAU_FASTFLAGVARIABLE(LuauAttributeSyntaxFunExpr, false)
-LUAU_FASTFLAGVARIABLE(LuauUserDefinedTypeFunctions, false)
+LUAU_FASTFLAGVARIABLE(LuauUserDefinedTypeFunctionsSyntax2, false)
+LUAU_FASTFLAGVARIABLE(LuauAllowFragmentParsing, false)
 
 namespace Luau
 {
@@ -211,6 +212,15 @@ Parser::Parser(const char* buffer, size_t bufferSize, AstNameTable& names, Alloc
     scratchExpr.reserve(16);
     scratchLocal.reserve(16);
     scratchBinding.reserve(16);
+
+    if (FFlag::LuauAllowFragmentParsing)
+    {
+        if (options.parseFragment)
+        {
+            localMap = options.parseFragment->localMap;
+            localStack = options.parseFragment->localStack;
+        }
+    }
 }
 
 bool Parser::blockFollow(const Lexeme& l)
@@ -784,6 +794,7 @@ AstStat* Parser::parseAttributeStat()
             AstExpr* expr = parsePrimaryExpr(/* asStatement= */ true);
             return parseDeclaration(expr->location, attributes);
         }
+        [[fallthrough]];
     default:
         return reportStatError(
             lexer.current().location,
@@ -890,10 +901,10 @@ AstStat* Parser::parseReturn()
 AstStat* Parser::parseTypeAlias(const Location& start, bool exported)
 {
     // parsing a type function
-    if (FFlag::LuauUserDefinedTypeFunctions)
+    if (FFlag::LuauUserDefinedTypeFunctionsSyntax2)
     {
         if (lexer.current().type == Lexeme::ReservedFunction)
-            return parseTypeFunction(start);
+            return parseTypeFunction(start, exported);
     }
 
     // parsing a type alias
@@ -916,20 +927,28 @@ AstStat* Parser::parseTypeAlias(const Location& start, bool exported)
 }
 
 // type function Name `(' arglist `)' `=' funcbody `end'
-AstStat* Parser::parseTypeFunction(const Location& start)
+AstStat* Parser::parseTypeFunction(const Location& start, bool exported)
 {
     Lexeme matchFn = lexer.current();
     nextLexeme();
 
+    if (exported)
+        report(start, "Type function cannot be exported");
+
     // parse the name of the type function
     std::optional<Name> fnName = parseNameOpt("type function name");
     if (!fnName)
         fnName = Name(nameError, lexer.current().location);
 
     matchRecoveryStopOnToken[Lexeme::ReservedEnd]++;
 
+    size_t oldTypeFunctionDepth = typeFunctionDepth;
+    typeFunctionDepth = functionStack.size();
+
     AstExprFunction* body = parseFunctionBody(/* hasself */ false, matchFn, fnName->name, nullptr, AstArray<AstAttr*>({nullptr, 0})).first;
 
+    typeFunctionDepth = oldTypeFunctionDepth;
+
     matchRecoveryStopOnToken[Lexeme::ReservedEnd]--;
 
     return allocator.alloc<AstStatTypeFunction>(Location(start, body->location), fnName->name, fnName->location, body);
@@ -2280,6 +2299,12 @@ AstExpr* Parser::parseNameExpr(const char* context)
     {
         AstLocal* local = *value;
 
+        if (FFlag::LuauUserDefinedTypeFunctionsSyntax2)
+        {
+            if (local->functionDepth < typeFunctionDepth)
+                return reportExprError(lexer.current().location, {}, "Type function cannot reference outer local '%s'", local->name.value);
+        }
+
         return allocator.alloc<AstExprLocal>(name->location, local, local->functionDepth != functionStack.size() - 1);
     }
 

luau/Ast/src/TimeTrace.cpp

@@ -3,6 +3,7 @@
 
 #include "Luau/StringUtils.h"
 
+#include <algorithm>
 #include <mutex>
 #include <string>
 

luau/CodeGen/src/CodeGenContext.cpp

@@ -346,13 +346,13 @@ void SharedCodeGenContextDeleter::operator()(const SharedCodeGenContext* codeGen
     return static_cast<BaseCodeGenContext*>(L->global->ecb.context);
 }
 
-static void onCloseState(lua_State* L) noexcept
+static void onCloseState(lua_State* L)
 {
     getCodeGenContext(L)->onCloseState();
     L->global->ecb = lua_ExecutionCallbacks{};
 }
 
-static void onDestroyFunction(lua_State* L, Proto* proto) noexcept
+static void onDestroyFunction(lua_State* L, Proto* proto)
 {
     getCodeGenContext(L)->onDestroyFunction(proto->execdata);
     proto->execdata = nullptr;

luau/CodeGen/src/IrLoweringA64.cpp

@@ -11,8 +11,6 @@
 #include "lstate.h"
 #include "lgc.h"
 
-LUAU_FASTFLAGVARIABLE(LuauCodegenArmNumToVecFix, false)
-
 namespace Luau
 {
 namespace CodeGen
@@ -1121,7 +1119,7 @@ void IrLoweringA64::lowerInst(IrInst& inst, uint32_t index, const IrBlock& next)
         else
         {
             RegisterA64 tempd = tempDouble(inst.a);
-            RegisterA64 temps = FFlag::LuauCodegenArmNumToVecFix ? regs.allocTemp(KindA64::s) : castReg(KindA64::s, tempd);
+            RegisterA64 temps = regs.allocTemp(KindA64::s);
 
             build.fcvt(temps, tempd);
             build.dup_4s(inst.regA64, castReg(KindA64::q, temps), 0);

luau/Common/include/Luau/Bytecode.h

@@ -441,7 +441,7 @@ enum LuauBytecodeTag
     // Bytecode version; runtime supports [MIN, MAX], compiler emits TARGET by default but may emit a higher version when flags are enabled
     LBC_VERSION_MIN = 3,
     LBC_VERSION_MAX = 6,
-    LBC_VERSION_TARGET = 5,
+    LBC_VERSION_TARGET = 6,
     // Type encoding version
     LBC_TYPE_VERSION_MIN = 1,
     LBC_TYPE_VERSION_MAX = 3,

luau/Common/include/Luau/Common.h

@@ -20,6 +20,19 @@
 #define LUAU_DEBUGBREAK() __builtin_trap()
 #endif
 
+// LUAU_FALLTHROUGH is a C++11-compatible alternative to [[fallthrough]] for use in the VM library
+#if defined(__clang__) && defined(__has_warning)
+#if __has_feature(cxx_attributes) && __has_warning("-Wimplicit-fallthrough")
+#define LUAU_FALLTHROUGH [[clang::fallthrough]]
+#else
+#define LUAU_FALLTHROUGH
+#endif
+#elif defined(__GNUC__) && __GNUC__ >= 7
+#define LUAU_FALLTHROUGH [[gnu::fallthrough]]
+#else
+#define LUAU_FALLTHROUGH
+#endif
+
 #if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
 #define LUAU_BIG_ENDIAN
 #endif

luau/Common/include/Luau/ExperimentalFlags.h

@@ -14,6 +14,7 @@ inline bool isFlagExperimental(const char* flag)
         "LuauInstantiateInSubtyping",      // requires some fixes to lua-apps code
         "LuauFixIndexerSubtypingOrdering", // requires some small fixes to lua-apps code since this fixes a false negative
         "StudioReportLuauAny2",             // takes telemetry data for usage of any types 
+        "LuauSolverV2",
         // makes sure we always have at least one entry
         nullptr,
     };