Sync to upstream/release/703 (#2146)

This will be Luau's last release for the year! Happy holidays and we'll
see y'all in 2026.

# Analysis
* Fix a bug in type checking functions where oversaturation (passing too
many arguments to a function) was sometimes missed, for example:
```luau
type T = { method: (T, number) -> number }

local function onT(a: T)
    a:method(5, 7) -- This would not error prior
end
```
* Type mismatch error wording has been improved: instead of talking
about "X could not be converted into Y," we talk about "expecting X" but
"getting Y."
* Builtin type functions now use improved logic for overload resolution.
* Type annotations on for-in loops are now respected, for example:
```luau
function my_iter(): any
    return {}
end

for index: number, value: string in my_iter() do
    -- This now errors, whereas prior we'd infer `index` to be of type `any`
    local ohno: boolean = index
end
```
* Function statements for table members now have their types checked,
for example the following used to not error:
```luau
local Library: { isnan: (number) -> number } = {} :: any

function Library.isnan(s: string): boolean
    return s == "NaN"
end
```
* Nil-able lambdas can now participate in bidirectional inference, for
example:
```luau
local listdir: (string, ((string) -> boolean)?) -> { string } = nil :: any
listdir("my_directory", function (path)
    -- `path` will now have type `string` here
end)
```
* Internal compiler errors when operating on exceptionally large types
should be less common, thanks to some non-recursive implementations of
common visitors.
* Fix a crash that could occur when deserializing user defined type
functions, one such example being:
```luau
type function identity(t: type)
    return t
end
type func<parameters...> = typeof(function(...: parameters...) end)
local whomp: <T>(arg1: T) -> identity<T>
whomp(function(...) end :: func<any>)
```
* Fix instantiation picking unhelpful (and sometimes plain incorrect)
bounds. Fixes #2125. Fixes
#2118.
```luau
local foo: <P>(constructor: (P) -> any) -> (P) -> any = (nil :: any)
-- Prior `fn` would be of type `(never) -> any`, and will now be the more useful
-- ({ test: true }) -> any
local fn = foo(function (value: { test: true })
    return value.test
end)
```
* Fix a class of constraint solving incomplete errors that could occur
when referencing globals inside lambdas.
* `types.unionof` and `types.intersectionof` will now attempt to
simplify their arguments, avoiding producing nested intersections and
unions, as well as removing identity types like `never` and `unknown`.
* The `setmetatable` type function now waits for its arguments before
resolving, fixing a class of constraint ordering bugs. Fixes
#2106:
```luau
local MyClass = {}
local MyClassMetatable = table.freeze({  __index = MyClass })

type MyClass = setmetatable<{ name: string }, typeof(MyClassMetatable)>

function MyClass.new(name: string): MyClass
    return setmetatable({ name = name }, MyClassMetatable)
end

function MyClass.hello(self: MyClass): string
    return `Hello, {self.name}!`
end

local instance = MyClass.new("World")
 -- This would sometimes be inferred as `any` due to constraint ordering bugs.
local g = instance:hello()
```

# Native Codegen

We now internally encode true float registers, as opposed to treating
all floats as doubles (as Luau does). This allows us to skip conversions
to and from a double when lowering operations on floats. Additionally,
we've added several optimizations for converting in between different
kinds of numbers (32-bit integers, 32-bit unsigned integers, floats,
doubles, etc.).

Consequently, an important notice for users of `CodeGen::HostIrHooks`:
we are updating the behavior of `LOAD_FLOAT`, `DOT_VEC`, `EXTRACT_VEC`,
`BUFFER_READF32`, `BUFFER_WRITEF32`, and `STORE_VECTOR` to produce or
consume single floating-point number instead of a double. When
`FFlag::LuauCodegenSplitFloat` is enabled, `FLOAT_TO_NUM` and
`NUM_TO_FLOAT` have to be used for explicit conversions.

* Double the amount of registers that are spilt for ints and floats on
x64. This fixes NCG failing to compile snippets that end up generating
many transient numbers. Fixes #1468.
* Fix a bug where NCG might improperly claim a stored value (and its
tag) can be elided after a GC check.
* NCG now optimizes buffer and userdata loads that can be computed from
previous stores (e.g. if you write `42` to the nth byte in a buffer and
then immediately read said byte).
* NCG will now try to remove unused temporary userdata allocations
* Fix a bug where NCG might claim a spilt register has been restored but
not actually do so, causing a garbage read from a register.
* NCG now optimizes upvalue loads and stores.
* NCG now optimizes `and` and `or` without generating basic blocks,
allowing more optimizations to occur.
* Fix a bug where NCG on arm64, restoring spilling registers may require
using an (already occupied) temporary register.
* Runtime type checks internal to a function that are redundant with
type checks added through annotations are now elided.
* NCG had an off-by-one bug where loop step detection was not kicking in
for non-constant end ranges in for-in loops: `i = 1,10` would be
optimized and `i = 1,#t` would not be.

# Require

* Added a `to_alias_override` callback: this allows embedders to provide
an alias that _cannot_ be overridden by users.

Author: hgoldstein

Analysis/include/Luau/BuiltinTypeFunctions.h

@@ -33,7 +33,6 @@ struct BuiltinTypeFunctions
 
     TypeFunction ltFunc;
     TypeFunction leFunc;
-    TypeFunction eqFunc;
 
     TypeFunction refineFunc;
     TypeFunction singletonFunc;

Analysis/include/Luau/ConstraintGenerator.h

@@ -58,6 +58,11 @@ struct InferencePack
     }
 };
 
+struct Checkpoint
+{
+    size_t offset = 0;
+};
+
 struct ConstraintGenerator
 {
     // A list of all the scopes in the module. This vector holds ownership of the
@@ -290,6 +295,13 @@ struct ConstraintGenerator
     );
 
     InferencePack checkPack(const ScopePtr& scope, AstExprCall* call);
+    InferencePack checkExprCall(
+        const ScopePtr& scope,
+        AstExprCall* call,
+        TypeId fnType,
+        Checkpoint funcBeginCheckpoint,
+        Checkpoint funcEndCheckpoint
+    );
 
     /**
      * Checks an expression that is expected to evaluate to one type.

Analysis/include/Luau/FileResolver.h

@@ -36,6 +36,11 @@ struct ModuleInfo
 
 struct RequireAlias
 {
+    explicit RequireAlias(std::string alias)
+        : alias(std::move(alias))
+    {
+    }
+
     std::string alias; // Unprefixed alias name (no leading `@`).
     std::vector<std::string> tags = {};
 };

Analysis/include/Luau/IterativeTypeVisitor.h

@@ -0,0 +1,116 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#pragma once
+
+#include "Luau/Type.h"
+#include "Luau/TypePack.h"
+#include "Luau/Set.h"
+
+#include <string>
+
+namespace Luau
+{
+
+struct IterativeTypeVisitor
+{
+    using SeenSet = Set<const void*>;
+
+    // We avoid Luau::Variant here because we can move the tag bit and make this struct 64 bits shorter.
+    struct WorkItem
+    {
+        WorkItem(TypeId ty, int32_t parent);
+        WorkItem(TypePackId tp, int32_t parent);
+
+        const TypeId* asType() const;
+        const TypePackId* asTypePack() const;
+
+        bool operator==(TypeId ty) const;
+        bool operator==(TypePackId tp) const;
+
+    private:
+        // TypeId if isType, else TypePackId
+        const void* t;
+        bool isType;
+
+    public:
+        // -1 indicates no parent
+        int32_t parent;
+    };
+
+    explicit IterativeTypeVisitor(std::string visitorName, bool skipBoundTypes);
+    explicit IterativeTypeVisitor(std::string visitorName, bool visitOnce, bool skipBoundTypes);
+    explicit IterativeTypeVisitor(std::string visitorName, SeenSet seen, bool visitOnce, bool skipBoundTypes);
+
+    IterativeTypeVisitor(const IterativeTypeVisitor&) = delete;
+    IterativeTypeVisitor& operator=(const IterativeTypeVisitor&) = delete;
+
+    virtual ~IterativeTypeVisitor() = default;
+
+    virtual void cycle(TypeId);
+    virtual void cycle(TypePackId);
+
+    virtual bool visit(TypeId ty);
+    virtual bool visit(TypeId ty, const BoundType& btv);
+    virtual bool visit(TypeId ty, const FreeType& ftv);
+    virtual bool visit(TypeId ty, const GenericType& gtv);
+    virtual bool visit(TypeId ty, const ErrorType& etv);
+    virtual bool visit(TypeId ty, const PrimitiveType& ptv);
+    virtual bool visit(TypeId ty, const FunctionType& ftv);
+    virtual bool visit(TypeId ty, const TableType& ttv);
+    virtual bool visit(TypeId ty, const MetatableType& mtv);
+    virtual bool visit(TypeId ty, const ExternType& etv);
+    virtual bool visit(TypeId ty, const AnyType& atv);
+    virtual bool visit(TypeId ty, const NoRefineType& nrt);
+    virtual bool visit(TypeId ty, const UnknownType& utv);
+    virtual bool visit(TypeId ty, const NeverType& ntv);
+    virtual bool visit(TypeId ty, const UnionType& utv);
+    virtual bool visit(TypeId ty, const IntersectionType& itv);
+    virtual bool visit(TypeId ty, const BlockedType& btv);
+    virtual bool visit(TypeId ty, const PendingExpansionType& petv);
+    virtual bool visit(TypeId ty, const SingletonType& stv);
+    virtual bool visit(TypeId ty, const NegationType& ntv);
+    virtual bool visit(TypeId ty, const TypeFunctionInstanceType& tfit);
+
+    virtual bool visit(TypePackId tp);
+    virtual bool visit(TypePackId tp, const BoundTypePack& btp);
+    virtual bool visit(TypePackId tp, const FreeTypePack& ftp);
+    virtual bool visit(TypePackId tp, const GenericTypePack& gtp);
+    virtual bool visit(TypePackId tp, const ErrorTypePack& etp);
+    virtual bool visit(TypePackId tp, const TypePack& pack);
+    virtual bool visit(TypePackId tp, const VariadicTypePack& vtp);
+    virtual bool visit(TypePackId tp, const BlockedTypePack& btp);
+    virtual bool visit(TypePackId tp, const TypeFunctionInstanceTypePack& tfitp);
+
+    void run(TypeId ty);
+    void run(TypePackId tp);
+
+protected:
+    /// Add this type (or pack) to the queue of things to traverse. Does not
+    /// immediately process the thing!  You cannot use this to effect in-order
+    /// traversal.
+    void traverse(TypeId ty);
+    void traverse(TypePackId tp);
+
+private:
+    void process(TypeId ty);
+    void process(TypePackId tp);
+
+    bool hasSeen(const void* tv);
+    void unsee(const void* tv);
+
+    template<typename TID>
+    bool isCyclic(TID ty) const;
+
+    void processWorkQueue();
+
+    SeenSet seen{nullptr};
+
+    std::vector<WorkItem> workQueue;
+    int32_t parentCursor = -1;
+    uint32_t workCursor = 0;
+
+    const std::string visitorName;
+    bool skipBoundTypes = false;
+    bool visitOnce = true;
+};
+
+} // namespace Luau

Analysis/include/Luau/Normalize.h

@@ -355,10 +355,9 @@ class Normalizer
 
     std::optional<TypePackId> intersectionOfTypePacks(TypePackId here, TypePackId there);
 
-    // Move to private with LuauNormalizerStepwiseFuel
+private:
     std::optional<TypePackId> intersectionOfTypePacks_INTERNAL(TypePackId here, TypePackId there);
 
-private:
     // ------- Cached TypeIds
     TypeId unionType(TypeId here, TypeId there);
     TypeId intersectionType(TypeId here, TypeId there);

Analysis/include/Luau/OverloadResolution.h

@@ -42,7 +42,7 @@ using IncompatibilityReason = Variant<SubtypingReasonings, ErrorVec>;
  */
 struct SelectedOverload
 {
-    /**
+   /**
      * An unambiguous overload, if one can be selected. This is _not_ necessarily
      * an overload that is valid for the argument pack provided. For example:
      *
@@ -302,7 +302,8 @@ struct SolveResult
 // Helper utility, presently used for binary operator type functions.
 //
 // Given a function and a set of arguments, select a suitable overload.
-SolveResult solveFunctionCall(
+// Clip with FFlag::LuauBuiltinTypeFunctionsUseNewOverloadResolution
+SolveResult solveFunctionCall_DEPRECATED(
     NotNull<TypeArena> arena,
     NotNull<BuiltinTypes> builtinTypes,
     NotNull<Normalizer> normalizer,

Analysis/include/Luau/Set.h

@@ -26,7 +26,7 @@ class Set
     class const_iterator;
     using iterator = const_iterator;
 
-    Set(const T& empty_key)
+    explicit Set(const T& empty_key)
         : mapping{empty_key}
     {
     }

Analysis/include/Luau/Subtyping.h

@@ -298,7 +298,6 @@ struct Subtyping
         const SingletonType* superSingleton,
         NotNull<Scope> scope
     );
-    SubtypingResult isCovariantWith(SubtypingEnvironment& env, const TableType* subTable, const TableType* superTable, NotNull<Scope> scope);
     SubtypingResult isCovariantWith(
         SubtypingEnvironment& env,
         const TableType* subTable,

Analysis/include/Luau/TypeChecker2.h

@@ -9,9 +9,10 @@
 #include "Luau/Subtyping.h"
 #include "Luau/Type.h"
 #include "Luau/TypeFwd.h"
-#include "Luau/TypeOrPack.h"
 #include "Luau/TypeUtils.h"
 
+LUAU_FASTFLAG(LuauBetterTypeMismatchErrors)
+
 namespace Luau
 {
 
@@ -44,7 +45,7 @@ struct Reasonings
         // sort the reasons here to achieve a stable error
         // stringification.
         std::sort(reasons.begin(), reasons.end());
-        std::string allReasons = "\nthis is because ";
+        std::string allReasons = (FFlag::LuauBetterTypeMismatchErrors && reasons.size() < 2) ? "\n" : "\nthis is because ";
         for (const std::string& reason : reasons)
         {
             if (reasons.size() > 1)

Analysis/src/AstJsonEncoder.cpp

@@ -8,8 +8,6 @@
 
 #include <math.h>
 
-LUAU_FASTFLAG(LuauAutocompleteAttributes)
-
 namespace Luau
 {
 
@@ -1167,10 +1165,7 @@ struct AstJsonEncoder : public AstVisitor
             "AstAttr",
             [&]()
             {
-                if (FFlag::LuauAutocompleteAttributes)
-                    write("name", node->name);
-                else
-                    write("name", node->type);
+                write("name", node->name);
             }
         );
     }