Sync to upstream/release/698 (#2070)

# General

Another week, another release. Happy Halloween! 🎃

## Require
- Integrate support for `.config.luau` files into `Luau.Require` as part
of the [Luau-syntax configuration files
RFC](https://rfcs.luau.org/config-luauconfig.html).
  - `is_config_present` has been replaced with `get_config_status`.
- `get_luau_config_timeout` has been added to configure extraction
timeouts at runtime.
- Enable support for `.config.luau` files in `luau` and `luau-analyze`.
- Merge the `Luau.RequireNavigator` static library into `Luau.Require`.

## Analysis
- Add fuel-based limits for normalization: normalization will now take a
set number of steps (the "fuel") and stop when we hit a certain number
of steps ("run out of fuel"). This is in lieu of trying to check static
limits on the size of its inputs. This may result in seeing more "code
too complex" errors but should dramatically reduce the number of cases
where Luau becomes unresponsive and uses several gigabytes of memory. We
plan to tune this limit over time to find the right balance between
responsiveness and completeness.
- Fix a case where refining a variable with the type `any` would cause
it to become `unknown` instead due to normalization not preserving `any`
in the top type position.
- Improve the wording of type errors in the new non-strict mode.
- Fix #1910.
- Fix #2065.
- Fix #1483.
- Fix #2018.

## Miscellaneous
- Introduce `Luau::overloaded` to facilitate interacting with
`Luau::Variant`.
- Add type checking support to the [Luau demo](https://luau.org/demo)!

---

Co-authored-by: Annie Tang <[email protected]>
Co-authored-by: Ariel Weiss <[email protected]>
Co-authored-by: Hunter Goldstein <[email protected]>
Co-authored-by: Ilya Rezvov <[email protected]>
Co-authored-by: Sora Kanosue <[email protected]>
Co-authored-by: Varun Saini <[email protected]>

Author: 6 people

Analysis/include/Luau/ConstraintSolver.h

@@ -218,18 +218,6 @@ struct ConstraintSolver
 
     void generalizeOneType(TypeId ty);
 
-    /**
-     * Bind a type variable to another type.
-     *
-     * A constraint is required and will validate that blockedTy is owned by this
-     * constraint. This prevents one constraint from interfering with another's
-     * blocked types.
-     *
-     * Bind will also unblock the type variable for you.
-     */
-    void bind(NotNull<const Constraint> constraint, TypeId ty, TypeId boundTo);
-    void bind(NotNull<const Constraint> constraint, TypePackId tp, TypePackId boundTo);
-
     template<typename T, typename... Args>
     void emplace(NotNull<const Constraint> constraint, TypeId ty, Args&&... args);
 
@@ -404,6 +392,18 @@ struct ConstraintSolver
      */
     void shiftReferences(TypeId source, TypeId target);
 
+    /**
+     * Bind a type variable to another type.
+     *
+     * A constraint is required and will validate that blockedTy is owned by this
+     * constraint. This prevents one constraint from interfering with another's
+     * blocked types.
+     *
+     * Bind will also unblock the type variable for you.
+     */
+    void bind(NotNull<const Constraint> constraint, TypeId ty, TypeId boundTo);
+    void bind(NotNull<const Constraint> constraint, TypePackId tp, TypePackId boundTo);
+
     /**
      * Generalizes the given free type if the reference counting allows it.
      * @param the scope to generalize in

Analysis/include/Luau/Normalize.h

@@ -317,6 +317,8 @@ class Normalizer
     DenseHashMap<TypeId, bool> cachedIsInhabited{nullptr};
     DenseHashMap<std::pair<TypeId, TypeId>, bool, TypeIdPairHash> cachedIsInhabitedIntersection{{nullptr, nullptr}};
 
+    std::optional<int> fuel{std::nullopt};
+
     bool withinResourceLimits();
     bool useNewLuauSolver() const;
 
@@ -342,13 +344,29 @@ class Normalizer
 
     // If this returns null, the typechecker should emit a "too complex" error
     std::shared_ptr<const NormalizedType> normalize(TypeId ty);
-    void clearNormal(NormalizedType& norm);
 
+    void clearCaches();
+
+    NormalizationResult isIntersectionInhabited(TypeId left, TypeId right);
+
+    // Check for inhabitance
+    NormalizationResult isInhabited(TypeId ty);
+    NormalizationResult isInhabited(const NormalizedType* norm);
+
+    // -------- Convert back from a normalized type to a type
+    TypeId typeFromNormal(const NormalizedType& norm);
+
+    std::optional<TypePackId> intersectionOfTypePacks(TypePackId here, TypePackId there);
+
+    // Move to private with LuauNormalizerStepwiseFuel
+    std::optional<TypePackId> intersectionOfTypePacks_INTERNAL(TypePackId here, TypePackId there);
+
+private:
     // ------- Cached TypeIds
     TypeId unionType(TypeId here, TypeId there);
     TypeId intersectionType(TypeId here, TypeId there);
     const TypeIds* cacheTypeIds(TypeIds tys);
-    void clearCaches();
+    void clearNormal(NormalizedType& norm);
 
     // ------- Normalizing unions
     void unionTysWithTy(TypeIds& here, TypeId there);
@@ -389,7 +407,6 @@ class Normalizer
     void intersectExternTypes(NormalizedExternType& heres, const NormalizedExternType& theres);
     void intersectExternTypesWithExternType(NormalizedExternType& heres, TypeId there);
     void intersectStrings(NormalizedStringType& here, const NormalizedStringType& there);
-    std::optional<TypePackId> intersectionOfTypePacks(TypePackId here, TypePackId there);
     std::optional<TypeId> intersectionOfTables(TypeId here, TypeId there, SeenTablePropPairs& seenTablePropPairs, Set<TypeId>& seenSet);
     void intersectTablesWithTable(TypeIds& heres, TypeId there, SeenTablePropPairs& seenTablePropPairs, Set<TypeId>& seenSetTypes);
     void intersectTables(TypeIds& heres, const TypeIds& theres);
@@ -411,18 +428,20 @@ class Normalizer
         Set<TypeId>& seenSet
     );
 
-    // Check for inhabitance
-    NormalizationResult isInhabited(TypeId ty);
     NormalizationResult isInhabited(TypeId ty, Set<TypeId>& seen);
-    NormalizationResult isInhabited(const NormalizedType* norm);
     NormalizationResult isInhabited(const NormalizedType* norm, Set<TypeId>& seen);
 
     // Check for intersections being inhabited
-    NormalizationResult isIntersectionInhabited(TypeId left, TypeId right);
     NormalizationResult isIntersectionInhabited(TypeId left, TypeId right, SeenTablePropPairs& seenTablePropPairs, Set<TypeId>& seenSet);
 
-    // -------- Convert back from a normalized type to a type
-    TypeId typeFromNormal(const NormalizedType& norm);
+
+    // Fuel setup
+
+    bool initializeFuel();
+    void clearFuel();
+    void consumeFuel();
+
+    friend struct FuelInitializer;
 };
 
 } // namespace Luau

Analysis/include/Luau/Subtyping.h

@@ -147,13 +147,6 @@ struct SubtypingEnvironment
         TypeIds upperBound;
     };
 
-    // TODO: Clip with LuauSubtypingGenericsDoesntUseVariance
-    struct GenericBounds_DEPRECATED
-    {
-        DenseHashSet<TypeId> lowerBound{nullptr};
-        DenseHashSet<TypeId> upperBound{nullptr};
-    };
-
     /* For nested subtyping relationship tests of mapped generic bounds, we keep the outer environment immutable */
     SubtypingEnvironment* parent = nullptr;
 
@@ -165,23 +158,16 @@ struct SubtypingEnvironment
         TypeId ty,
         NotNull<InternalErrorReporter> iceReporter
     );
-    // TODO: Clip with LuauSubtypingGenericsDoesntUseVariance
-    std::optional<TypeId> applyMappedGenerics_DEPRECATED(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, TypeId ty);
 
     // TODO: Clip with LuauTryFindSubstitutionReturnOptional
     const TypeId* tryFindSubstitution_DEPRECATED(TypeId ty) const;
     std::optional<TypeId> tryFindSubstitution(TypeId ty) const;
-    // TODO: Clip with LuauSubtypingGenericsDoesntUseVariance
     const SubtypingResult* tryFindSubtypingResult(std::pair<TypeId, TypeId> subAndSuper) const;
 
     bool containsMappedType(TypeId ty) const;
     bool containsMappedPack(TypePackId tp) const;
 
     GenericBounds& getMappedTypeBounds(TypeId ty, NotNull<InternalErrorReporter> iceReporter);
-    // TODO: Clip with LuauSubtypingGenericsDoesntUseVariance
-    GenericBounds_DEPRECATED& getMappedTypeBounds_DEPRECATED(TypeId ty);
-    // TODO: Clip with LuauSubtypingGenericPacksDoesntUseVariance2
-    TypePackId* getMappedPackBounds_DEPRECATED(TypePackId tp);
     MappedGenericEnvironment::LookupResult lookupGenericPack(TypePackId tp) const;
 
     /*
@@ -191,12 +177,8 @@ struct SubtypingEnvironment
      * of each vector represents the current scope.
      */
     DenseHashMap<TypeId, std::vector<GenericBounds>> mappedGenerics{nullptr};
-    // TODO: Clip with LuauSubtypingGenericsDoesntUseVariance
-    DenseHashMap<TypeId, GenericBounds_DEPRECATED> mappedGenerics_DEPRECATED{nullptr};
 
     MappedGenericEnvironment mappedGenericPacks;
-    // TODO: Clip with LuauSubtypingGenericPacksDoesntUseVariance2
-    DenseHashMap<TypePackId, TypePackId> mappedGenericPacks_DEPRECATED{nullptr};
 
     /*
      * See the test cyclic_tables_are_assumed_to_be_compatible_with_extern_types for
@@ -206,8 +188,6 @@ struct SubtypingEnvironment
      */
     DenseHashMap<TypeId, TypeId> substitutions{nullptr};
 
-    // TODO: Clip with LuauSubtypingGenericsDoesntUseVariance
-    DenseHashMap<std::pair<TypeId, TypeId>, SubtypingResult, TypePairHash> ephemeralCache{{}};
 
     // We use this cache to track pairs of subtypes that we tried to subtype, and found them to be in the seen set at the time.
     // In those situations, we return True, but mark the result as not cacheable, because we don't want to cache broader results which
@@ -237,7 +217,7 @@ struct Subtyping
         Contravariant
     };
 
-    // TODO: Clip this along with LuauSubtypingGenericsDoesntUseVariance?
+    // TODO: Clip in CLI-170986
     Variance variance = Variance::Covariant;
 
     using SeenSet = Set<std::pair<TypeId, TypeId>, TypePairHash>;
@@ -467,8 +447,6 @@ struct Subtyping
     SubtypingResult isTailCovariantWithTail(SubtypingEnvironment& env, NotNull<Scope> scope, Nothing, TypePackId superTp, const GenericTypePack* super);
 
     bool bindGeneric(SubtypingEnvironment& env, TypeId subTp, TypeId superTp);
-    // Clip with LuauSubtypingGenericPacksDoesntUseVariance2
-    bool bindGeneric_DEPRECATED(SubtypingEnvironment& env, TypePackId subTp, TypePackId superTp) const;
 
     template<typename T, typename Container>
     TypeId makeAggregateType(const Container& container, TypeId orElse);

Analysis/include/Luau/ToString.h

@@ -127,6 +127,10 @@ inline std::string toStringNamedFunction(const std::string& funcName, const Func
     return toStringNamedFunction(funcName, ftv, opts);
 }
 
+// Converts the given number index into a human-readable string for that index to be used in errors.
+// e.g. the index `0` becomes `1st`, `1` becomes `2nd`, `11` becomes `12th`, etc.
+std::string toHumanReadableIndex(size_t number);
+
 std::optional<std::string> getFunctionNameAsString(const AstExpr& expr);
 
 // It could be useful to see the text representation of a type during a debugging session instead of exploring the content of the class

Analysis/include/Luau/TypePack.h

@@ -231,11 +231,6 @@ bool isEmpty(TypePackId tp);
 /// Flattens out a type pack.  Also returns a valid TypePackId tail if the type pack's full size is not known
 std::pair<std::vector<TypeId>, std::optional<TypePackId>> flatten(TypePackId tp);
 std::pair<std::vector<TypeId>, std::optional<TypePackId>> flatten(TypePackId tp, const TxnLog& log);
-// TODO: Clip with LuauSubtypingGenericPacksDoesntUseVariance2
-std::pair<std::vector<TypeId>, std::optional<TypePackId>> flatten_DEPRECATED(
-    TypePackId tp,
-    const DenseHashMap<TypePackId, TypePackId>& mappedGenericPacks
-);
 
 /// Returs true if the type pack arose from a function that is declared to be variadic.
 /// Returns *false* for function argument packs that are inferred to be safe to oversaturate!

Analysis/include/Luau/TypePath.h

@@ -241,54 +241,8 @@ std::string toString(const TypePath::Path& path, bool prefixDot = false);
 /// Converts a Path to a human readable string for error reporting.
 std::string toStringHuman(const TypePath::Path& path);
 
-// To keep my head straight when clipping:
-// LuauReturnMappedGenericPacksFromSubtyping3 expects mappedGenericPacks AND arena
-// LuauSubtypingGenericPacksDoesntUseVariance2 expects just arena. this is the final state
-
-// TODO: clip below two along with `LuauReturnMappedGenericPacksFromSubtyping3`
-std::optional<TypeOrPack> traverse_DEPRECATED(TypeId root, const Path& path, NotNull<BuiltinTypes> builtinTypes);
-std::optional<TypeOrPack> traverse_DEPRECATED(TypePackId root, const Path& path, NotNull<BuiltinTypes> builtinTypes);
 std::optional<TypeOrPack> traverse(TypePackId root, const Path& path, NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena);
-// TODO: Clip with LuauSubtypingGenericPacksDoesntUseVariance2
-std::optional<TypeOrPack> traverse_DEPRECATED(
-    TypePackId root,
-    const Path& path,
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<const DenseHashMap<TypePackId, TypePackId>> mappedGenericPacks,
-    NotNull<TypeArena> arena
-);
 std::optional<TypeOrPack> traverse(TypeId root, const Path& path, NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena);
-// TODO: Clip with LuauSubtypingGenericPacksDoesntUseVariance2
-std::optional<TypeOrPack> traverse_DEPRECATED(
-    TypeId root,
-    const Path& path,
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<const DenseHashMap<TypePackId, TypePackId>> mappedGenericPacks,
-    NotNull<TypeArena> arena
-);
-
-/// Traverses a path from a type to its end point, which must be a type. This overload will fail if the path contains a PackSlice component or a
-/// mapped generic pack.
-/// @param root the entry point of the traversal
-/// @param path the path to traverse
-/// @param builtinTypes the built-in types in use (used to acquire the string metatable)
-/// @returns the TypeId at the end of the path, or nullopt if the traversal failed.
-std::optional<TypeId> traverseForType_DEPRECATED(TypeId root, const Path& path, NotNull<BuiltinTypes> builtinTypes);
-
-/// Traverses a path from a type to its end point, which must be a type.
-/// @param root the entry point of the traversal
-/// @param path the path to traverse
-/// @param builtinTypes the built-in types in use (used to acquire the string metatable)
-/// @param mappedGenericPacks the mapping for any encountered generic packs we want to reify
-/// @param arena a TypeArena, required if path has a PackSlice component
-/// @returns the TypeId at the end of the path, or nullopt if the traversal failed.
-std::optional<TypeId> traverseForType_DEPRECATED(
-    TypeId root,
-    const Path& path,
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<const DenseHashMap<TypePackId, TypePackId>> mappedGenericPacks,
-    NotNull<TypeArena> arena
-);
 
 /// Traverses a path from a type to its end point, which must be a type.
 /// @param root the entry point of the traversal
@@ -298,28 +252,6 @@ std::optional<TypeId> traverseForType_DEPRECATED(
 /// @returns the TypeId at the end of the path, or nullopt if the traversal failed.
 std::optional<TypeId> traverseForType(TypeId root, const Path& path, NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena);
 
-/// Traverses a path from a type pack to its end point, which must be a type.
-/// @param root the entry point of the traversal
-/// @param path the path to traverse
-/// @param builtinTypes the built-in types in use (used to acquire the string metatable)
-/// @returns the TypeId at the end of the path, or nullopt if the traversal failed.
-std::optional<TypeId> traverseForType_DEPRECATED(TypePackId root, const Path& path, NotNull<BuiltinTypes> builtinTypes);
-
-/// Traverses a path from a type pack to its end point, which must be a type.
-/// @param root the entry point of the traversal
-/// @param path the path to traverse
-/// @param builtinTypes the built-in types in use (used to acquire the string metatable)
-/// @param mappedGenericPacks the mapping for any encountered generic packs we want to reify
-/// @param arena a TypeArena, required if path has a PackSlice component
-/// @returns the TypeId at the end of the path, or nullopt if the traversal failed.
-std::optional<TypeId> traverseForType_DEPRECATED(
-    TypePackId root,
-    const Path& path,
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<const DenseHashMap<TypePackId, TypePackId>> mappedGenericPacks,
-    NotNull<TypeArena> arena
-);
-
 /// Traverses a path from a type pack to its end point, which must be a type.
 /// @param root the entry point of the traversal
 /// @param path the path to traverse
@@ -328,29 +260,6 @@ std::optional<TypeId> traverseForType_DEPRECATED(
 /// @returns the TypeId at the end of the path, or nullopt if the traversal failed.
 std::optional<TypeId> traverseForType(TypePackId root, const Path& path, NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena);
 
-/// Traverses a path from a type to its end point, which must be a type pack. This overload will fail if the path contains a PackSlice component or a
-/// mapped generic pack.
-/// @param root the entry point of the traversal
-/// @param path the path to traverse
-/// @param builtinTypes the built-in types in use (used to acquire the string metatable)
-/// @returns the TypePackId at the end of the path, or nullopt if the traversal failed.
-std::optional<TypePackId> traverseForPack_DEPRECATED(TypeId root, const Path& path, NotNull<BuiltinTypes> builtinTypes);
-
-/// Traverses a path from a type to its end point, which must be a type pack.
-/// @param root the entry point of the traversal
-/// @param path the path to traverse
-/// @param builtinTypes the built-in types in use (used to acquire the string metatable)
-/// @param mappedGenericPacks the mapping for any encountered generic packs we want to reify
-/// @param arena a TypeArena, required if path has a PackSlice component
-/// @returns the TypePackId at the end of the path, or nullopt if the traversal failed.
-std::optional<TypePackId> traverseForPack_DEPRECATED(
-    TypeId root,
-    const Path& path,
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<const DenseHashMap<TypePackId, TypePackId>> mappedGenericPacks,
-    NotNull<TypeArena> arena
-);
-
 /// Traverses a path from a type to its end point, which must be a type pack.
 /// @param root the entry point of the traversal
 /// @param path the path to traverse
@@ -359,28 +268,6 @@ std::optional<TypePackId> traverseForPack_DEPRECATED(
 /// @returns the TypePackId at the end of the path, or nullopt if the traversal failed.
 std::optional<TypePackId> traverseForPack(TypeId root, const Path& path, NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena);
 
-/// Traverses a path from a type pack to its end point, which must be a type pack.
-/// @param root the entry point of the traversal
-/// @param path the path to traverse
-/// @param builtinTypes the built-in types in use (used to acquire the string metatable)
-/// @returns the TypePackId at the end of the path, or nullopt if the traversal failed.
-std::optional<TypePackId> traverseForPack_DEPRECATED(TypePackId root, const Path& path, NotNull<BuiltinTypes> builtinTypes);
-
-/// Traverses a path from a type pack to its end point, which must be a type pack.
-/// @param root the entry point of the traversal
-/// @param path the path to traverse
-/// @param builtinTypes the built-in types in use (used to acquire the string metatable)
-/// @param mappedGenericPacks the mapping for any encountered generic packs we want to reify
-/// @param arena a TypeArena, required if path has a PackSlice component
-/// @returns the TypePackId at the end of the path, or nullopt if the traversal failed.
-std::optional<TypePackId> traverseForPack_DEPRECATED(
-    TypePackId root,
-    const Path& path,
-    NotNull<BuiltinTypes> builtinTypes,
-    NotNull<const DenseHashMap<TypePackId, TypePackId>> mappedGenericPacks,
-    NotNull<TypeArena> arena
-);
-
 /// Traverses a path from a type pack to its end point, which must be a type pack.
 /// @param root the entry point of the traversal
 /// @param path the path to traverse

Analysis/include/Luau/TypeUtils.h

@@ -6,6 +6,7 @@
 #include "Luau/Type.h"
 #include "Luau/TypeIds.h"
 #include "Luau/TypePack.h"
+#include "Luau/VisitType.h"
 
 #include <memory>
 #include <optional>
@@ -388,5 +389,17 @@ struct IntersectionBuilder
 TypeId addIntersection(NotNull<TypeArena> arena, NotNull<BuiltinTypes> builtinTypes, std::initializer_list<TypeId> list);
 TypeId addUnion(NotNull<TypeArena> arena, NotNull<BuiltinTypes> builtinTypes, std::initializer_list<TypeId> list);
 
+struct ContainsAnyGeneric final : public TypeOnceVisitor
+{
+    bool found = false;
+
+    explicit ContainsAnyGeneric();
+
+    bool visit(TypeId ty) override;
+    bool visit(TypePackId ty) override;
+
+    static bool hasAnyGeneric(TypeId ty);
+    static bool hasAnyGeneric(TypePackId tp);
+};
 
 } // namespace Luau