Sync to upstream/release/562

Analysis/include/Luau/Constraint.h

@@ -71,9 +71,9 @@ struct BinaryConstraint
 
     // When we dispatch this constraint, we update the key at this map to record
     // the overload that we selected.
-    const void* astFragment;
-    DenseHashMap<const void*, TypeId>* astOriginalCallTypes;
-    DenseHashMap<const void*, TypeId>* astOverloadResolvedTypes;
+    const AstNode* astFragment;
+    DenseHashMap<const AstNode*, TypeId>* astOriginalCallTypes;
+    DenseHashMap<const AstNode*, TypeId>* astOverloadResolvedTypes;
 };
 
 // iteratee is iterable

Analysis/include/Luau/ConstraintGraphBuilder.h

@@ -2,7 +2,7 @@
 #pragma once
 
 #include "Luau/Ast.h"
-#include "Luau/Connective.h"
+#include "Luau/Refinement.h"
 #include "Luau/Constraint.h"
 #include "Luau/DataFlowGraph.h"
 #include "Luau/Module.h"
@@ -27,27 +27,27 @@ struct DcrLogger;
 struct Inference
 {
     TypeId ty = nullptr;
-    ConnectiveId connective = nullptr;
+    RefinementId refinement = nullptr;
 
     Inference() = default;
 
-    explicit Inference(TypeId ty, ConnectiveId connective = nullptr)
+    explicit Inference(TypeId ty, RefinementId refinement = nullptr)
         : ty(ty)
-        , connective(connective)
+        , refinement(refinement)
     {
     }
 };
 
 struct InferencePack
 {
     TypePackId tp = nullptr;
-    std::vector<ConnectiveId> connectives;
+    std::vector<RefinementId> refinements;
 
     InferencePack() = default;
 
-    explicit InferencePack(TypePackId tp, const std::vector<ConnectiveId>& connectives = {})
+    explicit InferencePack(TypePackId tp, const std::vector<RefinementId>& refinements = {})
         : tp(tp)
-        , connectives(connectives)
+        , refinements(refinements)
     {
     }
 };
@@ -74,35 +74,11 @@ struct ConstraintGraphBuilder
     // will enqueue them during solving.
     std::vector<ConstraintPtr> unqueuedConstraints;
 
-    // A mapping of AST node to TypeId.
-    DenseHashMap<const AstExpr*, TypeId> astTypes{nullptr};
-
-    // A mapping of AST node to TypePackId.
-    DenseHashMap<const AstExpr*, TypePackId> astTypePacks{nullptr};
-
-    DenseHashMap<const AstExpr*, TypeId> astExpectedTypes{nullptr};
-
-    // If the node was applied as a function, this is the unspecialized type of
-    // that expression.
-    DenseHashMap<const void*, TypeId> astOriginalCallTypes{nullptr};
-
-    // If overload resolution was performed on this element, this is the
-    // overload that was selected.
-    DenseHashMap<const void*, TypeId> astOverloadResolvedTypes{nullptr};
-
-
-
-    // Types resolved from type annotations. Analogous to astTypes.
-    DenseHashMap<const AstType*, TypeId> astResolvedTypes{nullptr};
-
-    // Type packs resolved from type annotations. Analogous to astTypePacks.
-    DenseHashMap<const AstTypePack*, TypePackId> astResolvedTypePacks{nullptr};
-
-    // Defining scopes for AST nodes.
+    // The private scope of type aliases for which the type parameters belong to.
     DenseHashMap<const AstStatTypeAlias*, ScopePtr> astTypeAliasDefiningScopes{nullptr};
 
     NotNull<const DataFlowGraph> dfg;
-    ConnectiveArena connectiveArena;
+    RefinementArena refinementArena;
 
     int recursionCount = 0;
 
@@ -156,7 +132,7 @@ struct ConstraintGraphBuilder
      */
     NotNull<Constraint> addConstraint(const ScopePtr& scope, std::unique_ptr<Constraint> c);
 
-    void applyRefinements(const ScopePtr& scope, Location location, ConnectiveId connective);
+    void applyRefinements(const ScopePtr& scope, Location location, RefinementId refinement);
 
     /**
      * The entry point to the ConstraintGraphBuilder. This will construct a set
@@ -213,7 +189,7 @@ struct ConstraintGraphBuilder
     Inference check(const ScopePtr& scope, AstExprTypeAssertion* typeAssert);
     Inference check(const ScopePtr& scope, AstExprInterpString* interpString);
     Inference check(const ScopePtr& scope, AstExprTable* expr, std::optional<TypeId> expectedType);
-    std::tuple<TypeId, TypeId, ConnectiveId> checkBinary(const ScopePtr& scope, AstExprBinary* binary, std::optional<TypeId> expectedType);
+    std::tuple<TypeId, TypeId, RefinementId> checkBinary(const ScopePtr& scope, AstExprBinary* binary, std::optional<TypeId> expectedType);
 
     TypePackId checkLValues(const ScopePtr& scope, AstArray<AstExpr*> exprs);
 

Analysis/include/Luau/Module.h

@@ -74,14 +74,13 @@ struct Module
     DenseHashMap<const AstExpr*, TypePackId> astTypePacks{nullptr};
     DenseHashMap<const AstExpr*, TypeId> astExpectedTypes{nullptr};
 
-    // Pointers are either AstExpr or AstStat.
-    DenseHashMap<const void*, TypeId> astOriginalCallTypes{nullptr};
-
-    // Pointers are either AstExpr or AstStat.
-    DenseHashMap<const void*, TypeId> astOverloadResolvedTypes{nullptr};
+    DenseHashMap<const AstNode*, TypeId> astOriginalCallTypes{nullptr};
+    DenseHashMap<const AstNode*, TypeId> astOverloadResolvedTypes{nullptr};
 
     DenseHashMap<const AstType*, TypeId> astResolvedTypes{nullptr};
+    DenseHashMap<const AstType*, TypeId> astOriginalResolvedTypes{nullptr};
     DenseHashMap<const AstTypePack*, TypePackId> astResolvedTypePacks{nullptr};
+
     // Map AST nodes to the scope they create.  Cannot be NotNull<Scope> because we need a sentinel value for the map.
     DenseHashMap<const AstNode*, Scope*> astScopes{nullptr};
 

Analysis/include/Luau/Refinement.h

@@ -0,0 +1,68 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#pragma once
+
+#include "Luau/Def.h"
+#include "Luau/TypedAllocator.h"
+#include "Luau/Variant.h"
+
+namespace Luau
+{
+
+struct Type;
+using TypeId = const Type*;
+
+struct Negation;
+struct Conjunction;
+struct Disjunction;
+struct Equivalence;
+struct Proposition;
+using Refinement = Variant<Negation, Conjunction, Disjunction, Equivalence, Proposition>;
+using RefinementId = Refinement*; // Can and most likely is nullptr.
+
+struct Negation
+{
+    RefinementId refinement;
+};
+
+struct Conjunction
+{
+    RefinementId lhs;
+    RefinementId rhs;
+};
+
+struct Disjunction
+{
+    RefinementId lhs;
+    RefinementId rhs;
+};
+
+struct Equivalence
+{
+    RefinementId lhs;
+    RefinementId rhs;
+};
+
+struct Proposition
+{
+    DefId def;
+    TypeId discriminantTy;
+};
+
+template<typename T>
+const T* get(RefinementId refinement)
+{
+    return get_if<T>(refinement);
+}
+
+struct RefinementArena
+{
+    TypedAllocator<Refinement> allocator;
+
+    RefinementId negation(RefinementId refinement);
+    RefinementId conjunction(RefinementId lhs, RefinementId rhs);
+    RefinementId disjunction(RefinementId lhs, RefinementId rhs);
+    RefinementId equivalence(RefinementId lhs, RefinementId rhs);
+    RefinementId proposition(DefId def, TypeId discriminantTy);
+};
+
+} // namespace Luau

Analysis/include/Luau/Type.h

@@ -3,7 +3,7 @@
 
 #include "Luau/Ast.h"
 #include "Luau/Common.h"
-#include "Luau/Connective.h"
+#include "Luau/Refinement.h"
 #include "Luau/DataFlowGraph.h"
 #include "Luau/DenseHash.h"
 #include "Luau/Def.h"
@@ -266,12 +266,12 @@ struct MagicRefinementContext
     ScopePtr scope;
     NotNull<struct ConstraintGraphBuilder> cgb;
     NotNull<const DataFlowGraph> dfg;
-    NotNull<ConnectiveArena> connectiveArena;
-    std::vector<ConnectiveId> argumentConnectives;
+    NotNull<RefinementArena> refinementArena;
+    std::vector<RefinementId> argumentRefinements;
     const class AstExprCall* callSite;
 };
 
-using DcrMagicRefinement = std::vector<ConnectiveId> (*)(const MagicRefinementContext&);
+using DcrMagicRefinement = std::vector<RefinementId> (*)(const MagicRefinementContext&);
 
 struct FunctionType
 {

Analysis/include/Luau/TypeReduction.h

@@ -32,11 +32,23 @@ struct TypeReduction
     explicit TypeReduction(
         NotNull<TypeArena> arena, NotNull<BuiltinTypes> builtinTypes, NotNull<InternalErrorReporter> handle, const TypeReductionOptions& opts = {});
 
+    TypeReduction(const TypeReduction&) = delete;
+    TypeReduction& operator=(const TypeReduction&) = delete;
+
+    TypeReduction(TypeReduction&&) = default;
+    TypeReduction& operator=(TypeReduction&&) = default;
+
     std::optional<TypeId> reduce(TypeId ty);
     std::optional<TypePackId> reduce(TypePackId tp);
     std::optional<TypeFun> reduce(const TypeFun& fun);
 
+    /// Creating a child TypeReduction will allow the parent TypeReduction to share its memoization with the child TypeReductions.
+    /// This is safe as long as the parent's TypeArena continues to outlive both TypeReduction memoization.
+    TypeReduction fork(NotNull<TypeArena> arena, const TypeReductionOptions& opts = {}) const;
+
 private:
+    const TypeReduction* parent = nullptr;
+
     NotNull<TypeArena> arena;
     NotNull<BuiltinTypes> builtinTypes;
     NotNull<struct InternalErrorReporter> handle;
@@ -50,6 +62,9 @@ struct TypeReduction
 
     bool hasExceededCartesianProductLimit(TypeId ty) const;
     bool hasExceededCartesianProductLimit(TypePackId tp) const;
+
+    std::optional<TypeId> memoizedof(TypeId ty) const;
+    std::optional<TypePackId> memoizedof(TypePackId tp) const;
 };
 
 } // namespace Luau

Analysis/include/Luau/Unifier.h

@@ -95,8 +95,7 @@ struct Unifier
     void tryUnifyScalarShape(TypeId subTy, TypeId superTy, bool reversed);
     void tryUnifyWithMetatable(TypeId subTy, TypeId superTy, bool reversed);
     void tryUnifyWithClass(TypeId subTy, TypeId superTy, bool reversed);
-    void tryUnifyTypeWithNegation(TypeId subTy, TypeId superTy);
-    void tryUnifyNegationWithType(TypeId subTy, TypeId superTy);
+    void tryUnifyNegations(TypeId subTy, TypeId superTy);
 
     TypePackId tryApplyOverloadedFunction(TypeId function, const NormalizedFunctionType& overloads, TypePackId args);
 

Analysis/src/Autocomplete.cpp

@@ -7,13 +7,13 @@
 #include "Luau/ToString.h"
 #include "Luau/TypeInfer.h"
 #include "Luau/TypePack.h"
+#include "Luau/TypeReduction.h"
 
 #include <algorithm>
 #include <unordered_set>
 #include <utility>
 
 LUAU_FASTFLAGVARIABLE(LuauCompleteTableKeysBetter, false);
-LUAU_FASTFLAGVARIABLE(LuauFixAutocompleteInIf, false);
 LUAU_FASTFLAGVARIABLE(LuauFixAutocompleteInWhile, false);
 LUAU_FASTFLAGVARIABLE(LuauFixAutocompleteInFor, false);
 LUAU_FASTFLAGVARIABLE(LuauAutocompleteStringContent, false);
@@ -1534,20 +1534,13 @@ static AutocompleteResult autocomplete(const SourceModule& sourceModule, const M
     }
     else if (AstStatIf* statIf = extractStat<AstStatIf>(ancestry);
              statIf && (!statIf->thenLocation || statIf->thenLocation->containsClosed(position)) &&
-             (!FFlag::LuauFixAutocompleteInIf || (statIf->condition && !statIf->condition->location.containsClosed(position))))
+             (statIf->condition && !statIf->condition->location.containsClosed(position)))
     {
-        if (FFlag::LuauFixAutocompleteInIf)
-        {
-            AutocompleteEntryMap ret;
-            ret["then"] = {AutocompleteEntryKind::Keyword};
-            ret["and"] = {AutocompleteEntryKind::Keyword};
-            ret["or"] = {AutocompleteEntryKind::Keyword};
-            return {std::move(ret), ancestry, AutocompleteContext::Keyword};
-        }
-        else
-        {
-            return {{{"then", AutocompleteEntry{AutocompleteEntryKind::Keyword}}}, ancestry, AutocompleteContext::Keyword};
-        }
+        AutocompleteEntryMap ret;
+        ret["then"] = {AutocompleteEntryKind::Keyword};
+        ret["and"] = {AutocompleteEntryKind::Keyword};
+        ret["or"] = {AutocompleteEntryKind::Keyword};
+        return {std::move(ret), ancestry, AutocompleteContext::Keyword};
     }
     else if (AstStatRepeat* statRepeat = node->as<AstStatRepeat>(); statRepeat && statRepeat->condition->is<AstExprError>())
         return autocompleteExpression(sourceModule, *module, builtinTypes, typeArena, ancestry, position);
@@ -1671,7 +1664,6 @@ AutocompleteResult autocomplete(Frontend& frontend, const ModuleName& moduleName
         return {};
 
     ModulePtr module = frontend.moduleResolverForAutocomplete.getModule(moduleName);
-
     if (!module)
         return {};