Sync to upstream/release/691 (#1998)

# New Type Solver
* Fixed #1983 by adding
additional context to permit some expressions otherwise not allowed
* We now skip issuing CheckedFunctionWarnings on use of unreduced type
functions
* Fix gcc compile error
* Handle expressions `a == b` and `a ~= b` more efficiently  
* Subtyping now correctly handles generics over unions and intersections
in cases such as
```
local function a<T>(arr: { T }) end

a({ 'one', 'two' })
```
* Rearrange unification cases to avoid free type generalization to never
* Improve generic bounds mismatch error message
* Fix Ancestry bug in visitor for incomplete repeat blocks such as
```
local t = {}
function t:Foo() end

repeat
  t:|
  ```
*  Support autocomplete for attributes

# Native Codegen
* Unwind info has support on Android
* Introduced a separate ctypeof function which does not constant-fold for vector arguments.
* We now perform string concatenation at compile time if possible (there is a known issue with the optimization that we will address next week)
* Make vector.lerp and math.lerp more efficient with FMA
* Record STORE_SPLIT_TVALUE as a potential restore operation to reduce number of spills to stack 
* When native execution is disabled, we now mark the call frame as not executing natively, making resumption safer

--- 
Co-authored-by: Andy Friesen <[email protected]>
Co-authored-by: Annie Tang <[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]>
Co-authored-by: Vighnesh Vijay <[email protected]>
Co-authored-by: Vyacheslav Egorov <[email protected]>

---------

Co-authored-by: Hunter Goldstein <[email protected]>
Co-authored-by: Varun Saini <[email protected]>
Co-authored-by: Alexander Youngblood <[email protected]>
Co-authored-by: Aviral Goel <[email protected]>
Co-authored-by: Vighnesh <[email protected]>
Co-authored-by: Vyacheslav Egorov <[email protected]>
Co-authored-by: Ariel Weiss <[email protected]>
Co-authored-by: Andy Friesen <[email protected]>

Author: 9 people

Analysis/include/Luau/ConstraintSolver.h

@@ -178,6 +178,7 @@ struct ConstraintSolver
         ConstraintSet constraintSet
     );
 
+    // TODO CLI-169086: Replace all uses of this constructor with the ConstraintSet constructor, above.
     explicit ConstraintSolver(
         NotNull<Normalizer> normalizer,
         NotNull<Simplifier> simplifier,

Analysis/include/Luau/Error.h

@@ -87,6 +87,15 @@ struct CannotExtendTable
     bool operator==(const CannotExtendTable& rhs) const;
 };
 
+struct CannotCompareUnrelatedTypes
+{
+    TypeId left;
+    TypeId right;
+    AstExprBinary::Op op;
+
+    bool operator==(const CannotCompareUnrelatedTypes& rhs) const;
+};
+
 struct OnlyTablesCanHaveMethods
 {
     TypeId tableType;
@@ -547,6 +556,7 @@ using TypeErrorData = Variant<
     UnknownProperty,
     NotATable,
     CannotExtendTable,
+    CannotCompareUnrelatedTypes,
     OnlyTablesCanHaveMethods,
     DuplicateTypeDefinition,
     CountMismatch,

Analysis/include/Luau/IostreamHelpers.h

@@ -22,6 +22,7 @@ std::ostream& operator<<(std::ostream& lhs, const UnknownSymbol& error);
 std::ostream& operator<<(std::ostream& lhs, const UnknownProperty& error);
 std::ostream& operator<<(std::ostream& lhs, const NotATable& error);
 std::ostream& operator<<(std::ostream& lhs, const CannotExtendTable& error);
+std::ostream& operator<<(std::ostream& lhs, const CannotCompareUnrelatedTypes& error);
 std::ostream& operator<<(std::ostream& lhs, const OnlyTablesCanHaveMethods& error);
 std::ostream& operator<<(std::ostream& lhs, const DuplicateTypeDefinition& error);
 std::ostream& operator<<(std::ostream& lhs, const CountMismatch& error);

Analysis/include/Luau/Normalize.h

@@ -281,6 +281,9 @@ struct NormalizedType
     /// Returns true if this type contains the primitve top table type, `table`.
     bool hasTopTable() const;
 
+    /// Returns true if this type is `nil` or `nil | *error-type*`
+    bool isNil() const;
+
     // Helpers that improve readability of the above (they just say if the component is present)
     bool hasTops() const;
     bool hasBooleans() const;

Analysis/include/Luau/VisitType.h

@@ -10,8 +10,6 @@
 #include "Type.h"
 
 LUAU_FASTINT(LuauVisitRecursionLimit)
-LUAU_FASTFLAG(LuauSolverV2)
-LUAU_FASTFLAG(LuauSolverAgnosticVisitType)
 LUAU_FASTFLAG(LuauReduceSetTypeStackPressure)
 
 namespace Luau
@@ -261,37 +259,16 @@ struct GenericTypeVisitor
         }
         else if (auto ftv = get<FreeType>(ty))
         {
-            if (FFlag::LuauSolverAgnosticVisitType)
+            if (visit(ty, *ftv))
             {
-                if (visit(ty, *ftv))
-                {
-                    // Regardless of the choice of solver, all free types are guaranteed to have
-                    // lower and upper bounds
-                    LUAU_ASSERT(ftv->lowerBound);
-                    LUAU_ASSERT(ftv->upperBound);
+                // Regardless of the choice of solver, all free types are guaranteed to have
+                // lower and upper bounds
+                LUAU_ASSERT(ftv->lowerBound);
+                LUAU_ASSERT(ftv->upperBound);
 
-                    traverse(ftv->lowerBound);
-                    traverse(ftv->upperBound);
-                }
-            }
-            else if (FFlag::LuauSolverV2)
-            {
-                if (visit(ty, *ftv))
-                {
-                    // TODO: Replace these if statements with assert()s when we
-                    // delete FFlag::LuauSolverV2.
-                    //
-                    // When the old solver is used, these pointers are always
-                    // unused. When the new solver is used, they are never null.
-                    if (ftv->lowerBound)
-                        traverse(ftv->lowerBound);
-
-                    if (ftv->upperBound)
-                        traverse(ftv->upperBound);
-                }
+                traverse(ftv->lowerBound);
+                traverse(ftv->upperBound);
             }
-            else
-                visit(ty, *ftv);
         }
         else if (auto gtv = get<GenericType>(ty))
             visit(ty, *gtv);
@@ -324,20 +301,15 @@ struct GenericTypeVisitor
                 {
                     for (auto& [_name, prop] : ttv->props)
                     {
-                        if (FFlag::LuauSolverV2 || FFlag::LuauSolverAgnosticVisitType)
-                        {
-                            if (auto ty = prop.readTy)
-                                traverse(*ty);
-
-                            // In the case that the readType and the writeType
-                            // are the same pointer, just traverse once.
-                            // Traversing each property twice has pretty
-                            // significant performance consequences.
-                            if (auto ty = prop.writeTy; ty && !prop.isShared())
-                                traverse(*ty);
-                        }
-                        else
-                            traverse(prop.type_DEPRECATED());
+                        if (auto ty = prop.readTy)
+                            traverse(*ty);
+
+                        // In the case that the readType and the writeType
+                        // are the same pointer, just traverse once.
+                        // Traversing each property twice has pretty
+                        // significant performance consequences.
+                        if (auto ty = prop.writeTy; ty && !prop.isShared())
+                            traverse(*ty);
                     }
 
                     if (ttv->indexer)
@@ -362,20 +334,15 @@ struct GenericTypeVisitor
             {
                 for (const auto& [name, prop] : etv->props)
                 {
-                    if (FFlag::LuauSolverV2 || FFlag::LuauSolverAgnosticVisitType)
-                    {
-                        if (auto ty = prop.readTy)
-                            traverse(*ty);
-
-                        // In the case that the readType and the writeType are
-                        // the same pointer, just traverse once. Traversing each
-                        // property twice would have pretty significant
-                        // performance consequences.
-                        if (auto ty = prop.writeTy; ty && !prop.isShared())
-                            traverse(*ty);
-                    }
-                    else
-                        traverse(prop.type_DEPRECATED());
+                    if (auto ty = prop.readTy)
+                        traverse(*ty);
+                    
+                    // In the case that the readType and the writeType are
+                    // the same pointer, just traverse once. Traversing each
+                    // property twice would have pretty significant
+                    // performance consequences.
+                    if (auto ty = prop.writeTy; ty && !prop.isShared())
+                        traverse(*ty);
                 }
 
                 if (etv->parent)

Analysis/src/AstJsonEncoder.cpp

@@ -8,6 +8,8 @@
 
 #include <math.h>
 
+LUAU_FASTFLAG(LuauAutocompleteAttributes)
+
 namespace Luau
 {
 
@@ -1153,6 +1155,8 @@ struct AstJsonEncoder : public AstVisitor
             return writeString("native");
         case AstAttr::Type::Deprecated:
             return writeString("deprecated");
+        case AstAttr::Type::Unknown:
+            return writeString("unknown");
         }
     }
 
@@ -1163,7 +1167,10 @@ struct AstJsonEncoder : public AstVisitor
             "AstAttr",
             [&]()
             {
-                write("name", node->type);
+                if (FFlag::LuauAutocompleteAttributes)
+                    write("name", node->name);
+                else
+                    write("name", node->type);
             }
         );
     }

Analysis/src/AstQuery.cpp

@@ -12,6 +12,7 @@
 #include <algorithm>
 
 LUAU_FASTFLAG(LuauSolverV2)
+LUAU_FASTFLAGVARIABLE(LuauUnfinishedRepeatAncestryFix)
 
 namespace Luau
 {
@@ -31,10 +32,22 @@ struct AutocompleteNodeFinder : public AstVisitor
 
     bool visit(AstExpr* expr) override
     {
-        if (expr->location.begin <= pos && pos <= expr->location.end)
+        if (FFlag::LuauUnfinishedRepeatAncestryFix)
         {
-            ancestry.push_back(expr);
-            return true;
+            // 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;
+            }
         }
         return false;
     }

Analysis/src/AutocompleteCore.cpp

@@ -27,15 +27,17 @@ LUAU_FASTFLAG(LuauSolverV2)
 LUAU_FASTINT(LuauTypeInferIterationLimit)
 LUAU_FASTINT(LuauTypeInferRecursionLimit)
 LUAU_FASTFLAGVARIABLE(DebugLuauMagicVariableNames)
-LUAU_FASTFLAG(LuauImplicitTableIndexerKeys3)
 LUAU_FASTFLAGVARIABLE(LuauIncludeBreakContinueStatements)
 LUAU_FASTFLAGVARIABLE(LuauSuggestHotComments)
+LUAU_FASTFLAG(LuauAutocompleteAttributes)
 
 static constexpr std::array<std::string_view, 12> kStatementStartingKeywords =
     {"while", "if", "local", "repeat", "function", "do", "for", "return", "break", "continue", "type", "export"};
 
 static constexpr std::array<std::string_view, 6> kHotComments = {"nolint", "nocheck", "nonstrict", "strict", "optimize", "native"};
 
+static const std::string kKnownAttributes[] = {"checked", "deprecated", "native"};
+
 namespace Luau
 {
 
@@ -582,39 +584,21 @@ static void autocompleteStringSingleton(TypeId ty, bool addQuotes, AstNode* node
 
     ty = follow(ty);
 
-    if (FFlag::LuauImplicitTableIndexerKeys3)
+    if (auto ss = get<StringSingleton>(get<SingletonType>(ty)))
     {
-        if (auto ss = get<StringSingleton>(get<SingletonType>(ty)))
-        {
-            // This is purposefully `try_emplace` as we don't want to override any existing entries.
-            result.try_emplace(formatKey(ss->value), AutocompleteEntry{AutocompleteEntryKind::String, ty, false, false, TypeCorrectKind::Correct});
-        }
-        else if (auto uty = get<UnionType>(ty))
-        {
-            for (auto el : uty)
-            {
-                if (auto ss = get<StringSingleton>(get<SingletonType>(el)))
-                {
-                    // This is purposefully `try_emplace` as we don't want to override any existing entries.
-                    result.try_emplace(
-                        formatKey(ss->value), AutocompleteEntry{AutocompleteEntryKind::String, ty, false, false, TypeCorrectKind::Correct}
-                    );
-                }
-            }
-        }
+        // This is purposefully `try_emplace` as we don't want to override any existing entries.
+        result.try_emplace(formatKey(ss->value), AutocompleteEntry{AutocompleteEntryKind::String, ty, false, false, TypeCorrectKind::Correct});
     }
-    else
+    else if (auto uty = get<UnionType>(ty))
     {
-        if (auto ss = get<StringSingleton>(get<SingletonType>(ty)))
+        for (auto el : uty)
         {
-            result[formatKey(ss->value)] = AutocompleteEntry{AutocompleteEntryKind::String, ty, false, false, TypeCorrectKind::Correct};
-        }
-        else if (auto uty = get<UnionType>(ty))
-        {
-            for (auto el : uty)
+            if (auto ss = get<StringSingleton>(get<SingletonType>(el)))
             {
-                if (auto ss = get<StringSingleton>(get<SingletonType>(el)))
-                    result[formatKey(ss->value)] = AutocompleteEntry{AutocompleteEntryKind::String, ty, false, false, TypeCorrectKind::Correct};
+                // This is purposefully `try_emplace` as we don't want to override any existing entries.
+                result.try_emplace(
+                    formatKey(ss->value), AutocompleteEntry{AutocompleteEntryKind::String, ty, false, false, TypeCorrectKind::Correct}
+                );
             }
         }
     }
@@ -2105,12 +2089,6 @@ AutocompleteResult autocomplete_(
     {
         AutocompleteEntryMap result;
 
-        if (!FFlag::LuauImplicitTableIndexerKeys3)
-        {
-            if (auto it = module->astExpectedTypes.find(node->asExpr()))
-                autocompleteStringSingleton(*it, false, node, position, result);
-        }
-
         if (ancestry.size() >= 2)
         {
             if (auto idxExpr = ancestry.at(ancestry.size() - 2)->as<AstExprIndexExpr>())
@@ -2128,11 +2106,8 @@ AutocompleteResult autocomplete_(
             }
         }
 
-        if (FFlag::LuauImplicitTableIndexerKeys3)
-        {
-            if (auto it = module->astExpectedTypes.find(node->asExpr()))
-                autocompleteStringSingleton(*it, false, node, position, result);
-        }
+        if (auto it = module->astExpectedTypes.find(node->asExpr()))
+            autocompleteStringSingleton(*it, false, node, position, result);
 
         return {std::move(result), ancestry, AutocompleteContext::String};
     }
@@ -2143,6 +2118,22 @@ AutocompleteResult autocomplete_(
         AutocompleteEntryMap map;
         return {std::move(map), ancestry, AutocompleteContext::String};
     }
+    else if (AstExprFunction* func = node->as<AstExprFunction>())
+    {
+        if (FFlag::LuauAutocompleteAttributes)
+        {
+            for (AstAttr* attr : func->attributes)
+            {
+                if (attr->location.begin <= position && position <= attr->location.end && attr->type == AstAttr::Type::Unknown)
+                {
+                    AutocompleteEntryMap ret;
+                    for (const auto& attr : kKnownAttributes)
+                        ret[attr.c_str()] = {AutocompleteEntryKind::Keyword};
+                    return {std::move(ret), std::move(ancestry), AutocompleteContext::Keyword};
+                }
+            }
+        }
+    }
 
     if (node->is<AstExprConstantNumber>())
         return {};

Analysis/src/BuiltinDefinitions.cpp

@@ -32,7 +32,6 @@
  */
 
 LUAU_FASTFLAG(LuauSolverV2)
-LUAU_FASTFLAG(LuauEagerGeneralization4)
 LUAU_FASTFLAGVARIABLE(LuauTableCloneClonesType3)
 LUAU_FASTFLAG(LuauUseWorkspacePropToChooseSolver)
 LUAU_FASTFLAG(LuauEmplaceNotPushBack)
@@ -367,9 +366,7 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
 
     TypeArena& arena = globals.globalTypes;
     NotNull<BuiltinTypes> builtinTypes = globals.builtinTypes;
-    Scope* globalScope = nullptr; // NotNull<Scope> when removing FFlag::LuauEagerGeneralization4
-    if (FFlag::LuauEagerGeneralization4)
-        globalScope = globals.globalScope.get();
+    NotNull<Scope> globalScope{globals.globalScope.get()};
 
     if (frontend.getLuauSolverMode() == SolverMode::New)
         builtinTypeFunctions().addToScope(NotNull{&arena}, NotNull{globals.globalScope.get()});
@@ -513,12 +510,10 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
             TypePackId thePack = arena.addTypePack({genericTy});
             TypeId idTyWithMagic = arena.addType(FunctionType{{genericTy}, {}, thePack, thePack});
             ttv->props["freeze"] = makeProperty(idTyWithMagic, "@luau/global/table.freeze");
-            if (globalScope)
-                inferGenericPolarities(NotNull{&globals.globalTypes}, NotNull{globalScope}, idTyWithMagic);
+            inferGenericPolarities(NotNull{&globals.globalTypes}, NotNull{globalScope}, idTyWithMagic);
 
             TypeId idTy = arena.addType(FunctionType{{genericTy}, {}, thePack, thePack});
-            if (globalScope)
-                inferGenericPolarities(NotNull{&globals.globalTypes}, NotNull{globalScope}, idTy);
+            inferGenericPolarities(NotNull{&globals.globalTypes}, NotNull{globalScope}, idTy);
             ttv->props["clone"] = makeProperty(idTy, "@luau/global/table.clone");
         }
         else