Sync to upstream/release/609 (#1150)

### What's changed?
* Syntax for [read-only and write-only
properties](luau-lang/rfcs#15) is now parsed,
but is not yet supported in typechecking

### New Type Solver
* `keyof` and `rawkeyof` type operators have been updated to match final
text of the [RFC](luau-lang/rfcs#16)
* Fixed issues with cyclic type families that were generated for mutable
loop variables

### Native Code Generation
* Fixed inference for number / vector operation that caused an
unnecessary VM assist

---
### Internal Contributors
Co-authored-by: Aaron Weiss <[email protected]>
Co-authored-by: Andy Friesen <[email protected]>
Co-authored-by: Lily Brown <[email protected]>
Co-authored-by: Vyacheslav Egorov <[email protected]>

Analysis/include/Luau/ConstraintGenerator.h

@@ -241,8 +241,8 @@ struct ConstraintGenerator
      * Generate constraints to assign assignedTy to the expression expr
      * @returns the type of the expression.  This may or may not be assignedTy itself.
      */
-    std::optional<TypeId> checkLValue(const ScopePtr& scope, AstExpr* expr, TypeId assignedTy);
-    std::optional<TypeId> checkLValue(const ScopePtr& scope, AstExprLocal* local, TypeId assignedTy);
+    std::optional<TypeId> checkLValue(const ScopePtr& scope, AstExpr* expr, TypeId assignedTy, bool transform);
+    std::optional<TypeId> checkLValue(const ScopePtr& scope, AstExprLocal* local, TypeId assignedTy, bool transform);
     std::optional<TypeId> checkLValue(const ScopePtr& scope, AstExprGlobal* global, TypeId assignedTy);
     std::optional<TypeId> checkLValue(const ScopePtr& scope, AstExprIndexName* indexName, TypeId assignedTy);
     std::optional<TypeId> checkLValue(const ScopePtr& scope, AstExprIndexExpr* indexExpr, TypeId assignedTy);

Analysis/include/Luau/Frontend.h

@@ -235,6 +235,7 @@ struct Frontend
     FrontendOptions options;
     InternalErrorReporter iceHandler;
     std::function<void(const ModuleName& name, const ScopePtr& scope, bool forAutocomplete)> prepareModuleScope;
+    std::function<void(const ModuleName& name, std::string log)> writeJsonLog = {};
 
     std::unordered_map<ModuleName, std::shared_ptr<SourceNode>> sourceNodes;
     std::unordered_map<ModuleName, std::shared_ptr<SourceModule>> sourceModules;
@@ -253,6 +254,6 @@ ModulePtr check(const SourceModule& sourceModule, Mode mode, const std::vector<R
 ModulePtr check(const SourceModule& sourceModule, Mode mode, const std::vector<RequireCycle>& requireCycles, NotNull<BuiltinTypes> builtinTypes,
     NotNull<InternalErrorReporter> iceHandler, NotNull<ModuleResolver> moduleResolver, NotNull<FileResolver> fileResolver,
     const ScopePtr& globalScope, std::function<void(const ModuleName&, const ScopePtr&)> prepareModuleScope, FrontendOptions options,
-    TypeCheckLimits limits, bool recordJsonLog);
+    TypeCheckLimits limits, bool recordJsonLog, std::function<void(const ModuleName&, std::string)> writeJsonLog);
 
 } // namespace Luau

Analysis/src/ConstraintGenerator.cpp

@@ -1008,12 +1008,54 @@ ControlFlow ConstraintGenerator::visit(const ScopePtr& scope, AstStatAssign* ass
     std::vector<TypeId> assignees;
     assignees.reserve(assign->vars.size);
 
+    size_t i = 0;
     for (AstExpr* lvalue : assign->vars)
     {
         TypeId assignee = arena->addType(BlockedType{});
 
-        checkLValue(scope, lvalue, assignee);
+        // This is a really weird thing to do, but it's critically important for some kinds of
+        // assignments with the current type state behavior. Consider this code:
+        // local function f(l, r)
+        //     local i = l
+        //     for _ = l, r do
+        //         i = i + 1
+        //     end
+        // end
+        //
+        // With type states now, we will not create a new state for `i` within the loop. This means
+        // that, in the absence of the analysis below, we would infer a too-broad bound for i: the
+        // cyclic type t1 where t1 = add<t1 | number, number>. In order to stop this, we say that
+        // assignments to a definition with a self-referential binary expression do not transform
+        // the type of the definition. This will only apply for loops, where the definition is
+        // shared in more places; for non-loops, there will be a separate DefId for the lvalue in
+        // the assignment, so we will deem the expression to be transformative.
+        //
+        // Deeming the addition in the code sample above as non-transformative means that i is known
+        // to be exactly number further on, ensuring the type family reduces down to number, as is
+        // expected for this code snippet.
+        //
+        // There is a potential for spurious errors here if the expression is more complex than a
+        // simple binary expression, e.g. i = (i + 1) * 2. At the time of writing, this case hasn't
+        // materialized.
+        bool transform = true;
+
+        if (assign->values.size > i)
+        {
+            AstExpr* value = assign->values.data[i];
+            if (auto bexp = value->as<AstExprBinary>())
+            {
+                DefId lvalueDef = dfg->getDef(lvalue);
+                DefId lDef = dfg->getDef(bexp->left);
+                DefId rDef = dfg->getDef(bexp->right);
+
+                if (lvalueDef == lDef || lvalueDef == rDef)
+                    transform = false;
+            }
+        }
+
+        checkLValue(scope, lvalue, assignee, transform);
         assignees.push_back(assignee);
+        ++i;
     }
 
     TypePackId resultPack = checkPack(scope, assign->values).tp;
@@ -1027,7 +1069,7 @@ ControlFlow ConstraintGenerator::visit(const ScopePtr& scope, AstStatCompoundAss
     AstExprBinary binop = AstExprBinary{assign->location, assign->op, assign->var, assign->value};
     TypeId resultTy = check(scope, &binop).ty;
 
-    checkLValue(scope, assign->var, resultTy);
+    checkLValue(scope, assign->var, resultTy, true);
 
     DefId def = dfg->getDef(assign->var);
     scope->lvalueTypes[def] = resultTy;
@@ -2210,10 +2252,10 @@ std::tuple<TypeId, TypeId, RefinementId> ConstraintGenerator::checkBinary(
     }
 }
 
-std::optional<TypeId> ConstraintGenerator::checkLValue(const ScopePtr& scope, AstExpr* expr, TypeId assignedTy)
+std::optional<TypeId> ConstraintGenerator::checkLValue(const ScopePtr& scope, AstExpr* expr, TypeId assignedTy, bool transform)
 {
     if (auto local = expr->as<AstExprLocal>())
-        return checkLValue(scope, local, assignedTy);
+        return checkLValue(scope, local, assignedTy, transform);
     else if (auto global = expr->as<AstExprGlobal>())
         return checkLValue(scope, global, assignedTy);
     else if (auto indexName = expr->as<AstExprIndexName>())
@@ -2229,7 +2271,7 @@ std::optional<TypeId> ConstraintGenerator::checkLValue(const ScopePtr& scope, As
         ice->ice("checkLValue is inexhaustive");
 }
 
-std::optional<TypeId> ConstraintGenerator::checkLValue(const ScopePtr& scope, AstExprLocal* local, TypeId assignedTy)
+std::optional<TypeId> ConstraintGenerator::checkLValue(const ScopePtr& scope, AstExprLocal* local, TypeId assignedTy, bool transform)
 {
     std::optional<TypeId> annotatedTy = scope->lookup(local->local);
     LUAU_ASSERT(annotatedTy);
@@ -2241,8 +2283,11 @@ std::optional<TypeId> ConstraintGenerator::checkLValue(const ScopePtr& scope, As
 
     if (ty)
     {
-        if (auto lt = getMutable<LocalType>(*ty))
-            ++lt->blockCount;
+        if (transform)
+        {
+            if (auto lt = getMutable<LocalType>(*ty))
+                ++lt->blockCount;
+        }
     }
     else
     {
@@ -2251,13 +2296,17 @@ std::optional<TypeId> ConstraintGenerator::checkLValue(const ScopePtr& scope, As
         scope->lvalueTypes[defId] = *ty;
     }
 
-    addConstraint(scope, local->location, UnpackConstraint{
-        arena->addTypePack({*ty}),
-        arena->addTypePack({assignedTy}),
-        /*resultIsLValue*/ true
-    });
+    if (transform)
+    {
+        addConstraint(scope, local->location, UnpackConstraint{
+            arena->addTypePack({*ty}),
+            arena->addTypePack({assignedTy}),
+            /*resultIsLValue*/ true
+        });
+
+        recordInferredBinding(local->local, *ty);
+    }
 
-    recordInferredBinding(local->local, *ty);
 
     return ty;
 }
@@ -2821,20 +2870,38 @@ TypeId ConstraintGenerator::resolveType(const ScopePtr& scope, AstType* ty, bool
 
         for (const AstTableProp& prop : tab->props)
         {
-            std::string name = prop.name.value;
-            // TODO: Recursion limit.
-            TypeId propTy = resolveType(scope, prop.type, inTypeArguments);
-            // TODO: Fill in location.
-            props[name] = {propTy};
+            if (prop.access == AstTableAccess::Read)
+                reportError(prop.accessLocation.value_or(Location{}), GenericError{"read keyword is illegal here"});
+            else if (prop.access == AstTableAccess::Write)
+                reportError(prop.accessLocation.value_or(Location{}), GenericError{"write keyword is illegal here"});
+            else if (prop.access == AstTableAccess::ReadWrite)
+            {
+                std::string name = prop.name.value;
+                // TODO: Recursion limit.
+                TypeId propTy = resolveType(scope, prop.type, inTypeArguments);
+                props[name] = {propTy};
+                props[name].typeLocation = prop.location;
+            }
+            else
+                ice->ice("Unexpected property access " + std::to_string(int(prop.access)));
         }
 
-        if (tab->indexer)
+        if (AstTableIndexer* astIndexer = tab->indexer)
         {
-            // TODO: Recursion limit.
-            indexer = TableIndexer{
-                resolveType(scope, tab->indexer->indexType, inTypeArguments),
-                resolveType(scope, tab->indexer->resultType, inTypeArguments),
-            };
+            if (astIndexer->access == AstTableAccess::Read)
+                reportError(astIndexer->accessLocation.value_or(Location{}), GenericError{"read keyword is illegal here"});
+            else if (astIndexer->access == AstTableAccess::Write)
+                reportError(astIndexer->accessLocation.value_or(Location{}), GenericError{"write keyword is illegal here"});
+            else if (astIndexer->access == AstTableAccess::ReadWrite)
+            {
+                // TODO: Recursion limit.
+                indexer = TableIndexer{
+                    resolveType(scope, astIndexer->indexType, inTypeArguments),
+                    resolveType(scope, astIndexer->resultType, inTypeArguments),
+                };
+            }
+            else
+                ice->ice("Unexpected property access " + std::to_string(int(astIndexer->access)));
         }
 
         result = arena->addType(TableType{props, indexer, scope->level, scope.get(), TableState::Sealed});
@@ -3174,11 +3241,16 @@ void ConstraintGenerator::fillInInferredBindings(const ScopePtr& globalScope, As
         const auto& [scope, location, types] = p;
 
         std::vector<TypeId> tys(types.begin(), types.end());
+        if (tys.size() == 1)
+            scope->bindings[symbol] = Binding{tys.front(), location};
+        else
+        {
+            TypeId ty = arena->addType(BlockedType{});
+            addConstraint(globalScope, Location{}, SetOpConstraint{SetOpConstraint::Union, ty, std::move(tys)});
 
-        TypeId ty = arena->addType(BlockedType{});
-        addConstraint(globalScope, Location{}, SetOpConstraint{SetOpConstraint::Union, ty, std::move(tys)});
+            scope->bindings[symbol] = Binding{ty, location};
+        }
 
-        scope->bindings[symbol] = Binding{ty, location};
     }
 }
 

Analysis/src/EmbeddedBuiltinDefinitions.cpp

@@ -1,47 +1,13 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #include "Luau/BuiltinDefinitions.h"
 
-LUAU_FASTFLAGVARIABLE(LuauBufferTypeck, false)
-LUAU_FASTFLAGVARIABLE(LuauCheckedEmbeddedDefinitions, false);
+LUAU_FASTFLAGVARIABLE(LuauCheckedEmbeddedDefinitions2, false);
+LUAU_FASTFLAG(LuauCheckedFunctionSyntax);
 
 namespace Luau
 {
 
-static const std::string kBuiltinDefinitionBufferSrc_DEPRECATED = R"BUILTIN_SRC(
-
--- TODO: this will be replaced with a built-in primitive type
-declare class buffer end
-
-declare buffer: {
-    create: (size: number) -> buffer,
-    fromstring: (str: string) -> buffer,
-    tostring: () -> string,
-    len: (b: buffer) -> number,
-    copy: (target: buffer, targetOffset: number, source: buffer, sourceOffset: number?, count: number?) -> (),
-    fill: (b: buffer, offset: number, value: number, count: number?) -> (),
-    readi8: (b: buffer, offset: number) -> number,
-    readu8: (b: buffer, offset: number) -> number,
-    readi16: (b: buffer, offset: number) -> number,
-    readu16: (b: buffer, offset: number) -> number,
-    readi32: (b: buffer, offset: number) -> number,
-    readu32: (b: buffer, offset: number) -> number,
-    readf32: (b: buffer, offset: number) -> number,
-    readf64: (b: buffer, offset: number) -> number,
-    writei8: (b: buffer, offset: number, value: number) -> (),
-    writeu8: (b: buffer, offset: number, value: number) -> (),
-    writei16: (b: buffer, offset: number, value: number) -> (),
-    writeu16: (b: buffer, offset: number, value: number) -> (),
-    writei32: (b: buffer, offset: number, value: number) -> (),
-    writeu32: (b: buffer, offset: number, value: number) -> (),
-    writef32: (b: buffer, offset: number, value: number) -> (),
-    writef64: (b: buffer, offset: number, value: number) -> (),
-    readstring: (b: buffer, offset: number, count: number) -> string,
-    writestring: (b: buffer, offset: number, value: string, count: number?) -> (),
-}
-
-)BUILTIN_SRC";
-
-static const std::string kBuiltinDefinitionBufferSrc = R"BUILTIN_SRC(
+static const std::string kBuiltinDefinitionLuaSrc = R"BUILTIN_SRC(
 
 declare buffer: {
     create: (size: number) -> buffer,
@@ -70,9 +36,6 @@ declare buffer: {
     writestring: (b: buffer, offset: number, value: string, count: number?) -> (),
 }
 
-)BUILTIN_SRC";
-static const std::string kBuiltinDefinitionLuaSrc = R"BUILTIN_SRC(
-
 declare bit32: {
     band: (...number) -> number,
     bor: (...number) -> number,
@@ -488,12 +451,8 @@ std::string getBuiltinDefinitionSource()
 {
     std::string result = kBuiltinDefinitionLuaSrc;
 
-    if (FFlag::LuauBufferTypeck)
-        result = kBuiltinDefinitionBufferSrc + result;
-    else
-        result = kBuiltinDefinitionBufferSrc_DEPRECATED + result;
     // Annotates each non generic function as checked
-    if (FFlag::LuauCheckedEmbeddedDefinitions)
+    if (FFlag::LuauCheckedEmbeddedDefinitions2 && FFlag::LuauCheckedFunctionSyntax)
         result = kBuiltinDefinitionLuaSrcChecked;
 
     return result;

Analysis/src/Frontend.cpp

@@ -36,6 +36,7 @@ LUAU_FASTFLAGVARIABLE(DebugLuauDeferredConstraintResolution, false)
 LUAU_FASTFLAGVARIABLE(DebugLuauLogSolverToJson, false)
 LUAU_FASTFLAGVARIABLE(DebugLuauReadWriteProperties, false)
 LUAU_FASTFLAGVARIABLE(LuauRethrowSingleModuleIce, false)
+LUAU_FASTFLAGVARIABLE(DebugLuauLogSolverToJsonFile, false)
 
 namespace Luau
 {
@@ -872,6 +873,7 @@ void Frontend::addBuildQueueItems(std::vector<BuildQueueItem>& items, std::vecto
 
         data.config = configResolver->getConfig(moduleName);
         data.environmentScope = getModuleEnvironment(*sourceModule, data.config, frontendOptions.forAutocomplete);
+        data.recordJsonLog = FFlag::DebugLuauLogSolverToJson;
 
         Mode mode = sourceModule->mode.value_or(data.config.mode);
 
@@ -1169,17 +1171,17 @@ const SourceModule* Frontend::getSourceModule(const ModuleName& moduleName) cons
 ModulePtr check(const SourceModule& sourceModule, Mode mode, const std::vector<RequireCycle>& requireCycles, NotNull<BuiltinTypes> builtinTypes,
     NotNull<InternalErrorReporter> iceHandler, NotNull<ModuleResolver> moduleResolver, NotNull<FileResolver> fileResolver,
     const ScopePtr& parentScope, std::function<void(const ModuleName&, const ScopePtr&)> prepareModuleScope, FrontendOptions options,
-    TypeCheckLimits limits)
+    TypeCheckLimits limits, std::function<void(const ModuleName&, std::string)> writeJsonLog)
 {
     const bool recordJsonLog = FFlag::DebugLuauLogSolverToJson;
     return check(sourceModule, mode, requireCycles, builtinTypes, iceHandler, moduleResolver, fileResolver, parentScope,
-        std::move(prepareModuleScope), options, limits, recordJsonLog);
+        std::move(prepareModuleScope), options, limits, recordJsonLog, writeJsonLog);
 }
 
 ModulePtr check(const SourceModule& sourceModule, Mode mode, const std::vector<RequireCycle>& requireCycles, NotNull<BuiltinTypes> builtinTypes,
     NotNull<InternalErrorReporter> iceHandler, NotNull<ModuleResolver> moduleResolver, NotNull<FileResolver> fileResolver,
     const ScopePtr& parentScope, std::function<void(const ModuleName&, const ScopePtr&)> prepareModuleScope, FrontendOptions options,
-    TypeCheckLimits limits, bool recordJsonLog)
+    TypeCheckLimits limits, bool recordJsonLog, std::function<void(const ModuleName&, std::string)> writeJsonLog)
 {
     ModulePtr result = std::make_shared<Module>();
     result->name = sourceModule.name;
@@ -1281,7 +1283,10 @@ ModulePtr check(const SourceModule& sourceModule, Mode mode, const std::vector<R
     if (recordJsonLog)
     {
         std::string output = logger->compileOutput();
-        printf("%s\n", output.c_str());
+        if (FFlag::DebugLuauLogSolverToJsonFile && writeJsonLog)
+            writeJsonLog(sourceModule.name, std::move(output));
+        else
+            printf("%s\n", output.c_str());
     }
 
     return result;
@@ -1301,7 +1306,7 @@ ModulePtr Frontend::check(const SourceModule& sourceModule, Mode mode, std::vect
         {
             return Luau::check(sourceModule, mode, requireCycles, builtinTypes, NotNull{&iceHandler},
                 NotNull{forAutocomplete ? &moduleResolverForAutocomplete : &moduleResolver}, NotNull{fileResolver},
-                environmentScope ? *environmentScope : globals.globalScope, prepareModuleScopeWrap, options, typeCheckLimits, recordJsonLog);
+                environmentScope ? *environmentScope : globals.globalScope, prepareModuleScopeWrap, options, typeCheckLimits, recordJsonLog, writeJsonLog);
         }
         catch (const InternalCompilerError& err)
         {

Analysis/src/GlobalTypes.cpp

@@ -2,8 +2,6 @@
 
 #include "Luau/GlobalTypes.h"
 
-LUAU_FASTFLAG(LuauBufferTypeck)
-
 namespace Luau
 {
 
@@ -18,8 +16,7 @@ GlobalTypes::GlobalTypes(NotNull<BuiltinTypes> builtinTypes)
     globalScope->addBuiltinTypeBinding("string", TypeFun{{}, builtinTypes->stringType});
     globalScope->addBuiltinTypeBinding("boolean", TypeFun{{}, builtinTypes->booleanType});
     globalScope->addBuiltinTypeBinding("thread", TypeFun{{}, builtinTypes->threadType});
-    if (FFlag::LuauBufferTypeck)
-        globalScope->addBuiltinTypeBinding("buffer", TypeFun{{}, builtinTypes->bufferType});
+    globalScope->addBuiltinTypeBinding("buffer", TypeFun{{}, builtinTypes->bufferType});
     globalScope->addBuiltinTypeBinding("unknown", TypeFun{{}, builtinTypes->unknownType});
     globalScope->addBuiltinTypeBinding("never", TypeFun{{}, builtinTypes->neverType});
 

Analysis/src/Linter.cpp

@@ -14,8 +14,6 @@
 
 LUAU_FASTINTVARIABLE(LuauSuggestionDistance, 4)
 
-LUAU_FASTFLAG(LuauBufferTypeck)
-
 namespace Luau
 {
 
@@ -1107,7 +1105,7 @@ class LintUnknownType : AstVisitor
     TypeKind getTypeKind(const std::string& name)
     {
         if (name == "nil" || name == "boolean" || name == "userdata" || name == "number" || name == "string" || name == "table" ||
-            name == "function" || name == "thread" || (FFlag::LuauBufferTypeck && name == "buffer"))
+            name == "function" || name == "thread" || name == "buffer")
             return Kind_Primitive;
 
         if (name == "vector")