luau-lang · hgoldstein · Dec 12, 2025 · Jan 10, 2025 · Jan 10, 2025 · Jan 10, 2025
diff --git a/Analysis/include/Luau/BuiltinTypeFunctions.h b/Analysis/include/Luau/BuiltinTypeFunctions.h
@@ -33,7 +33,6 @@ struct BuiltinTypeFunctions
 
     TypeFunction ltFunc;
     TypeFunction leFunc;
-    TypeFunction eqFunc;
 
     TypeFunction refineFunc;
     TypeFunction singletonFunc;

diff --git a/Analysis/include/Luau/ConstraintGenerator.h b/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.

diff --git a/Analysis/include/Luau/FileResolver.h b/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 = {};
 };

diff --git a/Analysis/include/Luau/IterativeTypeVisitor.h b/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
diff --git a/Analysis/include/Luau/Normalize.h b/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);

diff --git a/Analysis/include/Luau/OverloadResolution.h b/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,

diff --git a/Analysis/include/Luau/Set.h b/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}
     {
     }

diff --git a/Analysis/include/Luau/Subtyping.h b/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,

diff --git a/Analysis/include/Luau/TypeChecker2.h b/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)

diff --git a/Analysis/src/AstJsonEncoder.cpp b/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);
             }
         );
     }

diff --git a/Analysis/src/AutocompleteCore.cpp b/Analysis/src/AutocompleteCore.cpp
@@ -28,7 +28,6 @@ LUAU_FASTINT(LuauTypeInferIterationLimit)
 LUAU_FASTINT(LuauTypeInferRecursionLimit)
 LUAU_FASTFLAGVARIABLE(DebugLuauMagicVariableNames)
 LUAU_FASTFLAGVARIABLE(LuauDoNotSuggestGenericsInAnonFuncs)
-LUAU_FASTFLAG(LuauAutocompleteAttributes)
 LUAU_FASTFLAGVARIABLE(LuauAutocompleteSingletonsInIndexer)
 
 static constexpr std::array<std::string_view, 12> kStatementStartingKeywords =
@@ -2216,17 +2215,14 @@ AutocompleteResult autocomplete_(
     }
     else if (AstExprFunction* func = node->as<AstExprFunction>())
     {
-        if (FFlag::LuauAutocompleteAttributes)
+        for (AstAttr* attr : func->attributes)
         {
-            for (AstAttr* attr : func->attributes)
+            if (attr->location.begin <= position && position <= attr->location.end && attr->type == AstAttr::Type::Unknown)
             {
-                if (attr->location.begin <= position && position <= attr->location.end && attr->type == AstAttr::Type::Unknown)
-                {
-                    AutocompleteEntryMap ret;
-                    for (const auto& attr : kKnownAttributes)
-                        ret[attr.c_str()] = {AutocompleteEntryKind::Keyword};
-                    return {std::move(ret), std::move(ancestry), AutocompleteContext::Keyword};
-                }
+                AutocompleteEntryMap ret;
+                for (const auto& attr : kKnownAttributes)
+                    ret[attr.c_str()] = {AutocompleteEntryKind::Keyword};
+                return {std::move(ret), std::move(ancestry), AutocompleteContext::Keyword};
             }
         }
     }