Sync to upstream/release/669

Analysis/include/Luau/ConstraintGenerator.h

@@ -11,15 +11,14 @@
 #include "Luau/ModuleResolver.h"
 #include "Luau/Normalize.h"
 #include "Luau/NotNull.h"
+#include "Luau/Polarity.h"
 #include "Luau/Refinement.h"
 #include "Luau/Symbol.h"
 #include "Luau/TypeFwd.h"
 #include "Luau/TypeUtils.h"
-#include "Luau/Variant.h"
 
 #include <memory>
 #include <vector>
-#include <unordered_map>
 
 namespace Luau
 {
@@ -162,19 +161,26 @@ struct ConstraintGenerator
     void visitFragmentRoot(const ScopePtr& resumeScope, AstStatBlock* block);
 
 private:
-    std::vector<std::vector<TypeId>> interiorTypes;
+    struct InteriorFreeTypes
+    {
+        std::vector<TypeId> types;
+        std::vector<TypePackId> typePacks;
+    };
+
+    std::vector<std::vector<TypeId>> DEPRECATED_interiorTypes;
+    std::vector<InteriorFreeTypes> interiorFreeTypes;
 
     /**
      * Fabricates a new free type belonging to a given scope.
      * @param scope the scope the free type belongs to.
      */
-    TypeId freshType(const ScopePtr& scope);
+    TypeId freshType(const ScopePtr& scope, Polarity polarity = Polarity::Unknown);
 
     /**
      * Fabricates a new free type pack belonging to a given scope.
      * @param scope the scope the free type pack belongs to.
      */
-    TypePackId freshTypePack(const ScopePtr& scope);
+    TypePackId freshTypePack(const ScopePtr& scope, Polarity polarity = Polarity::Unknown);
 
     /**
      * Allocate a new TypePack with the given head and tail.
@@ -295,7 +301,7 @@ struct ConstraintGenerator
     );
 
     Inference check(const ScopePtr& scope, AstExprConstantString* string, std::optional<TypeId> expectedType, bool forceSingleton);
-    Inference check(const ScopePtr& scope, AstExprConstantBool* bool_, std::optional<TypeId> expectedType, bool forceSingleton);
+    Inference check(const ScopePtr& scope, AstExprConstantBool* boolExpr, std::optional<TypeId> expectedType, bool forceSingleton);
     Inference check(const ScopePtr& scope, AstExprLocal* local);
     Inference check(const ScopePtr& scope, AstExprGlobal* global);
     Inference checkIndexName(const ScopePtr& scope, const RefinementKey* key, AstExpr* indexee, const std::string& index, Location indexLocation);
@@ -371,6 +377,11 @@ struct ConstraintGenerator
      **/
     TypeId resolveType(const ScopePtr& scope, AstType* ty, bool inTypeArguments, bool replaceErrorWithFresh = false);
 
+    // resolveType() is recursive, but we only want to invoke
+    // inferGenericPolarities() once at the very end.  We thus isolate the
+    // recursive part of the algorithm to this internal helper.
+    TypeId resolveType_(const ScopePtr& scope, AstType* ty, bool inTypeArguments, bool replaceErrorWithFresh = false);
+
     /**
      * Resolves a type pack from its AST annotation.
      * @param scope the scope that the type annotation appears within.
@@ -380,6 +391,9 @@ struct ConstraintGenerator
      **/
     TypePackId resolveTypePack(const ScopePtr& scope, AstTypePack* tp, bool inTypeArguments, bool replaceErrorWithFresh = false);
 
+    // Inner hepler for resolveTypePack
+    TypePackId resolveTypePack_(const ScopePtr& scope, AstTypePack* tp, bool inTypeArguments, bool replaceErrorWithFresh = false);
+
     /**
      * Resolves a type pack from its AST annotation.
      * @param scope the scope that the type annotation appears within.
@@ -418,7 +432,7 @@ struct ConstraintGenerator
      **/
     std::vector<std::pair<Name, GenericTypePackDefinition>> createGenericPacks(
         const ScopePtr& scope,
-        AstArray<AstGenericTypePack*> packs,
+        AstArray<AstGenericTypePack*> generics,
         bool useCache = false,
         bool addTypes = true
     );

Analysis/include/Luau/DataFlowGraph.h

@@ -129,8 +129,8 @@ struct DataFlowGraphBuilder
 
     /// A stack of scopes used by the visitor to see where we are.
     ScopeStack scopeStack;
-
-    DfgScope* currentScope();
+    NotNull<DfgScope> currentScope();
+    DfgScope* currentScope_DEPRECATED();
 
     struct FunctionCapture
     {
@@ -148,8 +148,8 @@ struct DataFlowGraphBuilder
     void joinBindings(DfgScope* p, const DfgScope& a, const DfgScope& b);
     void joinProps(DfgScope* p, const DfgScope& a, const DfgScope& b);
 
-    DefId lookup(Symbol symbol);
-    DefId lookup(DefId def, const std::string& key);
+    DefId lookup(Symbol symbol, Location location);
+    DefId lookup(DefId def, const std::string& key, Location location);
 
     ControlFlow visit(AstStatBlock* b);
     ControlFlow visitBlockWithoutChildScope(AstStatBlock* b);

Analysis/include/Luau/Def.h

@@ -4,7 +4,8 @@
 #include "Luau/NotNull.h"
 #include "Luau/TypedAllocator.h"
 #include "Luau/Variant.h"
-
+#include "Luau/Location.h"
+#include "Luau/Symbol.h"
 #include <string>
 #include <optional>
 
@@ -13,6 +14,7 @@ namespace Luau
 
 struct Def;
 using DefId = NotNull<const Def>;
+struct AstLocal;
 
 /**
  * A cell is a "single-object" value.
@@ -64,6 +66,8 @@ struct Def
     using V = Variant<struct Cell, struct Phi>;
 
     V v;
+    Symbol name;
+    Location location;
 };
 
 template<typename T>
@@ -79,7 +83,7 @@ struct DefArena
 {
     TypedAllocator<Def> allocator;
 
-    DefId freshCell(bool subscripted = false);
+    DefId freshCell(Symbol sym, Location location, bool subscripted = false);
     DefId phi(DefId a, DefId b);
     DefId phi(const std::vector<DefId>& defs);
 };

Analysis/include/Luau/FragmentAutocomplete.h

@@ -75,7 +75,7 @@ struct FragmentAutocompleteResult
 {
     ModulePtr incrementalModule;
     Scope* freshScope;
-    TypeArena arenaForAutocomplete;
+    TypeArena arenaForAutocomplete_DEPRECATED;
     AutocompleteResult acResults;
 };
 

Analysis/include/Luau/Generalization.h

@@ -8,12 +8,39 @@
 namespace Luau
 {
 
+template<typename TID>
+struct GeneralizationParams
+{
+    bool foundOutsideFunctions = false;
+    size_t useCount = 0;
+    Polarity polarity = Polarity::None;
+};
+
+// Replace a single free type by its bounds according to the polarity provided.
+std::optional<TypeId> generalizeType(
+    NotNull<TypeArena> arena,
+    NotNull<BuiltinTypes> builtinTypes,
+    NotNull<Scope> scope,
+    TypeId freeTy,
+    const GeneralizationParams<TypeId>& params
+);
+
+// Generalize one type pack
+std::optional<TypePackId> generalizeTypePack(
+    NotNull<TypeArena> arena,
+    NotNull<BuiltinTypes> builtinTypes,
+    NotNull<Scope> scope,
+    TypePackId tp,
+    const GeneralizationParams<TypePackId>& params
+);
+
+void sealTable(NotNull<Scope> scope, TypeId ty);
+
 std::optional<TypeId> generalize(
     NotNull<TypeArena> arena,
     NotNull<BuiltinTypes> builtinTypes,
     NotNull<Scope> scope,
     NotNull<DenseHashSet<TypeId>> cachedTypes,
     TypeId ty
 );
-
 }

Analysis/include/Luau/InferPolarity.h

@@ -0,0 +1,16 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#pragma once
+
+#include "Luau/NotNull.h"
+#include "Luau/TypeFwd.h"
+
+namespace Luau
+{
+
+struct Scope;
+struct TypeArena;
+
+void inferGenericPolarities(NotNull<TypeArena> arena, NotNull<Scope> scope, TypeId ty);
+void inferGenericPolarities(NotNull<TypeArena> arena, NotNull<Scope> scope, TypePackId tp);
+
+} // namespace Luau

Analysis/include/Luau/InsertionOrderedMap.h

@@ -67,6 +67,19 @@ struct InsertionOrderedMap
             return &pairs.at(it->second).second;
     }
 
+    V& operator[](const K& k)
+    {
+        auto it = indices.find(k);
+        if (it == indices.end())
+        {
+            pairs.push_back(std::make_pair(k, V()));
+            indices[k] = pairs.size() - 1;
+            return pairs.back().second;
+        }
+        else
+            return pairs.at(it->second).second;
+    }
+
     const_iterator begin() const
     {
         return pairs.begin();

Analysis/include/Luau/Polarity.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 <cstdint>
+
+namespace Luau
+{
+
+enum struct Polarity : uint8_t
+{
+    None = 0b000,
+    Positive = 0b001,
+    Negative = 0b010,
+    Mixed = 0b011,
+    Unknown = 0b100,
+};
+
+inline Polarity operator|(Polarity lhs, Polarity rhs)
+{
+    return Polarity(uint8_t(lhs) | uint8_t(rhs));
+}
+
+inline Polarity& operator|=(Polarity& lhs, Polarity rhs)
+{
+    lhs = lhs | rhs;
+    return lhs;
+}
+
+inline Polarity operator&(Polarity lhs, Polarity rhs)
+{
+    return Polarity(uint8_t(lhs) & uint8_t(rhs));
+}
+
+inline Polarity& operator&=(Polarity& lhs, Polarity rhs)
+{
+    lhs = lhs & rhs;
+    return lhs;
+}
+
+inline bool isPositive(Polarity p)
+{
+    return bool(p & Polarity::Positive);
+}
+
+inline bool isNegative(Polarity p)
+{
+    return bool(p & Polarity::Negative);
+}
+
+inline bool isKnown(Polarity p)
+{
+    return p != Polarity::Unknown;
+}
+
+inline Polarity invert(Polarity p)
+{
+    switch (p)
+    {
+    case Polarity::Positive:
+        return Polarity::Negative;
+    case Polarity::Negative:
+        return Polarity::Positive;
+    default:
+        return p;
+    }
+}
+
+} // namespace Luau

Analysis/include/Luau/Scope.h

@@ -40,7 +40,7 @@ struct Scope
     // All the children of this scope.
     std::vector<NotNull<Scope>> children;
     std::unordered_map<Symbol, Binding> bindings;
-    TypePackId returnType;
+    TypePackId returnType = nullptr;
     std::optional<TypePackId> varargPack;
 
     TypeLevel level;
@@ -100,6 +100,7 @@ struct Scope
     std::unordered_map<Name, TypePackId> typeAliasTypePackParameters;
 
     std::optional<std::vector<TypeId>> interiorFreeTypes;
+    std::optional<std::vector<TypePackId>> interiorFreeTypePacks;
 };
 
 // Returns true iff the left scope encloses the right scope.  A Scope* equal to

Analysis/include/Luau/Type.h

@@ -5,10 +5,11 @@
 
 #include "Luau/Ast.h"
 #include "Luau/Common.h"
-#include "Luau/Refinement.h"
 #include "Luau/DenseHash.h"
 #include "Luau/NotNull.h"
+#include "Luau/Polarity.h"
 #include "Luau/Predicate.h"
+#include "Luau/Refinement.h"
 #include "Luau/Unifiable.h"
 #include "Luau/Variant.h"
 #include "Luau/VecDeque.h"
@@ -37,15 +38,6 @@ struct Constraint;
 struct Subtyping;
 struct TypeChecker2;
 
-enum struct Polarity : uint8_t
-{
-    None = 0b000,
-    Positive = 0b001,
-    Negative = 0b010,
-    Mixed = 0b011,
-    Unknown = 0b100,
-};
-
 /**
  * There are three kinds of type variables:
  * - `Free` variables are metavariables, which stand for unconstrained types.
@@ -80,7 +72,7 @@ struct FreeType
     // New constructors
     explicit FreeType(TypeLevel level, TypeId lowerBound, TypeId upperBound);
     // This one got promoted to explicit
-    explicit FreeType(Scope* scope, TypeId lowerBound, TypeId upperBound);
+    explicit FreeType(Scope* scope, TypeId lowerBound, TypeId upperBound, Polarity polarity = Polarity::Unknown);
     explicit FreeType(Scope* scope, TypeLevel level, TypeId lowerBound, TypeId upperBound);
     // Old constructors
     explicit FreeType(TypeLevel level);
@@ -99,6 +91,8 @@ struct FreeType
     // Only used under local type inference
     TypeId lowerBound = nullptr;
     TypeId upperBound = nullptr;
+
+    Polarity polarity = Polarity::Unknown;
 };
 
 struct GenericType
@@ -107,8 +101,8 @@ struct GenericType
     GenericType();
 
     explicit GenericType(TypeLevel level);
-    explicit GenericType(const Name& name);
-    explicit GenericType(Scope* scope);
+    explicit GenericType(const Name& name, Polarity polarity = Polarity::Unknown);
+    explicit GenericType(Scope* scope, Polarity polarity = Polarity::Unknown);
 
     GenericType(TypeLevel level, const Name& name);
     GenericType(Scope* scope, const Name& name);
@@ -118,6 +112,8 @@ struct GenericType
     Scope* scope = nullptr;
     Name name;
     bool explicitName = false;
+
+    Polarity polarity = Polarity::Unknown;
 };
 
 // When an equality constraint is found, it is then "bound" to that type,
@@ -1206,7 +1202,7 @@ struct TypeIterator
     }
 };
 
-TypeId freshType(NotNull<TypeArena> arena, NotNull<BuiltinTypes> builtinTypes, Scope* scope);
+TypeId freshType(NotNull<TypeArena> arena, NotNull<BuiltinTypes> builtinTypes, Scope* scope, Polarity polarity = Polarity::Unknown);
 
 using TypeIdPredicate = std::function<std::optional<TypeId>(TypeId)>;
 std::vector<TypeId> filterMap(TypeId type, TypeIdPredicate predicate);