Sync to upstream/release/503 (#135)

- A series of major optimizations to type checking performance on complex
programs/types (up to two orders of magnitude speedup for programs
involving huge tagged unions)
- Fix a few issues encountered by UBSAN (and maybe fix s390x builds)
- Fix gcc-11 test builds
- Fix a rare corner case where luau_load wouldn't wake inactive threads
which could result in a use-after-free due to GC
- Fix CLI crash when error object that's not a string escapes to top level
- Fix Makefile suffixes on macOS

Co-authored-by: Rodactor <rodactor@roblox.com>

Analysis/include/Luau/BuiltinDefinitions.h

@@ -34,7 +34,6 @@ TypeId makeFunction( // Polymorphic
     std::initializer_list<TypeId> paramTypes, std::initializer_list<std::string> paramNames, std::initializer_list<TypeId> retTypes);
 
 void attachMagicFunction(TypeId ty, MagicFunction fn);
-void attachFunctionTag(TypeId ty, std::string constraint);
 
 Property makeProperty(TypeId ty, std::optional<std::string> documentationSymbol = std::nullopt);
 void assignPropDocumentationSymbols(TableTypeVar::Props& props, const std::string& baseName);

Analysis/include/Luau/Quantify.h

@@ -0,0 +1,14 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#pragma once
+
+#include "Luau/TypeVar.h"
+
+namespace Luau
+{
+
+struct Module;
+using ModulePtr = std::shared_ptr<Module>;
+
+void quantify(ModulePtr module, TypeId ty, TypeLevel level);
+
+} // namespace Luau

Analysis/include/Luau/ToString.h

@@ -69,4 +69,6 @@ std::string toString(const TypePackVar& tp, const ToStringOptions& opts = {});
 void dump(TypeId ty);
 void dump(TypePackId ty);
 
+std::string generateName(size_t n);
+
 } // namespace Luau

Analysis/include/Luau/TopoSortStatements.h

@@ -12,6 +12,7 @@ struct AstArray;
 class AstStat;
 
 bool containsFunctionCall(const AstStat& stat);
+bool containsFunctionCallOrReturn(const AstStat& stat);
 bool isFunction(const AstStat& stat);
 void toposort(std::vector<AstStat*>& stats);
 

Analysis/include/Luau/TxnLog.h

@@ -3,17 +3,35 @@
 
 #include "Luau/TypeVar.h"
 
+LUAU_FASTFLAG(LuauShareTxnSeen);
+
 namespace Luau
 {
 
 // Log of where what TypeIds we are rebinding and what they used to be
 struct TxnLog
 {
-    TxnLog() = default;
+    TxnLog()
+        : originalSeenSize(0)
+        , ownedSeen()
+        , sharedSeen(&ownedSeen)
+    {
+    }
+
+    explicit TxnLog(std::vector<std::pair<TypeId, TypeId>>* sharedSeen)
+        : originalSeenSize(sharedSeen->size())
+        , ownedSeen()
+        , sharedSeen(sharedSeen)
+    {
+    }
 
-    explicit TxnLog(const std::vector<std::pair<TypeId, TypeId>>& seen)
-        : seen(seen)
+    explicit TxnLog(const std::vector<std::pair<TypeId, TypeId>>& ownedSeen)
+        : originalSeenSize(ownedSeen.size())
+        , ownedSeen(ownedSeen)
+        , sharedSeen(nullptr)
     {
+        // This is deprecated!
+        LUAU_ASSERT(!FFlag::LuauShareTxnSeen);
     }
 
     TxnLog(const TxnLog&) = delete;
@@ -38,9 +56,11 @@ struct TxnLog
     std::vector<std::pair<TypeId, TypeVar>> typeVarChanges;
     std::vector<std::pair<TypePackId, TypePackVar>> typePackChanges;
     std::vector<std::pair<TableTypeVar*, std::optional<TypeId>>> tableChanges;
+    size_t originalSeenSize;
 
 public:
-    std::vector<std::pair<TypeId, TypeId>> seen; // used to avoid infinite recursion when types are cyclic
+    std::vector<std::pair<TypeId, TypeId>> ownedSeen;   // used to avoid infinite recursion when types are cyclic
+    std::vector<std::pair<TypeId, TypeId>>* sharedSeen; // shared with all the descendent logs
 };
 
 } // namespace Luau

Analysis/include/Luau/TypeInfer.h

@@ -11,6 +11,7 @@
 #include "Luau/TypePack.h"
 #include "Luau/TypeVar.h"
 #include "Luau/Unifier.h"
+#include "Luau/UnifierSharedState.h"
 
 #include <memory>
 #include <unordered_map>
@@ -121,7 +122,7 @@ struct TypeChecker
     void check(const ScopePtr& scope, const AstStatForIn& forin);
     void check(const ScopePtr& scope, TypeId ty, const ScopePtr& funScope, const AstStatFunction& function);
     void check(const ScopePtr& scope, TypeId ty, const ScopePtr& funScope, const AstStatLocalFunction& function);
-    void check(const ScopePtr& scope, const AstStatTypeAlias& typealias, bool forwardDeclare = false);
+    void check(const ScopePtr& scope, const AstStatTypeAlias& typealias, int subLevel = 0, bool forwardDeclare = false);
     void check(const ScopePtr& scope, const AstStatDeclareClass& declaredClass);
     void check(const ScopePtr& scope, const AstStatDeclareFunction& declaredFunction);
 
@@ -336,7 +337,7 @@ struct TypeChecker
 
     // Note: `scope` must be a fresh scope.
     std::pair<std::vector<TypeId>, std::vector<TypePackId>> createGenericTypes(
-        const ScopePtr& scope, const AstNode& node, const AstArray<AstName>& genericNames, const AstArray<AstName>& genericPackNames);
+        const ScopePtr& scope, std::optional<TypeLevel> levelOpt, const AstNode& node, const AstArray<AstName>& genericNames, const AstArray<AstName>& genericPackNames);
 
 public:
     ErrorVec resolve(const PredicateVec& predicates, const ScopePtr& scope, bool sense);
@@ -383,6 +384,8 @@ struct TypeChecker
     std::function<void(const ModuleName&, const ScopePtr&)> prepareModuleScope;
     InternalErrorReporter* iceHandler;
 
+    UnifierSharedState unifierState;
+
 public:
     const TypeId nilType;
     const TypeId numberType;

Analysis/include/Luau/TypeVar.h

@@ -540,4 +540,11 @@ UnionTypeVarIterator end(const UnionTypeVar* utv);
 using TypeIdPredicate = std::function<std::optional<TypeId>(TypeId)>;
 std::vector<TypeId> filterMap(TypeId type, TypeIdPredicate predicate);
 
+void attachTag(TypeId ty, const std::string& tagName);
+void attachTag(Property& prop, const std::string& tagName);
+
+bool hasTag(TypeId ty, const std::string& tagName);
+bool hasTag(const Property& prop, const std::string& tagName);
+bool hasTag(const Tags& tags, const std::string& tagName); // Do not use in new work.
+
 } // namespace Luau

Analysis/include/Luau/Unifier.h

@@ -6,6 +6,7 @@
 #include "Luau/TxnLog.h"
 #include "Luau/TypeInfer.h"
 #include "Luau/Module.h" // FIXME: For TypeArena.  It merits breaking out into its own header.
+#include "Luau/UnifierSharedState.h"
 
 #include <unordered_set>
 
@@ -41,11 +42,14 @@ struct Unifier
 
     std::shared_ptr<UnifierCounters> counters_DEPRECATED;
 
-    InternalErrorReporter* iceHandler;
+    UnifierSharedState& sharedState;
 
-    Unifier(TypeArena* types, Mode mode, ScopePtr globalScope, const Location& location, Variance variance, InternalErrorReporter* iceHandler);
-    Unifier(TypeArena* types, Mode mode, ScopePtr globalScope, const std::vector<std::pair<TypeId, TypeId>>& seen, const Location& location,
-        Variance variance, InternalErrorReporter* iceHandler, const std::shared_ptr<UnifierCounters>& counters_DEPRECATED = nullptr,
+    Unifier(TypeArena* types, Mode mode, ScopePtr globalScope, const Location& location, Variance variance, UnifierSharedState& sharedState);
+    Unifier(TypeArena* types, Mode mode, ScopePtr globalScope, const std::vector<std::pair<TypeId, TypeId>>& ownedSeen, const Location& location,
+        Variance variance, UnifierSharedState& sharedState, const std::shared_ptr<UnifierCounters>& counters_DEPRECATED = nullptr,
+        UnifierCounters* counters = nullptr);
+    Unifier(TypeArena* types, Mode mode, ScopePtr globalScope, std::vector<std::pair<TypeId, TypeId>>* sharedSeen, const Location& location,
+        Variance variance, UnifierSharedState& sharedState, const std::shared_ptr<UnifierCounters>& counters_DEPRECATED = nullptr,
         UnifierCounters* counters = nullptr);
 
     // Test whether the two type vars unify.  Never commits the result.
@@ -69,7 +73,8 @@ struct Unifier
     void tryUnifyWithMetatable(TypeId metatable, TypeId other, bool reversed);
     void tryUnifyWithClass(TypeId superTy, TypeId subTy, bool reversed);
     void tryUnify(const TableIndexer& superIndexer, const TableIndexer& subIndexer);
-    TypeId deeplyOptional(TypeId ty, std::unordered_map<TypeId,TypeId> seen = {});
+    TypeId deeplyOptional(TypeId ty, std::unordered_map<TypeId, TypeId> seen = {});
+    void cacheResult(TypeId superTy, TypeId subTy);
 
 public:
     void tryUnify(TypePackId superTy, TypePackId subTy, bool isFunctionCall = false);
@@ -101,8 +106,9 @@ struct Unifier
     [[noreturn]] void ice(const std::string& message, const Location& location);
     [[noreturn]] void ice(const std::string& message);
 
-    DenseHashSet<TypeId> tempSeenTy{nullptr};
-    DenseHashSet<TypePackId> tempSeenTp{nullptr};
+    // Remove with FFlagLuauCacheUnifyTableResults
+    DenseHashSet<TypeId> tempSeenTy_DEPRECATED{nullptr};
+    DenseHashSet<TypePackId> tempSeenTp_DEPRECATED{nullptr};
 };
 
 } // namespace Luau

Analysis/include/Luau/UnifierSharedState.h

@@ -0,0 +1,44 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#pragma once
+
+#include "Luau/DenseHash.h"
+#include "Luau/TypeVar.h"
+#include "Luau/TypePack.h"
+
+#include <utility>
+
+namespace Luau
+{
+struct InternalErrorReporter;
+
+struct TypeIdPairHash
+{
+    size_t hashOne(Luau::TypeId key) const
+    {
+        return (uintptr_t(key) >> 4) ^ (uintptr_t(key) >> 9);
+    }
+
+    size_t operator()(const std::pair<Luau::TypeId, Luau::TypeId>& x) const
+    {
+        return hashOne(x.first) ^ (hashOne(x.second) << 1);
+    }
+};
+
+struct UnifierSharedState
+{
+    UnifierSharedState(InternalErrorReporter* iceHandler)
+        : iceHandler(iceHandler)
+    {
+    }
+
+    InternalErrorReporter* iceHandler;
+
+    DenseHashSet<void*> seenAny{nullptr};
+    DenseHashMap<TypeId, bool> skipCacheForType{nullptr};
+    DenseHashSet<std::pair<TypeId, TypeId>, TypeIdPairHash> cachedUnify{{nullptr, nullptr}};
+
+    DenseHashSet<TypeId> tempSeenTy{nullptr};
+    DenseHashSet<TypePackId> tempSeenTp{nullptr};
+};
+
+} // namespace Luau

Analysis/include/Luau/VisitTypeVar.h

@@ -1,9 +1,12 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
+#include "Luau/DenseHash.h"
 #include "Luau/TypeVar.h"
 #include "Luau/TypePack.h"
 
+LUAU_FASTFLAG(LuauCacheUnifyTableResults)
+
 namespace Luau
 {
 
@@ -32,17 +35,33 @@ inline bool hasSeen(std::unordered_set<void*>& seen, const void* tv)
     return !seen.insert(ttv).second;
 }
 
+inline bool hasSeen(DenseHashSet<void*>& seen, const void* tv)
+{
+    void* ttv = const_cast<void*>(tv);
+
+    if (seen.contains(ttv))
+        return true;
+
+    seen.insert(ttv);
+    return false;
+}
+
 inline void unsee(std::unordered_set<void*>& seen, const void* tv)
 {
     void* ttv = const_cast<void*>(tv);
     seen.erase(ttv);
 }
 
-template<typename F>
-void visit(TypePackId tp, F& f, std::unordered_set<void*>& seen);
+inline void unsee(DenseHashSet<void*>& seen, const void* tv)
+{
+    // When DenseHashSet is used for 'visitOnce', where don't forget visited elements
+}
+
+template<typename F, typename Set>
+void visit(TypePackId tp, F& f, Set& seen);
 
-template<typename F>
-void visit(TypeId ty, F& f, std::unordered_set<void*>& seen)
+template<typename F, typename Set>
+void visit(TypeId ty, F& f, Set& seen)
 {
     if (visit_detail::hasSeen(seen, ty))
     {
@@ -79,15 +98,23 @@ void visit(TypeId ty, F& f, std::unordered_set<void*>& seen)
 
     else if (auto ttv = get<TableTypeVar>(ty))
     {
+        // Some visitors want to see bound tables, that's why we visit the original type
         if (apply(ty, *ttv, seen, f))
         {
-            for (auto& [_name, prop] : ttv->props)
-                visit(prop.type, f, seen);
-
-            if (ttv->indexer)
+            if (FFlag::LuauCacheUnifyTableResults && ttv->boundTo)
             {
-                visit(ttv->indexer->indexType, f, seen);
-                visit(ttv->indexer->indexResultType, f, seen);
+                visit(*ttv->boundTo, f, seen);
+            }
+            else
+            {
+                for (auto& [_name, prop] : ttv->props)
+                    visit(prop.type, f, seen);
+
+                if (ttv->indexer)
+                {
+                    visit(ttv->indexer->indexType, f, seen);
+                    visit(ttv->indexer->indexResultType, f, seen);
+                }
             }
         }
     }
@@ -140,8 +167,8 @@ void visit(TypeId ty, F& f, std::unordered_set<void*>& seen)
     visit_detail::unsee(seen, ty);
 }
 
-template<typename F>
-void visit(TypePackId tp, F& f, std::unordered_set<void*>& seen)
+template<typename F, typename Set>
+void visit(TypePackId tp, F& f, Set& seen)
 {
     if (visit_detail::hasSeen(seen, tp))
     {
@@ -182,6 +209,7 @@ void visit(TypePackId tp, F& f, std::unordered_set<void*>& seen)
 
     visit_detail::unsee(seen, tp);
 }
+
 } // namespace visit_detail
 
 template<typename TID, typename F>
@@ -197,4 +225,11 @@ void visitTypeVar(TID ty, F& f)
     visit_detail::visit(ty, f, seen);
 }
 
+template<typename TID, typename F>
+void visitTypeVarOnce(TID ty, F& f, DenseHashSet<void*>& seen)
+{
+    seen.clear();
+    visit_detail::visit(ty, f, seen);
+}
+
 } // namespace Luau

Analysis/src/Autocomplete.cpp

@@ -196,7 +196,8 @@ static TypeCorrectKind checkTypeCorrectKind(const Module& module, TypeArena* typ
 
     auto canUnify = [&typeArena, &module](TypeId expectedType, TypeId actualType) {
         InternalErrorReporter iceReporter;
-        Unifier unifier(typeArena, Mode::Strict, module.getModuleScope(), Location(), Variance::Covariant, &iceReporter);
+        UnifierSharedState unifierState(&iceReporter);
+        Unifier unifier(typeArena, Mode::Strict, module.getModuleScope(), Location(), Variance::Covariant, unifierState);
 
         unifier.tryUnify(expectedType, actualType);
 

Analysis/src/BuiltinDefinitions.cpp

@@ -106,18 +106,6 @@ void attachMagicFunction(TypeId ty, MagicFunction fn)
         LUAU_ASSERT(!"Got a non functional type");
 }
 
-void attachFunctionTag(TypeId ty, std::string tag)
-{
-    if (auto ftv = getMutable<FunctionTypeVar>(ty))
-    {
-        ftv->tags.emplace_back(std::move(tag));
-    }
-    else
-    {
-        LUAU_ASSERT(!"Got a non functional type");
-    }
-}
-
 Property makeProperty(TypeId ty, std::optional<std::string> documentationSymbol)
 {
     return {