Sync to upstream/release/674 (#1832)

# General

* Expose an optional `get_alias` API as an alternative to `get_config`
in Luau.Require and Luau.RequireNavigator.
* Improve the Luau CLI's virtual filesystem implementation to fix bugs
related to `init.luau`. Fixes
#1816


# New Type Solver

* Avoid double reporting errors when erroneous arguments are provided to
type functions.
* Fix some instances of unresovable cyclic type functions in loops by
only considering the first loop cycles. This results in some type
inference inaccuracies when the type of a variable in loop through
multiple iterations. Fixes
#1413.
* Better generalize free types that have meaningful lower and upper
bounds, especially for table indexers.
* Report more specific errors when assigning or returning table literal
types, instead of citing the *entire* table type.
* Inference for functions with generic type packs is greatly improved.
* Fix some internal compiler exceptions when using type-stating
functions like `table.freeze` in `if _ then _ else _` expressions and
short circuiting binary operations.
* More consistently simplify unions of primitive types, especially in
array-like and dictionary-like tables.
* Fix a crash when type checking an erroneous type alias containing
`typeof` with a type assertion expression, as in:
  ```
  type MyTable = {}
  -- This will error at type checking time as it's a duplicate
  type MyTable = typeof(setmetatable(SomeTable :: {}, SomeMetaTable));
  ```
* Fix a crash when inferring the type of an index expression where the
indexee is invalid (e.g. `nil`).

# Runtime
* Avoid throwing an exception from `luau_load` if we run out of memory.
* Type functions are no longer compiled and included in bytecode. Fixes
#1817.
* Fix some instances of Luau C API functions reading invalid debug
information (generally when the first or last instruction of a block was
being inspected). Fixes #1369.
* Avoid potential signed integer overflow when doing bounds checks on
tables.
* Support 16 byte aligned userdata objects when system allocation
alignment is also 16 bytes.
* Fix memory leaks in `Luau.Require` when using VM build with no
exceptions. Fixes #1827.

---------

Co-authored-by: Andy Friesen <afriesen@roblox.com>
Co-authored-by: Ariel Weiss <aaronweiss@roblox.com>
Co-authored-by: Hunter Goldstein <hgoldstein@roblox.com>
Co-authored-by: James McNellis <jmcnellis@roblox.com>
Co-authored-by: Sora Kanosue <skanosue@roblox.com>
Co-authored-by: Talha Pathan <tpathan@roblox.com>
Co-authored-by: Varun Saini <vsaini@roblox.com>
Co-authored-by: Vyacheslav Egorov <vegorov@roblox.com>

Author: 8 people

Analysis/include/Luau/BuiltinDefinitions.h

@@ -9,7 +9,7 @@
 namespace Luau
 {
 
-static constexpr char kRequireTagName[] = "require";
+inline constexpr char kRequireTagName[] = "require";
 
 struct Frontend;
 struct GlobalTypes;

Analysis/include/Luau/Constraint.h

@@ -276,6 +276,12 @@ struct ReducePackConstraint
     TypePackId tp;
 };
 
+// simplify ty
+struct SimplifyConstraint
+{
+    TypeId ty;
+};
+
 using ConstraintV = Variant<
     SubtypeConstraint,
     PackSubtypeConstraint,
@@ -294,7 +300,8 @@ using ConstraintV = Variant<
     ReduceConstraint,
     ReducePackConstraint,
     EqualityConstraint,
-    TableCheckConstraint>;
+    TableCheckConstraint,
+    SimplifyConstraint>;
 
 struct Constraint
 {

Analysis/include/Luau/ConstraintGenerator.h

@@ -173,6 +173,8 @@ struct ConstraintGenerator
     std::vector<std::vector<TypeId>> DEPRECATED_interiorTypes;
     std::vector<InteriorFreeTypes> interiorFreeTypes;
 
+    std::vector<TypeId> unionsToSimplify;
+
     /**
      * Fabricates a new free type belonging to a given scope.
      * @param scope the scope the free type belongs to.
@@ -447,6 +449,12 @@ struct ConstraintGenerator
 
     // make a union type function of these two types
     TypeId makeUnion(const ScopePtr& scope, Location location, TypeId lhs, TypeId rhs);
+
+    // Make a union type and add it to `unionsToSimplify`, ensuring that
+    // later we will attempt to simplify this union in order to keep types
+    // small.
+    TypeId makeUnion(std::vector<TypeId> options);
+
     // make an intersect type function of these two types
     TypeId makeIntersect(const ScopePtr& scope, Location location, TypeId lhs, TypeId rhs);
     void prepopulateGlobalScopeForFragmentTypecheck(const ScopePtr& globalScope, const ScopePtr& resumeScope, AstStatBlock* program);

Analysis/include/Luau/ConstraintSolver.h

@@ -249,6 +249,8 @@ struct ConstraintSolver
     bool tryDispatch(const ReducePackConstraint& c, NotNull<const Constraint> constraint, bool force);
     bool tryDispatch(const EqualityConstraint& c, NotNull<const Constraint> constraint);
 
+    bool tryDispatch(const SimplifyConstraint& c, NotNull<const Constraint> constraint);
+
     // for a, ... in some_table do
     // also handles __iter metamethod
     bool tryDispatchIterableTable(TypeId iteratorTy, const IterableConstraint& c, NotNull<const Constraint> constraint, bool force);

Analysis/include/Luau/Error.h

@@ -462,6 +462,11 @@ struct ReservedIdentifier
     bool operator==(const ReservedIdentifier& rhs) const;
 };
 
+struct UnexpectedArrayLikeTableItem
+{
+    bool operator==(const UnexpectedArrayLikeTableItem&) const { return true; }
+};
+
 using TypeErrorData = Variant<
     TypeMismatch,
     UnknownSymbol,
@@ -512,7 +517,8 @@ using TypeErrorData = Variant<
     UnexpectedTypePackInSubtyping,
     ExplicitFunctionAnnotationRecommended,
     UserDefinedTypeFunctionError,
-    ReservedIdentifier>;
+    ReservedIdentifier,
+    UnexpectedArrayLikeTableItem>;
 
 struct TypeErrorSummary
 {

Analysis/include/Luau/Metamethods.h

@@ -8,7 +8,7 @@
 namespace Luau
 {
 
-static const std::unordered_map<AstExprBinary::Op, const char*> kBinaryOpMetamethods{
+inline const std::unordered_map<AstExprBinary::Op, const char*> kBinaryOpMetamethods{
     {AstExprBinary::Op::CompareEq, "__eq"},
     {AstExprBinary::Op::CompareNe, "__eq"},
     {AstExprBinary::Op::CompareGe, "__lt"},
@@ -25,7 +25,7 @@ static const std::unordered_map<AstExprBinary::Op, const char*> kBinaryOpMetamet
     {AstExprBinary::Op::Concat, "__concat"},
 };
 
-static const std::unordered_map<AstExprUnary::Op, const char*> kUnaryOpMetamethods{
+inline const std::unordered_map<AstExprUnary::Op, const char*> kUnaryOpMetamethods{
     {AstExprUnary::Op::Minus, "__unm"},
     {AstExprUnary::Op::Len, "__len"},
 };

Analysis/include/Luau/Subtyping.h

@@ -60,7 +60,7 @@ struct SubtypingReasoningHash
 };
 
 using SubtypingReasonings = DenseHashSet<SubtypingReasoning, SubtypingReasoningHash>;
-static const SubtypingReasoning kEmptyReasoning = SubtypingReasoning{TypePath::kEmpty, TypePath::kEmpty, SubtypingVariance::Invalid};
+inline const SubtypingReasoning kEmptyReasoning = SubtypingReasoning{TypePath::kEmpty, TypePath::kEmpty, SubtypingVariance::Invalid};
 
 struct SubtypingResult
 {

Analysis/include/Luau/Type.h

@@ -1206,7 +1206,7 @@ std::vector<TypeId> filterMap(TypeId type, TypeIdPredicate predicate);
 
 // A tag to mark a type which doesn't derive directly from the root type as overriding the return of `typeof`.
 // Any classes which derive from this type will have typeof return this type.
-static constexpr char kTypeofRootTag[] = "typeofRoot";
+inline constexpr char kTypeofRootTag[] = "typeofRoot";
 
 void attachTag(TypeId ty, const std::string& tagName);
 void attachTag(Property& prop, const std::string& tagName);

Analysis/include/Luau/TypeChecker2.h

@@ -193,6 +193,9 @@ struct TypeChecker2
 
     void explainError(TypeId subTy, TypeId superTy, Location location, const SubtypingResult& result);
     void explainError(TypePackId subTy, TypePackId superTy, Location location, const SubtypingResult& result);
+
+    bool testPotentialLiteralIsSubtype(AstExpr* expr, TypeId expectedTy);
+
     bool testIsSubtype(TypeId subTy, TypeId superTy, Location location);
     bool testIsSubtype(TypePackId subTy, TypePackId superTy, Location location);
     void reportError(TypeError e);

Analysis/include/Luau/TypeFunctionRuntime.h

@@ -216,9 +216,6 @@ struct TypeFunctionExternType
 
     std::optional<TypeFunctionTypeId> metatable; // metaclass?
 
-    // this was mistaken, and we should actually be keeping separate read/write types here.
-    std::optional<TypeFunctionTypeId> parent_DEPRECATED;
-
     std::optional<TypeFunctionTypeId> readParent;
     std::optional<TypeFunctionTypeId> writeParent;
 

Analysis/include/Luau/TypePath.h

@@ -183,7 +183,7 @@ struct PathHash
 };
 
 /// The canonical "empty" Path, meaning a Path with no components.
-static const Path kEmpty{};
+inline const Path kEmpty{};
 
 struct PathBuilder
 {

Analysis/include/Luau/TypeUtils.h

@@ -291,4 +291,14 @@ void trackInteriorFreeType(Scope* scope, TypeId ty);
 
 void trackInteriorFreeTypePack(Scope* scope, TypePackId tp);
 
+// A fast approximation of subTy <: superTy
+bool fastIsSubtype(TypeId subTy, TypeId superTy);
+
+/**
+ * @param tables A list of potential table parts of a union
+ * @param exprType Type of the expression to match
+ * @return An element of `tables` that best matches `exprType`.
+ */
+std::optional<TypeId> extractMatchingTableType(std::vector<TypeId>& tables, TypeId exprType, NotNull<BuiltinTypes> builtinTypes);
+
 } // namespace Luau

Analysis/src/AutocompleteCore.cpp

@@ -25,7 +25,6 @@ LUAU_FASTINT(LuauTypeInferIterationLimit)
 LUAU_FASTINT(LuauTypeInferRecursionLimit)
 LUAU_FASTFLAGVARIABLE(DebugLuauMagicVariableNames)
 LUAU_FASTFLAGVARIABLE(LuauAutocompleteUsesModuleForTypeCompatibility)
-LUAU_FASTFLAGVARIABLE(LuauAutocompleteUnionCopyPreviousSeen)
 LUAU_FASTFLAGVARIABLE(LuauAutocompleteMissingFollows)
 LUAU_FASTFLAG(LuauStoreReturnTypesAsPackOnAst)
 
@@ -490,13 +489,10 @@ static void autocompleteProps(
             //  t1 where t1 = t1 | ExternType
             //
             // Then we are on a one way journey to a stack overflow.
-            if (FFlag::LuauAutocompleteUnionCopyPreviousSeen)
+            for (auto ty : seen)
             {
-                for (auto ty : seen)
-                {
-                    if (is<UnionType, IntersectionType>(ty))
-                        innerSeen.insert(ty);
-                }
+                if (is<UnionType, IntersectionType>(ty))
+                    innerSeen.insert(ty);
             }
 
             if (isNil(*iter))

Analysis/src/BuiltinDefinitions.cpp

@@ -30,9 +30,8 @@
  */
 
 LUAU_FASTFLAG(LuauSolverV2)
-LUAU_FASTFLAG(LuauNonReentrantGeneralization2)
+LUAU_FASTFLAG(LuauNonReentrantGeneralization3)
 LUAU_FASTFLAGVARIABLE(LuauTableCloneClonesType3)
-LUAU_FASTFLAGVARIABLE(LuauUserTypeFunTypecheck)
 LUAU_FASTFLAGVARIABLE(LuauMagicFreezeCheckBlocked2)
 LUAU_FASTFLAGVARIABLE(LuauFormatUseLastPosition)
 
@@ -292,8 +291,6 @@ void assignPropDocumentationSymbols(TableType::Props& props, const std::string&
 
 static void finalizeGlobalBindings(ScopePtr scope)
 {
-    LUAU_ASSERT(FFlag::LuauUserTypeFunTypecheck);
-
     for (const auto& pair : scope->bindings)
     {
         persist(pair.second.typeId);
@@ -313,8 +310,8 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
 
     TypeArena& arena = globals.globalTypes;
     NotNull<BuiltinTypes> builtinTypes = globals.builtinTypes;
-    Scope* globalScope = nullptr; // NotNull<Scope> when removing FFlag::LuauNonReentrantGeneralization2
-    if (FFlag::LuauNonReentrantGeneralization2)
+    Scope* globalScope = nullptr; // NotNull<Scope> when removing FFlag::LuauNonReentrantGeneralization3
+    if (FFlag::LuauNonReentrantGeneralization3)
         globalScope = globals.globalScope.get();
 
     if (FFlag::LuauSolverV2)
@@ -420,23 +417,7 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
         // clang-format on
     }
 
-    if (FFlag::LuauUserTypeFunTypecheck)
-    {
-        finalizeGlobalBindings(globals.globalScope);
-    }
-    else
-    {
-        for (const auto& pair : globals.globalScope->bindings)
-        {
-            persist(pair.second.typeId);
-
-            if (TableType* ttv = getMutable<TableType>(pair.second.typeId))
-            {
-                if (!ttv->name)
-                    ttv->name = "typeof(" + toString(pair.first) + ")";
-            }
-        }
-    }
+    finalizeGlobalBindings(globals.globalScope);
 
     attachMagicFunction(getGlobalBinding(globals, "assert"), std::make_shared<MagicAssert>());
 
@@ -500,58 +481,55 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
     attachTag(requireTy, kRequireTagName);
     attachMagicFunction(requireTy, std::make_shared<MagicRequire>());
 
-    if (FFlag::LuauUserTypeFunTypecheck)
-    {
-        // Global scope cannot be the parent of the type checking environment because it can be changed by the embedder
-        globals.globalTypeFunctionScope->exportedTypeBindings = globals.globalScope->exportedTypeBindings;
-        globals.globalTypeFunctionScope->builtinTypeNames = globals.globalScope->builtinTypeNames;
-
-        // Type function runtime also removes a few standard libraries and globals, so we will take only the ones that are defined
-        static const char* typeFunctionRuntimeBindings[] = {
-            // Libraries
-            "math",
-            "table",
-            "string",
-            "bit32",
-            "utf8",
-            "buffer",
-
-            // Globals
-            "assert",
-            "error",
-            "print",
-            "next",
-            "ipairs",
-            "pairs",
-            "select",
-            "unpack",
-            "getmetatable",
-            "setmetatable",
-            "rawget",
-            "rawset",
-            "rawlen",
-            "rawequal",
-            "tonumber",
-            "tostring",
-            "type",
-            "typeof",
-        };
+    // Global scope cannot be the parent of the type checking environment because it can be changed by the embedder
+    globals.globalTypeFunctionScope->exportedTypeBindings = globals.globalScope->exportedTypeBindings;
+    globals.globalTypeFunctionScope->builtinTypeNames = globals.globalScope->builtinTypeNames;
+
+    // Type function runtime also removes a few standard libraries and globals, so we will take only the ones that are defined
+    static const char* typeFunctionRuntimeBindings[] = {
+        // Libraries
+        "math",
+        "table",
+        "string",
+        "bit32",
+        "utf8",
+        "buffer",
+
+        // Globals
+        "assert",
+        "error",
+        "print",
+        "next",
+        "ipairs",
+        "pairs",
+        "select",
+        "unpack",
+        "getmetatable",
+        "setmetatable",
+        "rawget",
+        "rawset",
+        "rawlen",
+        "rawequal",
+        "tonumber",
+        "tostring",
+        "type",
+        "typeof",
+    };
 
-        for (auto& name : typeFunctionRuntimeBindings)
-        {
-            AstName astName = globals.globalNames.names->get(name);
-            LUAU_ASSERT(astName.value);
+    for (auto& name : typeFunctionRuntimeBindings)
+    {
+        AstName astName = globals.globalNames.names->get(name);
+        LUAU_ASSERT(astName.value);
 
-            globals.globalTypeFunctionScope->bindings[astName] = globals.globalScope->bindings[astName];
-        }
+        globals.globalTypeFunctionScope->bindings[astName] = globals.globalScope->bindings[astName];
+    }
 
-        LoadDefinitionFileResult typeFunctionLoadResult = frontend.loadDefinitionFile(
-            globals, globals.globalTypeFunctionScope, getTypeFunctionDefinitionSource(), "@luau", /* captureComments */ false, false
-        );
-        LUAU_ASSERT(typeFunctionLoadResult.success);
+    LoadDefinitionFileResult typeFunctionLoadResult = frontend.loadDefinitionFile(
+        globals, globals.globalTypeFunctionScope, getTypeFunctionDefinitionSource(), "@luau", /* captureComments */ false, false
+    );
+    LUAU_ASSERT(typeFunctionLoadResult.success);
 
-        finalizeGlobalBindings(globals.globalTypeFunctionScope);
-    }
+    finalizeGlobalBindings(globals.globalTypeFunctionScope);
 }
 
 static std::vector<TypeId> parseFormatString(NotNull<BuiltinTypes> builtinTypes, const char* data, size_t size)

Analysis/src/Constraint.cpp

@@ -143,10 +143,6 @@ DenseHashSet<TypeId> Constraint::getMaybeMutatedFreeTypes() const
             rci.traverse(ty);
         // `UnpackConstraint` should not mutate `sourcePack`.
     }
-    else if (auto rpc = get<ReduceConstraint>(*this); FFlag::DebugLuauGreedyGeneralization && rpc)
-    {
-        rci.traverse(rpc->ty);
-    }
     else if (auto rpc = get<ReducePackConstraint>(*this))
     {
         rci.traverse(rpc->tp);