Sync to upstream/release/633 (#1318)

# What's Changed?

- Mostly stability and bugfixes with the new solver.

## New Solver

- Typechecking with the new solver should respect the no-check hot
comment.
- Record type alias locations and property locations of table
assignments
- Maintain location information for exported table types
- Stability fixes for normalization
- Report internal constraint solver errors.

---
### Internal Contributors

Co-authored-by: Aaron Weiss <aaronweiss@roblox.com>
Co-authored-by: Alexander McCord <amccord@roblox.com>
Co-authored-by: Andy Friesen <afriesen@roblox.com>
Co-authored-by: Vighnesh Vijay <vvijay@roblox.com>
Co-authored-by: Vyacheslav Egorov <vegorov@roblox.com>

---------

Co-authored-by: Aaron Weiss <aaronweiss@roblox.com>
Co-authored-by: Alexander McCord <amccord@roblox.com>
Co-authored-by: Andy Friesen <afriesen@roblox.com>
Co-authored-by: Aviral Goel <agoel@roblox.com>
Co-authored-by: David Cope <dcope@roblox.com>
Co-authored-by: Lily Brown <lbrown@roblox.com>
Co-authored-by: Vyacheslav Egorov <vegorov@roblox.com>

Author: 8 people

Analysis/include/Luau/Constraint.h

@@ -202,6 +202,10 @@ struct AssignPropConstraint
     std::string propName;
     TypeId rhsType;
 
+    /// If a new property is to be inserted into a table type, it will be
+    /// ascribed this location.
+    std::optional<Location> propLocation;
+
     /// The canonical write type of the property.  It is _solely_ used to
     /// populate astTypes during constraint resolution.  Nothing should ever
     /// block on it.

Analysis/src/ConstraintGenerator.cpp

@@ -1246,6 +1246,9 @@ ControlFlow ConstraintGenerator::visit(const ScopePtr& scope, AstStatTypeAlias*
         return ControlFlow::None;
     }
 
+    scope->typeAliasLocations[alias->name.value] = alias->location;
+    scope->typeAliasNameLocations[alias->name.value] = alias->nameLocation;
+
     ScopePtr* defnScope = astTypeAliasDefiningScopes.find(alias);
 
     std::unordered_map<Name, TypeFun>* typeBindings;
@@ -2441,7 +2444,7 @@ void ConstraintGenerator::visitLValue(const ScopePtr& scope, AstExprIndexName* e
 
     bool incremented = recordPropertyAssignment(lhsTy);
 
-    auto apc = addConstraint(scope, expr->location, AssignPropConstraint{lhsTy, expr->index.value, rhsType, propTy, incremented});
+    auto apc = addConstraint(scope, expr->location, AssignPropConstraint{lhsTy, expr->index.value, rhsType, expr->indexLocation, propTy, incremented});
     getMutable<BlockedType>(propTy)->setOwner(apc);
 }
 
@@ -2457,7 +2460,7 @@ void ConstraintGenerator::visitLValue(const ScopePtr& scope, AstExprIndexExpr* e
 
         bool incremented = recordPropertyAssignment(lhsTy);
 
-        auto apc = addConstraint(scope, expr->location, AssignPropConstraint{lhsTy, std::move(propName), rhsType, propTy, incremented});
+        auto apc = addConstraint(scope, expr->location, AssignPropConstraint{lhsTy, std::move(propName), rhsType, expr->index->location, propTy, incremented});
         getMutable<BlockedType>(propTy)->setOwner(apc);
 
         return;
@@ -2478,6 +2481,7 @@ Inference ConstraintGenerator::check(const ScopePtr& scope, AstExprTable* expr,
     LUAU_ASSERT(ttv);
 
     ttv->state = TableState::Unsealed;
+    ttv->definitionModuleName = module->name;
     ttv->scope = scope.get();
 
     interiorTypes.back().push_back(ty);
@@ -2509,7 +2513,7 @@ Inference ConstraintGenerator::check(const ScopePtr& scope, AstExprTable* expr,
             if (AstExprConstantString* key = item.key->as<AstExprConstantString>())
             {
                 std::string propName{key->value.data, key->value.size};
-                ttv->props[propName] = {itemTy};
+                ttv->props[propName] = {itemTy, /*deprecated*/ false, {}, key->location};
             }
             else
             {

Analysis/src/ConstraintSolver.cpp

@@ -486,6 +486,9 @@ void ConstraintSolver::run()
             progress |= runSolverPass(true);
     } while (progress);
 
+    if (!unsolvedConstraints.empty())
+        reportError(InternalError{"Type inference failed to complete, you may see some confusing types and type errors."}, Location{});
+
     // After we have run all the constraints, type families should be generalized
     // At this point, we can try to perform one final simplification to suss out
     // whether type families are truly uninhabited or if they can reduce
@@ -1729,7 +1732,10 @@ bool ConstraintSolver::tryDispatch(const AssignPropConstraint& c, NotNull<const
         if (lhsTable->state == TableState::Unsealed || lhsTable->state == TableState::Free)
         {
             bind(constraint, c.propType, rhsType);
-            lhsTable->props[propName] = Property::rw(rhsType);
+            Property& newProp = lhsTable->props[propName];
+            newProp.readTy = rhsType;
+            newProp.writeTy = rhsType;
+            newProp.location = c.propLocation;
 
             if (lhsTable->state == TableState::Unsealed && c.decrementPropCount)
             {

Analysis/src/Frontend.cpp

@@ -41,6 +41,7 @@ LUAU_FASTFLAGVARIABLE(DebugLuauLogSolverToJsonFile, false)
 LUAU_FASTFLAGVARIABLE(DebugLuauForbidInternalTypes, false)
 LUAU_FASTFLAGVARIABLE(DebugLuauForceStrictMode, false)
 LUAU_FASTFLAGVARIABLE(DebugLuauForceNonStrictMode, false)
+LUAU_FASTFLAGVARIABLE(LuauSourceModuleUpdatedWithSelectedMode, false)
 
 namespace Luau
 {
@@ -918,6 +919,9 @@ void Frontend::checkBuildQueueItem(BuildQueueItem& item)
         mode = Mode::Nonstrict;
     else
         mode = sourceModule.mode.value_or(config.mode);
+
+    if (FFlag::LuauSourceModuleUpdatedWithSelectedMode)
+        item.sourceModule->mode = {mode};
     ScopePtr environmentScope = item.environmentScope;
     double timestamp = getTimestamp();
     const std::vector<RequireCycle>& requireCycles = item.requireCycles;
@@ -1240,9 +1244,7 @@ ModulePtr check(const SourceModule& sourceModule, Mode mode, const std::vector<R
     ModulePtr result = std::make_shared<Module>();
     result->name = sourceModule.name;
     result->humanReadableName = sourceModule.humanReadableName;
-
-    result->mode = sourceModule.mode.value_or(Mode::NoCheck);
-
+    result->mode = mode;
     result->internalTypes.owningModule = result.get();
     result->interfaceTypes.owningModule = result.get();
 
@@ -1323,10 +1325,19 @@ ModulePtr check(const SourceModule& sourceModule, Mode mode, const std::vector<R
     }
     else
     {
-        if (mode == Mode::Nonstrict)
+        switch (mode)
+        {
+        case Mode::Nonstrict:
             Luau::checkNonStrict(builtinTypes, iceHandler, NotNull{&unifierState}, NotNull{&dfg}, NotNull{&limits}, sourceModule, result.get());
-        else
+            break;
+        case Mode::Definition:
+            // fallthrough intentional
+        case Mode::Strict:
             Luau::check(builtinTypes, NotNull{&unifierState}, NotNull{&limits}, logger.get(), sourceModule, result.get());
+            break;
+        case Mode::NoCheck:
+            break;
+        };
     }
 
     unfreeze(result->interfaceTypes);

Analysis/src/Normalize.cpp

@@ -255,8 +255,10 @@ bool isSubtype(const NormalizedStringType& subStr, const NormalizedStringType& s
 
 void NormalizedClassType::pushPair(TypeId ty, TypeIds negations)
 {
-    ordering.push_back(ty);
-    classes.insert(std::make_pair(ty, std::move(negations)));
+    auto result = classes.insert(std::make_pair(ty, std::move(negations)));
+    if (result.second)
+        ordering.push_back(ty);
+    LUAU_ASSERT(ordering.size() == classes.size());
 }
 
 void NormalizedClassType::resetToNever()

Analysis/src/Substitution.cpp

@@ -753,7 +753,12 @@ void Substitution::replaceChildren(TypeId ty)
         for (auto& [name, prop] : ttv->props)
         {
             if (FFlag::DebugLuauDeferredConstraintResolution)
-                prop = Property::create(replace(prop.readTy), replace(prop.writeTy));
+            {
+                if (prop.readTy)
+                    prop.readTy = replace(prop.readTy);
+                if (prop.writeTy)
+                    prop.writeTy = replace(prop.writeTy);
+            }
             else
                 prop.setType(replace(prop.type()));
         }

CodeGen/include/Luau/IrDump.h

@@ -31,10 +31,8 @@ void toString(IrToStringContext& ctx, IrOp op);
 
 void toString(std::string& result, IrConst constant);
 
-const char* getBytecodeTypeName_DEPRECATED(uint8_t type);
 const char* getBytecodeTypeName(uint8_t type, const char* const* userdataTypes);
 
-void toString_DEPRECATED(std::string& result, const BytecodeTypes& bcTypes);
 void toString(std::string& result, const BytecodeTypes& bcTypes, const char* const* userdataTypes);
 
 void toStringDetailed(

CodeGen/src/BytecodeAnalysis.cpp

@@ -11,7 +11,6 @@
 
 #include <algorithm>
 
-LUAU_FASTFLAGVARIABLE(LuauCodegenUserdataOps, false)
 LUAU_FASTFLAGVARIABLE(LuauCodegenFastcall3, false)
 
 namespace Luau
@@ -749,50 +748,27 @@ void analyzeBytecodeTypes(IrFunction& function, const HostIrHooks& hostHooks)
 
                 regTags[ra] = LBC_TYPE_ANY;
 
-                if (FFlag::LuauCodegenUserdataOps)
-                {
-                    TString* str = gco2ts(function.proto->k[kc].value.gc);
-                    const char* field = getstr(str);
+                TString* str = gco2ts(function.proto->k[kc].value.gc);
+                const char* field = getstr(str);
 
-                    if (bcType.a == LBC_TYPE_VECTOR)
+                if (bcType.a == LBC_TYPE_VECTOR)
+                {
+                    if (str->len == 1)
                     {
-                        if (str->len == 1)
-                        {
-                            // Same handling as LOP_GETTABLEKS block in lvmexecute.cpp - case-insensitive comparison with "X" / "Y" / "Z"
-                            char ch = field[0] | ' ';
-
-                            if (ch == 'x' || ch == 'y' || ch == 'z')
-                                regTags[ra] = LBC_TYPE_NUMBER;
-                        }
+                        // Same handling as LOP_GETTABLEKS block in lvmexecute.cpp - case-insensitive comparison with "X" / "Y" / "Z"
+                        char ch = field[0] | ' ';
 
-                        if (regTags[ra] == LBC_TYPE_ANY && hostHooks.vectorAccessBytecodeType)
-                            regTags[ra] = hostHooks.vectorAccessBytecodeType(field, str->len);
-                    }
-                    else if (isCustomUserdataBytecodeType(bcType.a))
-                    {
-                        if (regTags[ra] == LBC_TYPE_ANY && hostHooks.userdataAccessBytecodeType)
-                            regTags[ra] = hostHooks.userdataAccessBytecodeType(bcType.a, field, str->len);
+                        if (ch == 'x' || ch == 'y' || ch == 'z')
+                            regTags[ra] = LBC_TYPE_NUMBER;
                     }
+
+                    if (regTags[ra] == LBC_TYPE_ANY && hostHooks.vectorAccessBytecodeType)
+                        regTags[ra] = hostHooks.vectorAccessBytecodeType(field, str->len);
                 }
-                else
+                else if (isCustomUserdataBytecodeType(bcType.a))
                 {
-                    if (bcType.a == LBC_TYPE_VECTOR)
-                    {
-                        TString* str = gco2ts(function.proto->k[kc].value.gc);
-                        const char* field = getstr(str);
-
-                        if (str->len == 1)
-                        {
-                            // Same handling as LOP_GETTABLEKS block in lvmexecute.cpp - case-insensitive comparison with "X" / "Y" / "Z"
-                            char ch = field[0] | ' ';
-
-                            if (ch == 'x' || ch == 'y' || ch == 'z')
-                                regTags[ra] = LBC_TYPE_NUMBER;
-                        }
-
-                        if (regTags[ra] == LBC_TYPE_ANY && hostHooks.vectorAccessBytecodeType)
-                            regTags[ra] = hostHooks.vectorAccessBytecodeType(field, str->len);
-                    }
+                    if (regTags[ra] == LBC_TYPE_ANY && hostHooks.userdataAccessBytecodeType)
+                        regTags[ra] = hostHooks.userdataAccessBytecodeType(bcType.a, field, str->len);
                 }
 
                 bcType.result = regTags[ra];
@@ -829,7 +805,7 @@ void analyzeBytecodeTypes(IrFunction& function, const HostIrHooks& hostHooks)
                     regTags[ra] = LBC_TYPE_NUMBER;
                 else if (bcType.a == LBC_TYPE_VECTOR && bcType.b == LBC_TYPE_VECTOR)
                     regTags[ra] = LBC_TYPE_VECTOR;
-                else if (FFlag::LuauCodegenUserdataOps && hostHooks.userdataMetamethodBytecodeType &&
+                else if (hostHooks.userdataMetamethodBytecodeType &&
                          (isCustomUserdataBytecodeType(bcType.a) || isCustomUserdataBytecodeType(bcType.b)))
                     regTags[ra] = hostHooks.userdataMetamethodBytecodeType(bcType.a, bcType.b, opcodeToHostMetamethod(op));
 
@@ -861,7 +837,7 @@ void analyzeBytecodeTypes(IrFunction& function, const HostIrHooks& hostHooks)
                     if (bcType.b == LBC_TYPE_NUMBER || bcType.b == LBC_TYPE_VECTOR)
                         regTags[ra] = LBC_TYPE_VECTOR;
                 }
-                else if (FFlag::LuauCodegenUserdataOps && hostHooks.userdataMetamethodBytecodeType &&
+                else if (hostHooks.userdataMetamethodBytecodeType &&
                          (isCustomUserdataBytecodeType(bcType.a) || isCustomUserdataBytecodeType(bcType.b)))
                 {
                     regTags[ra] = hostHooks.userdataMetamethodBytecodeType(bcType.a, bcType.b, opcodeToHostMetamethod(op));
@@ -884,7 +860,7 @@ void analyzeBytecodeTypes(IrFunction& function, const HostIrHooks& hostHooks)
 
                 if (bcType.a == LBC_TYPE_NUMBER && bcType.b == LBC_TYPE_NUMBER)
                     regTags[ra] = LBC_TYPE_NUMBER;
-                else if (FFlag::LuauCodegenUserdataOps && hostHooks.userdataMetamethodBytecodeType &&
+                else if (hostHooks.userdataMetamethodBytecodeType &&
                          (isCustomUserdataBytecodeType(bcType.a) || isCustomUserdataBytecodeType(bcType.b)))
                     regTags[ra] = hostHooks.userdataMetamethodBytecodeType(bcType.a, bcType.b, opcodeToHostMetamethod(op));
 
@@ -907,7 +883,7 @@ void analyzeBytecodeTypes(IrFunction& function, const HostIrHooks& hostHooks)
                     regTags[ra] = LBC_TYPE_NUMBER;
                 else if (bcType.a == LBC_TYPE_VECTOR && bcType.b == LBC_TYPE_VECTOR)
                     regTags[ra] = LBC_TYPE_VECTOR;
-                else if (FFlag::LuauCodegenUserdataOps && hostHooks.userdataMetamethodBytecodeType &&
+                else if (hostHooks.userdataMetamethodBytecodeType &&
                          (isCustomUserdataBytecodeType(bcType.a) || isCustomUserdataBytecodeType(bcType.b)))
                     regTags[ra] = hostHooks.userdataMetamethodBytecodeType(bcType.a, bcType.b, opcodeToHostMetamethod(op));
 
@@ -939,7 +915,7 @@ void analyzeBytecodeTypes(IrFunction& function, const HostIrHooks& hostHooks)
                     if (bcType.b == LBC_TYPE_NUMBER || bcType.b == LBC_TYPE_VECTOR)
                         regTags[ra] = LBC_TYPE_VECTOR;
                 }
-                else if (FFlag::LuauCodegenUserdataOps && hostHooks.userdataMetamethodBytecodeType &&
+                else if (hostHooks.userdataMetamethodBytecodeType &&
                          (isCustomUserdataBytecodeType(bcType.a) || isCustomUserdataBytecodeType(bcType.b)))
                 {
                     regTags[ra] = hostHooks.userdataMetamethodBytecodeType(bcType.a, bcType.b, opcodeToHostMetamethod(op));
@@ -962,7 +938,7 @@ void analyzeBytecodeTypes(IrFunction& function, const HostIrHooks& hostHooks)
 
                 if (bcType.a == LBC_TYPE_NUMBER && bcType.b == LBC_TYPE_NUMBER)
                     regTags[ra] = LBC_TYPE_NUMBER;
-                else if (FFlag::LuauCodegenUserdataOps && hostHooks.userdataMetamethodBytecodeType &&
+                else if (hostHooks.userdataMetamethodBytecodeType &&
                          (isCustomUserdataBytecodeType(bcType.a) || isCustomUserdataBytecodeType(bcType.b)))
                     regTags[ra] = hostHooks.userdataMetamethodBytecodeType(bcType.a, bcType.b, opcodeToHostMetamethod(op));
 
@@ -984,7 +960,7 @@ void analyzeBytecodeTypes(IrFunction& function, const HostIrHooks& hostHooks)
                     regTags[ra] = LBC_TYPE_NUMBER;
                 else if (bcType.a == LBC_TYPE_VECTOR && bcType.b == LBC_TYPE_VECTOR)
                     regTags[ra] = LBC_TYPE_VECTOR;
-                else if (FFlag::LuauCodegenUserdataOps && hostHooks.userdataMetamethodBytecodeType &&
+                else if (hostHooks.userdataMetamethodBytecodeType &&
                          (isCustomUserdataBytecodeType(bcType.a) || isCustomUserdataBytecodeType(bcType.b)))
                     regTags[ra] = hostHooks.userdataMetamethodBytecodeType(bcType.a, bcType.b, opcodeToHostMetamethod(op));
 
@@ -1014,7 +990,7 @@ void analyzeBytecodeTypes(IrFunction& function, const HostIrHooks& hostHooks)
                     if (bcType.b == LBC_TYPE_NUMBER || bcType.b == LBC_TYPE_VECTOR)
                         regTags[ra] = LBC_TYPE_VECTOR;
                 }
-                else if (FFlag::LuauCodegenUserdataOps && hostHooks.userdataMetamethodBytecodeType &&
+                else if (hostHooks.userdataMetamethodBytecodeType &&
                          (isCustomUserdataBytecodeType(bcType.a) || isCustomUserdataBytecodeType(bcType.b)))
                 {
                     regTags[ra] = hostHooks.userdataMetamethodBytecodeType(bcType.a, bcType.b, opcodeToHostMetamethod(op));
@@ -1047,7 +1023,7 @@ void analyzeBytecodeTypes(IrFunction& function, const HostIrHooks& hostHooks)
                     regTags[ra] = LBC_TYPE_NUMBER;
                 else if (bcType.a == LBC_TYPE_VECTOR)
                     regTags[ra] = LBC_TYPE_VECTOR;
-                else if (FFlag::LuauCodegenUserdataOps && hostHooks.userdataMetamethodBytecodeType && isCustomUserdataBytecodeType(bcType.a))
+                else if (hostHooks.userdataMetamethodBytecodeType && isCustomUserdataBytecodeType(bcType.a))
                     regTags[ra] = hostHooks.userdataMetamethodBytecodeType(bcType.a, LBC_TYPE_ANY, HostMetamethod::Minus);
 
                 bcType.result = regTags[ra];
@@ -1203,26 +1179,13 @@ void analyzeBytecodeTypes(IrFunction& function, const HostIrHooks& hostHooks)
 
                 bcType.result = LBC_TYPE_FUNCTION;
 
-                if (FFlag::LuauCodegenUserdataOps)
-                {
-                    TString* str = gco2ts(function.proto->k[kc].value.gc);
-                    const char* field = getstr(str);
+                TString* str = gco2ts(function.proto->k[kc].value.gc);
+                const char* field = getstr(str);
 
-                    if (bcType.a == LBC_TYPE_VECTOR && hostHooks.vectorNamecallBytecodeType)
-                        knownNextCallResult = LuauBytecodeType(hostHooks.vectorNamecallBytecodeType(field, str->len));
-                    else if (isCustomUserdataBytecodeType(bcType.a) && hostHooks.userdataNamecallBytecodeType)
-                        knownNextCallResult = LuauBytecodeType(hostHooks.userdataNamecallBytecodeType(bcType.a, field, str->len));
-                }
-                else
-                {
-                    if (bcType.a == LBC_TYPE_VECTOR && hostHooks.vectorNamecallBytecodeType)
-                    {
-                        TString* str = gco2ts(function.proto->k[kc].value.gc);
-                        const char* field = getstr(str);
-
-                        knownNextCallResult = LuauBytecodeType(hostHooks.vectorNamecallBytecodeType(field, str->len));
-                    }
-                }
+                if (bcType.a == LBC_TYPE_VECTOR && hostHooks.vectorNamecallBytecodeType)
+                    knownNextCallResult = LuauBytecodeType(hostHooks.vectorNamecallBytecodeType(field, str->len));
+                else if (isCustomUserdataBytecodeType(bcType.a) && hostHooks.userdataNamecallBytecodeType)
+                    knownNextCallResult = LuauBytecodeType(hostHooks.userdataNamecallBytecodeType(bcType.a, field, str->len));
                 break;
             }
             case LOP_CALL: