luau-lang · aatxe · Jan 19, 2025 · Jan 19, 2025 · Jan 19, 2025 · Jan 19, 2025
diff --git a/extern/luau/.gitrepo b/extern/luau/.gitrepo
@@ -6,7 +6,7 @@
 [subrepo]
 	remote = git@github.com:luau-lang/luau.git
 	branch = master
-	commit = 8f94786ceb5e34ad50a1ddcfae26c4dce862bdb7
-	parent = f42c5f620ff9d08787090e772e3a7b15dc9ae655
+	commit = 29047504daa8f9bba574d86b8be8b6145ad86fd8
+	parent = 4773900a43385016f5f8e13aa62efb0d033d4d6f
 	method = merge
 	cmdver = 0.4.9
diff --git a/extern/luau/Analysis/include/Luau/ConstraintSolver.h b/extern/luau/Analysis/include/Luau/ConstraintSolver.h
@@ -420,6 +420,11 @@ struct ConstraintSolver
     void throwUserCancelError() const;
 
     ToStringOptions opts;
+
+    void fillInDiscriminantTypes(
+        NotNull<const Constraint> constraint,
+        const std::vector<std::optional<TypeId>>& discriminantTypes
+    );
 };
 
 void dump(NotNull<Scope> rootScope, struct ToStringOptions& opts);

diff --git a/extern/luau/Analysis/include/Luau/FragmentAutocomplete.h b/extern/luau/Analysis/include/Luau/FragmentAutocomplete.h
@@ -15,6 +15,12 @@ namespace Luau
 {
 struct FrontendOptions;
 
+enum class FragmentTypeCheckStatus
+{
+    Success,
+    SkipAutocomplete,
+};
+
 struct FragmentAutocompleteAncestryResult
 {
     DenseHashMap<AstName, AstLocal*> localMap{AstName()};
@@ -29,6 +35,7 @@ struct FragmentParseResult
     AstStatBlock* root = nullptr;
     std::vector<AstNode*> ancestry;
     AstStat* nearestStatement = nullptr;
+    std::vector<Comment> commentLocations;
     std::unique_ptr<Allocator> alloc = std::make_unique<Allocator>();
 };
 
@@ -56,7 +63,7 @@ FragmentParseResult parseFragment(
     std::optional<Position> fragmentEndPosition
 );
 
-FragmentTypeCheckResult typecheckFragment(
+std::pair<FragmentTypeCheckStatus, FragmentTypeCheckResult> typecheckFragment(
     Frontend& frontend,
     const ModuleName& moduleName,
     const Position& cursorPos,

diff --git a/extern/luau/Analysis/include/Luau/Module.h b/extern/luau/Analysis/include/Luau/Module.h
@@ -16,6 +16,8 @@
 #include <unordered_map>
 #include <optional>
 
+LUAU_FASTFLAG(LuauIncrementalAutocompleteCommentDetection)
+
 namespace Luau
 {
 
@@ -55,6 +57,7 @@ struct SourceModule
     }
 };
 
+bool isWithinComment(const std::vector<Comment>& commentLocations, Position pos);
 bool isWithinComment(const SourceModule& sourceModule, Position pos);
 bool isWithinComment(const ParseResult& result, Position pos);
 

diff --git a/extern/luau/Analysis/include/Luau/Scope.h b/extern/luau/Analysis/include/Luau/Scope.h
@@ -95,6 +95,8 @@ struct Scope
     // we need that the generic type `T` in both cases is the same, so we use a cache.
     std::unordered_map<Name, TypeId> typeAliasTypeParameters;
     std::unordered_map<Name, TypePackId> typeAliasTypePackParameters;
+
+    std::optional<std::vector<TypeId>> interiorFreeTypes;
 };
 
 // Returns true iff the left scope encloses the right scope.  A Scope* equal to

diff --git a/extern/luau/Analysis/include/Luau/Type.h b/extern/luau/Analysis/include/Luau/Type.h
@@ -626,7 +626,7 @@ struct TypeFunctionInstanceType
     std::vector<TypeId> typeArguments;
     std::vector<TypePackId> packArguments;
 
-    std::optional<AstName> userFuncName;          // Name of the user-defined type function; only available for UDTFs
+    std::optional<AstName> userFuncName; // Name of the user-defined type function; only available for UDTFs
     UserDefinedFunctionData userFuncData;
 
     TypeFunctionInstanceType(

diff --git a/extern/luau/Analysis/include/Luau/TypeFunction.h b/extern/luau/Analysis/include/Luau/TypeFunction.h
@@ -71,7 +71,7 @@ struct TypeFunctionContext
     // The constraint being reduced in this run of the reduction
     const Constraint* constraint;
 
-    std::optional<AstName> userFuncName;          // Name of the user-defined type function; only available for UDTFs
+    std::optional<AstName> userFuncName; // Name of the user-defined type function; only available for UDTFs
 
     TypeFunctionContext(NotNull<ConstraintSolver> cs, NotNull<Scope> scope, NotNull<const Constraint> constraint);
 

diff --git a/extern/luau/Analysis/include/Luau/TypeFunctionRuntime.h b/extern/luau/Analysis/include/Luau/TypeFunctionRuntime.h
@@ -119,7 +119,14 @@ struct TypeFunctionVariadicTypePack
     TypeFunctionTypeId type;
 };
 
-using TypeFunctionTypePackVariant = Variant<TypeFunctionTypePack, TypeFunctionVariadicTypePack>;
+struct TypeFunctionGenericTypePack
+{
+    bool isNamed = false;
+
+    std::string name;
+};
+
+using TypeFunctionTypePackVariant = Variant<TypeFunctionTypePack, TypeFunctionVariadicTypePack, TypeFunctionGenericTypePack>;
 
 struct TypeFunctionTypePackVar
 {
@@ -135,6 +142,9 @@ struct TypeFunctionTypePackVar
 
 struct TypeFunctionFunctionType
 {
+    std::vector<TypeFunctionTypeId> generics;
+    std::vector<TypeFunctionTypePackId> genericPacks;
+
     TypeFunctionTypePackId argTypes;
     TypeFunctionTypePackId retTypes;
 };
@@ -210,6 +220,14 @@ struct TypeFunctionClassType
     std::string name;
 };
 
+struct TypeFunctionGenericType
+{
+    bool isNamed = false;
+    bool isPack = false;
+
+    std::string name;
+};
+
 using TypeFunctionTypeVariant = Luau::Variant<
     TypeFunctionPrimitiveType,
     TypeFunctionAnyType,
@@ -221,7 +239,8 @@ using TypeFunctionTypeVariant = Luau::Variant<
     TypeFunctionNegationType,
     TypeFunctionFunctionType,
     TypeFunctionTableType,
-    TypeFunctionClassType>;
+    TypeFunctionClassType,
+    TypeFunctionGenericType>;
 
 struct TypeFunctionType
 {

diff --git a/extern/luau/Analysis/include/Luau/TypeUtils.h b/extern/luau/Analysis/include/Luau/TypeUtils.h
@@ -269,8 +269,8 @@ bool isLiteral(const AstExpr* expr);
 std::vector<TypeId> findBlockedTypesIn(AstExprTable* expr, NotNull<DenseHashMap<const AstExpr*, TypeId>> astTypes);
 
 /**
- * Given a function call and a mapping from expression to type, determine 
- * whether the type of any argument in said call in depends on a blocked types. 
+ * Given a function call and a mapping from expression to type, determine
+ * whether the type of any argument in said call in depends on a blocked types.
  * This is used as a precondition for bidirectional inference: be warned that
  * the behavior of this algorithm is tightly coupled to that of bidirectional
  * inference.
@@ -280,4 +280,13 @@ std::vector<TypeId> findBlockedTypesIn(AstExprTable* expr, NotNull<DenseHashMap<
  */
 std::vector<TypeId> findBlockedArgTypesIn(AstExprCall* expr, NotNull<DenseHashMap<const AstExpr*, TypeId>> astTypes);
 
+/**
+ * Given a scope and a free type, find the closest parent that has a present
+ * `interiorFreeTypes` and append the given type to said list. This list will
+ * be generalized when the requiste `GeneralizationConstraint` is resolved.
+ * @param scope Initial scope this free type was attached to
+ * @param ty Free type to track.
+ */
+void trackInteriorFreeType(Scope* scope, TypeId ty);
+
 } // namespace Luau
diff --git a/extern/luau/Analysis/src/AnyTypeSummary.cpp b/extern/luau/Analysis/src/AnyTypeSummary.cpp
@@ -177,7 +177,6 @@ void AnyTypeSummary::visit(const Scope* scope, AstStatReturn* ret, const Module*
             }
         }
     }
-
 }
 
 void AnyTypeSummary::visit(const Scope* scope, AstStatLocal* local, const Module* module, NotNull<BuiltinTypes> builtinTypes)

diff --git a/extern/luau/Analysis/src/AstQuery.cpp b/extern/luau/Analysis/src/AstQuery.cpp
@@ -13,8 +13,6 @@
 
 LUAU_FASTFLAG(LuauSolverV2)
 
-LUAU_FASTFLAGVARIABLE(LuauDocumentationAtPosition)
-
 namespace Luau
 {
 
@@ -518,7 +516,6 @@ static std::optional<DocumentationSymbol> getMetatableDocumentation(
     const AstName& index
 )
 {
-    LUAU_ASSERT(FFlag::LuauDocumentationAtPosition);
     auto indexIt = mtable->props.find("__index");
     if (indexIt == mtable->props.end())
         return std::nullopt;
@@ -575,26 +572,7 @@ std::optional<DocumentationSymbol> getDocumentationSymbolAtPosition(const Source
                 }
                 else if (const ClassType* ctv = get<ClassType>(parentTy))
                 {
-                    if (FFlag::LuauDocumentationAtPosition)
-                    {
-                        while (ctv)
-                        {
-                            if (auto propIt = ctv->props.find(indexName->index.value); propIt != ctv->props.end())
-                            {
-                                if (FFlag::LuauSolverV2)
-                                {
-                                    if (auto ty = propIt->second.readTy)
-                                        return checkOverloadedDocumentationSymbol(module, *ty, parentExpr, propIt->second.documentationSymbol);
-                                }
-                                else
-                                    return checkOverloadedDocumentationSymbol(
-                                        module, propIt->second.type(), parentExpr, propIt->second.documentationSymbol
-                                    );
-                            }
-                            ctv = ctv->parent ? Luau::get<Luau::ClassType>(*ctv->parent) : nullptr;
-                        }
-                    }
-                    else
+                    while (ctv)
                     {
                         if (auto propIt = ctv->props.find(indexName->index.value); propIt != ctv->props.end())
                         {
@@ -608,17 +586,15 @@ std::optional<DocumentationSymbol> getDocumentationSymbolAtPosition(const Source
                                     module, propIt->second.type(), parentExpr, propIt->second.documentationSymbol
                                 );
                         }
+                        ctv = ctv->parent ? Luau::get<Luau::ClassType>(*ctv->parent) : nullptr;
                     }
                 }
-                else if (FFlag::LuauDocumentationAtPosition)
+                else if (const PrimitiveType* ptv = get<PrimitiveType>(parentTy); ptv && ptv->metatable)
                 {
-                    if (const PrimitiveType* ptv = get<PrimitiveType>(parentTy); ptv && ptv->metatable)
+                    if (auto mtable = get<TableType>(*ptv->metatable))
                     {
-                        if (auto mtable = get<TableType>(*ptv->metatable))
-                        {
-                            if (std::optional<std::string> docSymbol = getMetatableDocumentation(module, parentExpr, mtable, indexName->index))
-                                return docSymbol;
-                        }
+                        if (std::optional<std::string> docSymbol = getMetatableDocumentation(module, parentExpr, mtable, indexName->index))
+                            return docSymbol;
                     }
                 }
             }

diff --git a/extern/luau/Analysis/src/AutocompleteCore.cpp b/extern/luau/Analysis/src/AutocompleteCore.cpp
@@ -25,6 +25,7 @@ LUAU_FASTINT(LuauTypeInferIterationLimit)
 LUAU_FASTINT(LuauTypeInferRecursionLimit)
 
 LUAU_FASTFLAGVARIABLE(LuauAutocompleteRefactorsForIncrementalAutocomplete)
+LUAU_FASTFLAGVARIABLE(LuauAutocompleteUseLimits)
 
 static const std::unordered_set<std::string> kStatementStartingKeywords =
     {"while", "if", "local", "repeat", "function", "do", "for", "return", "break", "continue", "type", "export"};
@@ -177,6 +178,12 @@ static bool checkTypeMatch(TypeId subTy, TypeId superTy, NotNull<Scope> scope, T
         unifier.normalize = false;
         unifier.checkInhabited = false;
 
+        if (FFlag::LuauAutocompleteUseLimits)
+        {
+            unifierState.counters.recursionLimit = FInt::LuauTypeInferRecursionLimit;
+            unifierState.counters.iterationLimit = FInt::LuauTypeInferIterationLimit;
+        }
+
         return unifier.canUnify(subTy, superTy).empty();
     }
 }

diff --git a/extern/luau/Analysis/src/BuiltinDefinitions.cpp b/extern/luau/Analysis/src/BuiltinDefinitions.cpp
@@ -31,6 +31,7 @@
 LUAU_FASTFLAG(LuauSolverV2)
 LUAU_FASTFLAGVARIABLE(LuauTypestateBuiltins2)
 LUAU_FASTFLAGVARIABLE(LuauStringFormatArityFix)
+LUAU_FASTFLAGVARIABLE(LuauStringFormatErrorSuppression)
 LUAU_FASTFLAG(AutocompleteRequirePathSuggestions2)
 LUAU_FASTFLAG(LuauVectorDefinitionsExtra)
 
@@ -611,7 +612,9 @@ static void dcrMagicFunctionTypeCheckFormat(MagicFunctionTypeCheckContext contex
     if (!fmt)
     {
         if (FFlag::LuauStringFormatArityFix)
-            context.typechecker->reportError(CountMismatch{1, std::nullopt, 0, CountMismatch::Arg, true, "string.format"}, context.callSite->location);
+            context.typechecker->reportError(
+                CountMismatch{1, std::nullopt, 0, CountMismatch::Arg, true, "string.format"}, context.callSite->location
+            );
         return;
     }
 
@@ -629,10 +632,29 @@ static void dcrMagicFunctionTypeCheckFormat(MagicFunctionTypeCheckContext contex
         Location location = context.callSite->args.data[i + (calledWithSelf ? 0 : paramOffset)]->location;
         // use subtyping instead here
         SubtypingResult result = context.typechecker->subtyping->isSubtype(actualTy, expectedTy, context.checkScope);
+
         if (!result.isSubtype)
         {
-            Reasonings reasonings = context.typechecker->explainReasonings(actualTy, expectedTy, location, result);
-            context.typechecker->reportError(TypeMismatch{expectedTy, actualTy, reasonings.toString()}, location);
+            if (FFlag::LuauStringFormatErrorSuppression)
+            {
+                switch (shouldSuppressErrors(NotNull{&context.typechecker->normalizer}, actualTy))
+                {
+                    case ErrorSuppression::Suppress:
+                        break;
+                    case ErrorSuppression::NormalizationFailed:
+                        break;
+                    case ErrorSuppression::DoNotSuppress:
+                        Reasonings reasonings = context.typechecker->explainReasonings(actualTy, expectedTy, location, result);
+
+                        if (!reasonings.suppressed)
+                            context.typechecker->reportError(TypeMismatch{expectedTy, actualTy, reasonings.toString()}, location);
+                }
+            }
+            else
+            {
+                Reasonings reasonings = context.typechecker->explainReasonings(actualTy, expectedTy, location, result);
+                context.typechecker->reportError(TypeMismatch{expectedTy, actualTy, reasonings.toString()}, location);
+            }
         }
     }
 }

diff --git a/extern/luau/Analysis/src/Constraint.cpp b/extern/luau/Analysis/src/Constraint.cpp
@@ -62,7 +62,6 @@ struct ReferenceCountInitializer : TypeOnceVisitor
         // of this type, hence:
         return !FFlag::LuauDontRefCountTypesInTypeFunctions;
     }
-
 };
 
 bool isReferenceCountedType(const TypeId typ)
-Original file line number
+Diff line change
@@ Expand Up @@
                 }
             }
         }
     }
     void AnyTypeSummary::visit(const Scope* scope, AstStatLocal* local, const Module* module, NotNull<BuiltinTypes> builtinTypes)
@@ Expand Down @@