Sync to upstream/release/700 (#2090)

We have reached release 700!

# Analysis

* `table.isfrozen` and `table.clear` use `{}` instead of generic table
type to make it work with union of table types.
* Relax typing definitions for `types.newtable` to make it easier to
specify read-only table properties
* Do not drop explicit generic type packs. Hopefully fixes #2075 
* Added protection against stack overflows to more spots in `Unifier2`
* Improved bidirectionally inferring lambdas. When performing inference
on a lambda, check _right_ before we attempt to emplace a free type
whether there's a generic.
* Reworked overload resolution interface.
`OverloadResolver::resolveOverload` was introduced to abstract and unify
existing resolving machinery.
* `instantiation2` selects more useful bounds.
- If we have positive or negative polarity, blindly use the upper/lower
bounds respectively.
- Otherwise, attempt to find a reasonable bound by first avoiding
picking `never` or `unknown`, then doing a subtype test to try to pick a
tight bound.
* Added protection against stack overflows to the non-strict type
checker
* Luau-syntax configuration extraction can now be timed out during
analysis. See `CLI/src/Analyze.cpp` for an example.

# Require
* Support chained aliases with built-in cycle detection:
luau-lang/rfcs#145.
* Resolve JohnnyMorganz/luau-lsp#1246.

# Autocomplete

* Do not recommend generic types for anonymous functions being passed as
arguments

---

Co-authored-by: Andy Friesen <[email protected]>
Co-authored-by: Annie Tang <[email protected]>
Co-authored-by: Ariel Weiss <[email protected]>
Co-authored-by: Hunter Goldstein <[email protected]>
Co-authored-by: Varun Saini <[email protected]>

Author: 6 people

Analysis/include/Luau/ConfigResolver.h

@@ -0,0 +1,29 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#pragma once
+
+#include "Luau/Config.h"
+#include "Luau/TypeCheckLimits.h"
+
+namespace Luau
+{
+
+struct Config;
+
+struct ConfigResolver
+{
+    virtual ~ConfigResolver() {}
+
+    virtual const Config& getConfig(const ModuleName& name, const TypeCheckLimits& limits) const = 0;
+};
+
+struct NullConfigResolver : ConfigResolver
+{
+    Config defaultConfig;
+
+    virtual const Config& getConfig(const ModuleName& name, const TypeCheckLimits& limits) const override
+    {
+        return defaultConfig;
+    }
+};
+
+} // namespace Luau

Analysis/include/Luau/FileResolver.h

@@ -1,6 +1,8 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
+#include "Luau/TypeCheckLimits.h"
+
 #include <memory>
 #include <optional>
 #include <string>
@@ -101,7 +103,7 @@ struct FileResolver
 
     virtual std::optional<SourceCode> readSource(const ModuleName& name) = 0;
 
-    virtual std::optional<ModuleInfo> resolveModule(const ModuleInfo* context, AstExpr* expr)
+    virtual std::optional<ModuleInfo> resolveModule(const ModuleInfo* context, AstExpr* expr, const TypeCheckLimits& limits)
     {
         return std::nullopt;
     }

Analysis/include/Luau/Frontend.h

@@ -2,6 +2,7 @@
 #pragma once
 
 #include "Luau/Config.h"
+#include "Luau/ConfigResolver.h"
 #include "Luau/GlobalTypes.h"
 #include "Luau/Module.h"
 #include "Luau/ModuleResolver.h"
@@ -235,7 +236,7 @@ struct Frontend
     );
 
     std::optional<CheckResult> getCheckResult(const ModuleName& name, bool accumulateNested, bool forAutocomplete = false);
-    std::vector<ModuleName> getRequiredScripts(const ModuleName& name);
+    std::vector<ModuleName> getRequiredScripts(const ModuleName& name, const TypeCheckLimits& limits);
 
 private:
     ModulePtr check(
@@ -249,12 +250,13 @@ struct Frontend
         TypeCheckLimits typeCheckLimits
     );
 
-    std::pair<SourceNode*, SourceModule*> getSourceNode(const ModuleName& name);
+    std::pair<SourceNode*, SourceModule*> getSourceNode(const ModuleName& name, const TypeCheckLimits& limits);
     SourceModule parse(const ModuleName& name, std::string_view src, const ParseOptions& parseOptions);
 
     bool parseGraph(
         std::vector<ModuleName>& buildQueue,
         const ModuleName& root,
+        const TypeCheckLimits& limits,
         bool forAutocomplete,
         std::function<bool(const ModuleName&)> canSkip = {}
     );

Analysis/include/Luau/Instantiation2.h

@@ -3,6 +3,7 @@
 
 #include "Luau/NotNull.h"
 #include "Luau/Substitution.h"
+#include "Luau/Subtyping.h"
 #include "Luau/TxnLog.h"
 #include "Luau/TypeFwd.h"
 #include "Luau/Unifiable.h"
@@ -60,30 +61,70 @@ struct Instantiation2 final : Substitution
     // Mapping from generic type packs to `TypePack`s of free types to be used in instantiation.
     DenseHashMap<TypePackId, TypePackId> genericPackSubstitutions{nullptr};
 
+    // Make `NotNull` with LuauInstantiationUsesGenericPolarity
+    Subtyping* subtyping = nullptr;
+    Scope* scope = nullptr;
+
     Instantiation2(TypeArena* arena, DenseHashMap<TypeId, TypeId> genericSubstitutions, DenseHashMap<TypePackId, TypePackId> genericPackSubstitutions)
         : Substitution(TxnLog::empty(), arena)
         , genericSubstitutions(std::move(genericSubstitutions))
         , genericPackSubstitutions(std::move(genericPackSubstitutions))
     {
     }
 
+    Instantiation2(
+        TypeArena* arena,
+        DenseHashMap<TypeId, TypeId> genericSubstitutions,
+        DenseHashMap<TypePackId, TypePackId> genericPackSubstitutions,
+        NotNull<Subtyping> subtyping,
+        NotNull<Scope> scope
+    )
+        : Substitution(TxnLog::empty(), arena)
+        , genericSubstitutions(std::move(genericSubstitutions))
+        , genericPackSubstitutions(std::move(genericPackSubstitutions))
+        , subtyping(subtyping)
+        , scope(scope)
+    {
+    }
+
     bool ignoreChildren(TypeId ty) override;
     bool isDirty(TypeId ty) override;
     bool isDirty(TypePackId tp) override;
     TypeId clean(TypeId ty) override;
     TypePackId clean(TypePackId tp) override;
 };
 
+// Clip with LuauInstantiationUsesGenericPolarity
+std::optional<TypeId> instantiate2_DEPRECATED(
+    TypeArena* arena,
+    DenseHashMap<TypeId, TypeId> genericSubstitutions,
+    DenseHashMap<TypePackId, TypePackId> genericPackSubstitutions,
+    TypeId ty
+);
+
+// Clip with LuauInstantiationUsesGenericPolarity
+std::optional<TypePackId> instantiate2_DEPRECATED(
+    TypeArena* arena,
+    DenseHashMap<TypeId, TypeId> genericSubstitutions,
+    DenseHashMap<TypePackId, TypePackId> genericPackSubstitutions,
+    TypePackId tp
+);
+
 std::optional<TypeId> instantiate2(
     TypeArena* arena,
     DenseHashMap<TypeId, TypeId> genericSubstitutions,
     DenseHashMap<TypePackId, TypePackId> genericPackSubstitutions,
+    NotNull<Subtyping> subtyping,
+    NotNull<Scope> scope,
     TypeId ty
 );
+
 std::optional<TypePackId> instantiate2(
     TypeArena* arena,
     DenseHashMap<TypeId, TypeId> genericSubstitutions,
     DenseHashMap<TypePackId, TypePackId> genericPackSubstitutions,
+    NotNull<Subtyping> subtyping,
+    NotNull<Scope> scope,
     TypePackId tp
 );
 

Analysis/include/Luau/OverloadResolution.h

@@ -22,6 +22,40 @@ struct Subtyping;
 
 class Normalizer;
 
+// There are essentially two reasons why we might consider an overload
+// to be unsuitable:
+//
+// First, subtyping might fail.  This also includes cases where we
+// cannot find a generic substitution scheme that results in a
+// callable function.
+//
+// Second, subtyping might succeed, but it might result in the
+// presence of an unreducible type function.  (eg add<string, string>)
+//
+// TODO: Subtyping should probably also be the thing that checks for
+// unreducible type functions.  This would be nice because it would
+// mean that overload resolution would not have to talk about type
+// functions at all.
+using IncompatibilityReason = Variant<SubtypingReasonings, ErrorVec>;
+
+struct OverloadResolution
+{
+    // Overloads that will work
+    std::vector<TypeId> ok;
+
+    // "Overloads" that aren't callable.
+    std::vector<TypeId> nonFunctions;
+
+    // Overloads that could match, but require that other constraints also be satisfied.
+    std::vector<std::pair<TypeId, std::vector<ConstraintV>>> potentialOverloads;
+
+    // Overloads that have the correct arity, but do not work.
+    std::vector<std::pair<TypeId, IncompatibilityReason>> incompatibleOverloads;
+
+    // Overloads that will never work specifically because of an arity mismatch.
+    std::vector<TypeId> arityMismatches;
+};
+
 struct OverloadResolver
 {
     enum Analysis
@@ -62,7 +96,44 @@ struct OverloadResolver
     std::vector<std::pair<TypeId, ErrorVec>> nonviableOverloads;
     InsertionOrderedMap<TypeId, std::pair<OverloadResolver::Analysis, size_t>> resolution;
 
-    std::pair<OverloadResolver::Analysis, TypeId> selectOverload(
+    // Given a (potentially overloaded) function and a set of arguments, test each overload.
+    OverloadResolution resolveOverload(
+        TypeId fnTy,
+        TypePackId args,
+        Location fnLocation,
+        NotNull<DenseHashSet<TypeId>> uniqueTypes,
+        bool useFreeTypeBounds
+    );
+
+    void reportErrors(
+        ErrorVec& errors,
+        TypeId fnTy,
+        Location fnLocation,
+        const ModuleName& moduleName,
+        TypePackId argPack,
+        const std::vector<AstExpr*>& argExprs,
+        const SubtypingReasoning& reason
+    ) const;
+
+private:
+    void testFunction(
+        OverloadResolution& result,
+        TypeId fnTy,
+        TypePackId argsPack,
+        Location fnLocation,
+        NotNull<DenseHashSet<TypeId>> uniqueTypes
+    );
+
+    void testFunctionOrCallMetamethod(
+        OverloadResolution& result,
+        TypeId fnTy,
+        TypePackId argsPack,
+        Location fnLocation,
+        NotNull<DenseHashSet<TypeId>> uniqueTypes
+    );
+
+public:
+    std::pair<Analysis, TypeId> selectOverload(
         TypeId ty,
         TypePackId args,
         NotNull<DenseHashSet<TypeId>> uniqueTypes,
@@ -104,8 +175,35 @@ struct OverloadResolver
         ErrorVec* errors,
         Location argLocation,
         const SubtypingReasoning* reason,
-        std::optional<TypeId> failedSubTy,
-        std::optional<TypeId> failedSuperTy
+        std::optional<TypeId> wantedTy,
+        std::optional<TypeId> givenTy
+    ) const;
+
+    void maybeEmplaceError(
+        ErrorVec* errors,
+        Location argLocation,
+        const ModuleName& moduleName,
+        const SubtypingReasoning* reason,
+        std::optional<TypeId> wantedTy,
+        std::optional<TypeId> givenTy
+    ) const;
+
+    void maybeEmplaceError(
+        ErrorVec* errors,
+        Location argLocation,
+        const ModuleName& moduleName,
+        const SubtypingReasoning* reason,
+        std::optional<TypePackId> wantedTp,
+        std::optional<TypePackId> givenTp
+    ) const;
+
+    void maybeEmplaceError(
+        ErrorVec* errors,
+        Location argLocation,
+        const ModuleName& moduleName,
+        const SubtypingReasoning* reason,
+        std::optional<TypeOrPack> wantedType,
+        std::optional<TypeOrPack> givenType
     ) const;
 
     // Checks if the candidate args are arity-compatible with the desired parameters.

Analysis/include/Luau/RecursionCounter.h

@@ -37,4 +37,14 @@ struct RecursionLimiter : RecursionCounter
     RecursionLimiter(const std::string& system, int* count, int limit);
 };
 
+struct NonExceptionalRecursionLimiter : RecursionCounter
+{
+    NativeStackGuard nativeStackGuard;
+
+    bool isOk(int limit) const;
+
+    NonExceptionalRecursionLimiter(int* count);
+
+};
+
 } // namespace Luau

Analysis/include/Luau/RequireTracer.h

@@ -21,6 +21,6 @@ struct RequireTraceResult
     std::vector<std::pair<ModuleName, Location>> requireList;
 };
 
-RequireTraceResult traceRequires(FileResolver* fileResolver, AstStatBlock* root, const ModuleName& currentModuleName);
+RequireTraceResult traceRequires(FileResolver* fileResolver, AstStatBlock* root, const ModuleName& currentModuleName, const TypeCheckLimits& limits);
 
 } // namespace Luau

Analysis/include/Luau/Subtyping.h

@@ -117,7 +117,7 @@ struct SubtypingResult
     // If this subtype result required testing free types, we might be making
     // assumptions about what the free type eventually resolves to.  If so,
     // those assumptions are recorded here.
-    std::vector<SubtypeConstraint> assumedConstraints;
+    std::vector<ConstraintV> assumedConstraints;
 
     /// If any generic bounds were invalid, report them here
     std::vector<GenericBoundsMismatch> genericBoundsMismatches;
@@ -211,15 +211,6 @@ struct Subtyping
     // a covariant test where an invariant test would otherwise be required.
     const DenseHashSet<TypeId>* uniqueTypes = nullptr;
 
-    enum class Variance
-    {
-        Covariant,
-        Contravariant
-    };
-
-    // TODO: Clip in CLI-170986
-    Variance variance = Variance::Covariant;
-
     using SeenSet = Set<std::pair<TypeId, TypeId>, TypePairHash>;
     using SeenTypePackSet = Set<std::pair<TypePackId, TypePackId>, TypePairHash>;
 
@@ -252,7 +243,19 @@ struct Subtyping
     // TODO recursion limits
 
     SubtypingResult isSubtype(TypeId subTy, TypeId superTy, NotNull<Scope> scope);
-    SubtypingResult isSubtype(TypePackId subTp, TypePackId superTp, NotNull<Scope> scope, const std::vector<TypeId>& bindableGenerics);
+    SubtypingResult isSubtype(
+        TypePackId subTp,
+        TypePackId superTp,
+        NotNull<Scope> scope,
+        const std::vector<TypeId>& bindableGenerics
+    );
+    SubtypingResult isSubtype(
+        TypePackId subTp,
+        TypePackId superTp,
+        NotNull<Scope> scope,
+        const std::vector<TypeId>& bindableGenerics,
+        const std::vector<TypePackId>& bindableGenericPacks
+    );
     // Clip with FFlagLuauPassBindableGenericsByReference
     SubtypingResult isSubtype_DEPRECATED(
         TypePackId subTp,

Analysis/src/AstQuery.cpp

@@ -12,7 +12,6 @@
 #include <algorithm>
 
 LUAU_FASTFLAG(LuauSolverV2)
-LUAU_FASTFLAGVARIABLE(LuauUnfinishedRepeatAncestryFix)
 
 namespace Luau
 {
@@ -32,22 +31,11 @@ struct AutocompleteNodeFinder : public AstVisitor
 
     bool visit(AstExpr* expr) override
     {
-        if (FFlag::LuauUnfinishedRepeatAncestryFix)
+        // If the expression size is 0 (begin == end), we don't want to include it in the ancestry
+        if (expr->location.begin <= pos && pos <= expr->location.end && expr->location.begin != expr->location.end)
         {
-            // If the expression size is 0 (begin == end), we don't want to include it in the ancestry
-            if (expr->location.begin <= pos && pos <= expr->location.end && expr->location.begin != expr->location.end)
-            {
-                ancestry.push_back(expr);
-                return true;
-            }
-        }
-        else
-        {
-            if (expr->location.begin <= pos && pos <= expr->location.end)
-            {
-                ancestry.push_back(expr);
-                return true;
-            }
+            ancestry.push_back(expr);
+            return true;
         }
         return false;
     }