Merge tag '0.697' into wip_merge

Author: HaroldCindy

Analysis/include/Luau/NativeStackGuard.h

@@ -0,0 +1,28 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#pragma once
+
+#include <stdint.h>
+
+namespace Luau
+{
+
+struct NativeStackGuard
+{
+    NativeStackGuard();
+
+    // Returns true if we are not dangerously close to overrunning the C stack.
+    bool isOk() const;
+
+private:
+    uintptr_t high;
+    uintptr_t low;
+};
+
+}
+
+namespace Luau
+{
+
+uintptr_t getStackAddressSpaceSize();
+
+}

Analysis/include/Luau/RecursionCounter.h

@@ -3,6 +3,7 @@
 
 #include "Luau/Common.h"
 #include "Luau/Error.h"
+#include "Luau/NativeStackGuard.h"
 
 #include <stdexcept>
 #include <exception>
@@ -12,40 +13,28 @@ namespace Luau
 
 struct RecursionLimitException : public InternalCompilerError
 {
-    RecursionLimitException(const std::string system)
-        : InternalCompilerError("Internal recursion counter limit exceeded in " + system)
-    {
-    }
+    explicit RecursionLimitException(const std::string& system);
 };
 
 struct RecursionCounter
 {
-    RecursionCounter(int* count)
-        : count(count)
-    {
-        ++(*count);
-    }
-
-    ~RecursionCounter()
-    {
-        LUAU_ASSERT(*count > 0);
-        --(*count);
-    }
+    explicit RecursionCounter(int* count);
+    ~RecursionCounter();
+
+    RecursionCounter(const RecursionCounter&) = delete;
+    RecursionCounter& operator=(const RecursionCounter&) = delete;
+    RecursionCounter(RecursionCounter&&) = delete;
+    RecursionCounter& operator=(RecursionCounter&&) = delete;
 
 protected:
     int* count;
 };
 
 struct RecursionLimiter : RecursionCounter
 {
-    RecursionLimiter(const std::string system, int* count, int limit)
-        : RecursionCounter(count)
-    {
-        if (limit > 0 && *count > limit)
-        {
-            throw RecursionLimitException(system);
-        }
-    }
+    NativeStackGuard nativeStackGuard;
+
+    RecursionLimiter(const std::string& system, int* count, int limit);
 };
 
 } // namespace Luau

Analysis/include/Luau/TypeFunction.h

@@ -108,6 +108,10 @@ struct TypeFunctionReductionResult
     std::optional<std::string> error;
     /// Messages printed out from user-defined type functions
     std::vector<std::string> messages;
+    /// Some type function reduction rules may _create_ type functions (e.g.
+    /// the numeric type functions can "distribute" over an inner union). If
+    /// any type functions were created this way, we must add them here.
+    std::vector<Ty> freshTypes;
 };
 
 template<typename T>

Analysis/src/BuiltinTypeFunctions.cpp

@@ -29,6 +29,7 @@ LUAU_FASTFLAG(LuauExplicitSkipBoundTypes)
 LUAU_FASTFLAG(LuauNoMoreComparisonTypeFunctions)
 LUAU_FASTFLAGVARIABLE(LuauBuiltinTypeFunctionsArentGlobal)
 LUAU_FASTFLAG(LuauPassBindableGenericsByReference)
+LUAU_FASTFLAG(LuauEnqueueUnionsOfDistributedTypeFunctions)
 
 namespace Luau
 {
@@ -122,7 +123,10 @@ std::optional<TypeFunctionReductionResult<TypeId>> tryDistributeTypeFunctionApp(
         if (ctx->solver)
             ctx->pushConstraint(ReduceConstraint{resultTy});
 
-        return {{resultTy, Reduction::MaybeOk, {}, {}}};
+        if (FFlag::LuauEnqueueUnionsOfDistributedTypeFunctions)
+            return {{resultTy, Reduction::MaybeOk, {}, {}, {}, {}, {resultTy}}};
+        else
+            return {{resultTy, Reduction::MaybeOk, {}, {}}};
     }
 
     return std::nullopt;
@@ -2468,7 +2472,7 @@ static TypeFunctionReductionResult<TypeId> getmetatableHelper(TypeId targetTy, c
     std::optional<TypeId> result = std::nullopt;
     bool erroneous = true;
 
-    if (auto table = get<TableType>(targetTy))
+    if (get<TableType>(targetTy))
         erroneous = false;
 
     if (auto mt = get<MetatableType>(targetTy))

Analysis/src/ConstraintGenerator.cpp

@@ -1563,7 +1563,7 @@ ControlFlow ConstraintGenerator::visit(const ScopePtr& scope, AstStatFunction* f
         sig.bodyScope->lvalueTypes[def] = sig.signature;
         updateRValueRefinements(sig.bodyScope, def, sig.signature);
     }
-    else if (AstExprIndexName* indexName = function->name->as<AstExprIndexName>())
+    else if (function->name->is<AstExprIndexName>())
     {
         updateRValueRefinements(sig.bodyScope, def, sig.signature);
     }
@@ -1673,7 +1673,7 @@ ControlFlow ConstraintGenerator::visit(const ScopePtr& scope, AstStatFunction* f
     {
         visitLValue(scope, indexName, generalizedType);
     }
-    else if (AstExprError* err = function->name->as<AstExprError>())
+    else if (function->name->is<AstExprError>())
     {
         generalizedType = builtinTypes->errorType;
     }
@@ -2360,7 +2360,7 @@ InferencePack ConstraintGenerator::checkPack(
 
     if (AstExprCall* call = expr->as<AstExprCall>())
         result = checkPack(scope, call);
-    else if (AstExprVarargs* varargs = expr->as<AstExprVarargs>())
+    else if (expr->is<AstExprVarargs>())
     {
         if (scope->varargPack)
             result = InferencePack{*scope->varargPack};

Analysis/src/ConstraintSolver.cpp

@@ -1226,7 +1226,7 @@ bool ConstraintSolver::tryDispatch(const TypeAliasExpansionConstraint& c, NotNul
     }
 
     // Adding ReduceConstraint on type function for the constraint solver
-    if (auto typeFn = get<TypeFunctionInstanceType>(follow(tf->type)))
+    if (get<TypeFunctionInstanceType>(follow(tf->type)))
         pushConstraint(NotNull(constraint->scope.get()), constraint->location, ReduceConstraint{tf->type});
 
     // Due to how pending expansion types and TypeFun's are created
@@ -3660,7 +3660,7 @@ bool ConstraintSolver::isBlocked(TypePackId tp) const
 {
     tp = follow(tp);
 
-    if (auto tfitp = get<TypeFunctionInstanceTypePack>(tp))
+    if (get<TypeFunctionInstanceTypePack>(tp))
         return uninhabitedTypeFunctions.contains(tp) == false;
 
     return nullptr != get<BlockedTypePack>(tp);

Analysis/src/DataFlowGraph.cpp

@@ -574,7 +574,7 @@ ControlFlow DataFlowGraphBuilder::visit(AstStatLocal* l)
         if (i < l->values.size)
         {
             AstExpr* e = l->values.data[i];
-            if (const AstExprTable* tbl = e->as<AstExprTable>())
+            if (e->is<AstExprTable>())
             {
                 def = defs[i];
             }
@@ -1165,17 +1165,17 @@ void DataFlowGraphBuilder::visitType(AstType* t)
         return visitType(f);
     else if (auto tyof = t->as<AstTypeTypeof>())
         return visitType(tyof);
-    else if (auto o = t->as<AstTypeOptional>())
+    else if (t->is<AstTypeOptional>())
         return;
     else if (auto u = t->as<AstTypeUnion>())
         return visitType(u);
     else if (auto i = t->as<AstTypeIntersection>())
         return visitType(i);
     else if (auto e = t->as<AstTypeError>())
         return visitType(e);
-    else if (auto s = t->as<AstTypeSingletonBool>())
+    else if (t->is<AstTypeSingletonBool>())
         return; // ok
-    else if (auto s = t->as<AstTypeSingletonString>())
+    else if (t->is<AstTypeSingletonString>())
         return; // ok
     else if (auto g = t->as<AstTypeGroup>())
         return visitType(g->type);
@@ -1243,7 +1243,7 @@ void DataFlowGraphBuilder::visitTypePack(AstTypePack* p)
         return visitTypePack(e);
     else if (auto v = p->as<AstTypePackVariadic>())
         return visitTypePack(v);
-    else if (auto g = p->as<AstTypePackGeneric>())
+    else if (p->is<AstTypePackGeneric>())
         return; // ok
     else
         handle->ice("Unknown AstTypePack in DataFlowGraphBuilder::visitTypePack");

Analysis/src/EqSatSimplification.cpp

@@ -286,7 +286,7 @@ Id toId(
     // First, handle types which do not contain other types.  They obviously
     // cannot participate in cycles, so we don't have to check for that.
 
-    if (auto freeTy = get<FreeType>(ty))
+    if (get<FreeType>(ty))
         return egraph.add(TOpaque{ty});
     else if (get<GenericType>(ty))
         return egraph.add(TOpaque{ty});
@@ -765,7 +765,7 @@ TypeId fromId(
         return arena->addType(SingletonType{StringSingleton{strings.asString(s->value())}});
     else if (auto fun = node.get<TFunction>())
         return fun->value();
-    else if (auto tbl = node.get<TTable>())
+    else if (node.get<TTable>())
     {
         TypeId res = arena->addType(BlockedType{});
         seen[rootId] = res;
@@ -1310,7 +1310,7 @@ void unionWithType(EGraph& egraph, CanonicalizedType& ct, Id part)
         if (!ct.functionPart)
             ct.functionParts.insert(part);
     }
-    else if (auto tclass = isTag<TClass>(egraph, part))
+    else if (isTag<TClass>(egraph, part))
         unionClasses(egraph, ct.classParts, part);
     else if (isTag<TAny>(egraph, part))
     {
@@ -1415,7 +1415,7 @@ bool subtract(EGraph& egraph, CanonicalizedType& ct, Id part)
         ct.tablePart.reset();
     else if (etype->get<TTopClass>())
         ct.classParts.clear();
-    else if (auto tclass = etype->get<TClass>())
+    else if (etype->get<TClass>())
     {
         auto it = std::find(ct.classParts.begin(), ct.classParts.end(), part);
         if (it != ct.classParts.end())

Analysis/src/Error.cpp

@@ -697,7 +697,7 @@ struct ErrorConverter
             if (tfit->typeArguments.size() != 2)
                 return "Type function instance " + Luau::toString(e.ty) + " is ill-formed, and thus invalid";
 
-            if (auto errType = get<ErrorType>(tfit->typeArguments[1])) // Second argument to (index | rawget)<_,_> is not a type
+            if (get<ErrorType>(tfit->typeArguments[1])) // Second argument to (index | rawget)<_,_> is not a type
                 return "Second argument to " + tfit->function->name + "<" + Luau::toString(tfit->typeArguments[0]) + ", _> is not a valid index type";
             else // Property `indexer` does not exist on type `indexee`
                 return "Property '" + Luau::toString(tfit->typeArguments[1]) + "' does not exist on type '" + Luau::toString(tfit->typeArguments[0]) +
@@ -757,12 +757,8 @@ struct ErrorConverter
     std::string operator()(const CheckedFunctionCallError& e) const
     {
         // TODO: What happens if checkedFunctionName cannot be found??
-        if (FFlag::LuauNewNonStrictReportsOneIndexedErrors)
-            return "Function '" + e.checkedFunctionName + "' expects '" + toString(e.expected) + "' at argument #" +
-                   std::to_string(e.argumentIndex + 1) + ", but got '" + Luau::toString(e.passed) + "'";
-        else
-            return "Function '" + e.checkedFunctionName + "' expects '" + toString(e.expected) + "' at argument #" + std::to_string(e.argumentIndex) +
-                   ", but got '" + Luau::toString(e.passed) + "'";
+        return "Function '" + e.checkedFunctionName + "' expects '" + toString(e.expected) + "' at argument #" +
+            std::to_string(e.argumentIndex + 1) + ", but got '" + Luau::toString(e.passed) + "'";
     }
 
     std::string operator()(const NonStrictFunctionDefinitionError& e) const

Analysis/src/FragmentAutocomplete.cpp

@@ -33,8 +33,6 @@ LUAU_FASTINT(LuauTarjanChildLimit)
 LUAU_FASTFLAGVARIABLE(DebugLogFragmentsFromAutocomplete)
 LUAU_FASTFLAG(LuauUseWorkspacePropToChooseSolver)
 LUAU_FASTFLAGVARIABLE(LuauFragmentRequiresCanBeResolvedToAModule)
-LUAU_FASTFLAGVARIABLE(LuauPopulateSelfTypesInFragment)
-LUAU_FASTFLAGVARIABLE(LuauForInProvidesRecommendations)
 LUAU_FASTFLAGVARIABLE(LuauForInRangesConsiderInLocation)
 
 namespace Luau
@@ -119,7 +117,7 @@ Location getFragmentLocation(AstStat* nearestStatement, const Position& cursorPo
     {
         Location nonEmpty{nearestStatement->location.begin, cursorPosition};
         // If your sibling is a do block, do nothing
-        if (auto doEnd = nearestStatement->as<AstStatBlock>())
+        if (nearestStatement->as<AstStatBlock>())
             return empty;
 
         // If you're inside the body of the function and this is your sibling, empty fragment
@@ -156,27 +154,20 @@ Location getFragmentLocation(AstStat* nearestStatement, const Position& cursorPo
 
         if (auto forStat = nearestStatement->as<AstStatFor>())
         {
-
-            if (FFlag::LuauForInProvidesRecommendations)
-            {
-                if (forStat->step && forStat->step->location.containsClosed(cursorPosition))
-                    return {forStat->step->location.begin, cursorPosition};
-                if (forStat->to && forStat->to->location.containsClosed(cursorPosition))
-                    return {forStat->to->location.begin, cursorPosition};
-                if (forStat->from && forStat->from->location.containsClosed(cursorPosition))
-                    return {forStat->from->location.begin, cursorPosition};
-            }
+            if (forStat->step && forStat->step->location.containsClosed(cursorPosition))
+                return {forStat->step->location.begin, cursorPosition};
+            if (forStat->to && forStat->to->location.containsClosed(cursorPosition))
+                return {forStat->to->location.begin, cursorPosition};
+            if (forStat->from && forStat->from->location.containsClosed(cursorPosition))
+                return {forStat->from->location.begin, cursorPosition};
 
             if (!forStat->hasDo)
                 return nonEmpty;
             else
             {
-                if (FFlag::LuauForInProvidesRecommendations)
-                {
                     auto completeableExtents = Location{forStat->location.begin, forStat->doLocation.begin};
                     if (completeableExtents.containsClosed(cursorPosition))
                         return nonEmpty;
-                }
 
                 return empty;
             }
@@ -188,21 +179,18 @@ Location getFragmentLocation(AstStat* nearestStatement, const Position& cursorPo
                 return nonEmpty;
             else
             {
-                if (FFlag::LuauForInProvidesRecommendations)
+                auto completeableExtents = Location{forIn->location.begin, forIn->doLocation.begin};
+                if (completeableExtents.containsClosed(cursorPosition))
                 {
-                    auto completeableExtents = Location{forIn->location.begin, forIn->doLocation.begin};
-                    if (completeableExtents.containsClosed(cursorPosition))
+                    if (!forIn->hasIn)
+                        return nonEmpty;
+                    else
                     {
-                        if (!forIn->hasIn)
+                        // [for ... in ... do] - the cursor can either be between [for ... in] or [in ... do]
+                        if (FFlag::LuauForInRangesConsiderInLocation && cursorPosition < forIn->inLocation.begin)
                             return nonEmpty;
                         else
-                        {
-                            // [for ... in ... do] - the cursor can either be between [for ... in] or [in ... do]
-                            if (FFlag::LuauForInRangesConsiderInLocation && cursorPosition < forIn->inLocation.begin)
-                                return nonEmpty;
-                            else
-                                return Location{forIn->inLocation.begin, cursorPosition};
-                        }
+                            return Location{forIn->inLocation.begin, cursorPosition};
                     }
                 }
                 return empty;
@@ -429,13 +417,10 @@ FragmentAutocompleteAncestryResult findAncestryForFragmentParse(AstStatBlock* st
                     {
                         if (globFun->location.contains(cursorPos))
                         {
-                            if (FFlag::LuauPopulateSelfTypesInFragment)
+                            if (auto local = globFun->func->self)
                             {
-                                if (auto local = globFun->func->self)
-                                {
-                                    localStack.push_back(local);
-                                    localMap[local->name] = local;
-                                }
+                                localStack.push_back(local);
+                                localMap[local->name] = local;
                             }
 
                             for (AstLocal* loc : globFun->func->args)