Fix "Subtyping test returned a reasoning with an invalid path" for mismatches with negations of unions and intersections

Analysis/src/Subtyping.cpp

@@ -31,6 +31,7 @@ LUAU_FASTFLAGVARIABLE(LuauDropUnionSubtypeReasoning)
 LUAU_FASTFLAGVARIABLE(LuauDontBindOptionalGenericToNil)
 LUAU_FASTFLAGVARIABLE(LuauImproveUniqueTableWidthSubtyping)
 LUAU_FASTFLAG(LuauBidirectionalInferenceSimplifyTables)
+LUAU_FASTFLAGVARIABLE(LuauNegationsFixSubtypePath)
 
 namespace Luau
 {
@@ -1836,6 +1837,7 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, const Type
     TypeId negatedTy = follow(superNegation->ty);
 
     SubtypingResult result;
+    bool moved = false;
 
     if (is<NeverType>(negatedTy))
     {
@@ -1867,6 +1869,7 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, const Type
             {
                 NegationType negatedTmp{ty};
                 result.andAlso(isCovariantWith(env, subTy, &negatedTmp, scope));
+                moved = true;
             }
         }
     }
@@ -1884,6 +1887,7 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, const Type
             {
                 NegationType negatedTmp{ty};
                 result.orElse(isCovariantWith(env, subTy, &negatedTmp, scope));
+                moved = true;
             }
         }
     }
@@ -1933,7 +1937,10 @@ SubtypingResult Subtyping::isCovariantWith(SubtypingEnvironment& env, const Type
     else
         result = {false};
 
-    return result.withSuperComponent(TypePath::TypeField::Negated);
+    if (FFlag::LuauNegationsFixSubtypePath && moved)
+        return result;
+    else
+        return result.withSuperComponent(TypePath::TypeField::Negated);
 }
 
 SubtypingResult Subtyping::isCovariantWith(

Analysis/src/TypeChecker2.cpp

@@ -40,6 +40,7 @@ LUAU_FASTFLAG(LuauTweakAccessViolationReporting)
 LUAU_FASTFLAG(LuauReadOnlyIndexers)
 LUAU_FASTFLAG(LuauImproveUniqueTableWidthSubtyping)
 LUAU_FASTFLAG(LuauBidirectionalInferenceSimplifyTables)
+LUAU_FASTFLAG(LuauNegationsFixSubtypePath)
 
 LUAU_FASTFLAG(DebugLuauUserDefinedClasses)
 
@@ -3028,7 +3029,6 @@ Reasonings TypeChecker2::explainReasonings_(TID subTy, TID superTy, Location loc
             continue;
 
         std::optional<TypeOrPack> optSubLeaf = traverse(subTy, reasoning.subPath, builtinTypes, subtyping->arena);
-
         std::optional<TypeOrPack> optSuperLeaf = traverse(superTy, reasoning.superPath, builtinTypes, subtyping->arena);
 
         if (!optSubLeaf || !optSuperLeaf)
@@ -3064,6 +3064,25 @@ Reasonings TypeChecker2::explainReasonings_(TID subTy, TID superTy, Location loc
             subLeafAsString = "()";
 
         std::string superLeafAsString = toString(superLeaf);
+        if (FFlag::LuauNegationsFixSubtypePath && !reasoning.superPath.components.empty())
+        {
+            // If we don't do this, we get "`number` is not a subtype of `number`" etc in our error messages
+            if (const TypePath::TypeField* tf = get_if<TypePath::TypeField>(&reasoning.superPath.components.back()); tf && *tf == TypePath::TypeField::Negated)
+            {
+                Path clippedPath = reasoning.superPath.pop();
+                std::optional<TypeOrPack> optNegationLeaf = traverse(superTy, clippedPath, builtinTypes, subtyping->arena);
+
+                if (optNegationLeaf)
+                {
+                    const TypeOrPack& negationLeaf = *optNegationLeaf;
+                    auto negationLeafTy = get<TypeId>(negationLeaf);
+
+                    if (negationLeafTy)
+                        superLeafAsString = toString(negationLeaf);
+                }
+            }
+        }
+
         // if the string is empty, it must be an empty type pack
         if (superLeafAsString.empty())
             superLeafAsString = "()";

tests/TypeInfer.negations.test.cpp

@@ -7,6 +7,8 @@
 #include "Luau/Common.h"
 #include "ScopedFlags.h"
 
+LUAU_FASTFLAG(LuauNegationsFixSubtypePath)
+
 using namespace Luau;
 
 namespace
@@ -77,4 +79,38 @@ end
     LUAU_REQUIRE_NO_ERRORS(result);
 }
 
+TEST_CASE_FIXTURE(NegationFixture, "subtype_path_is_valid_for_unions")
+{
+    ScopedFastFlag fixSubtypePath{FFlag::LuauNegationsFixSubtypePath, true};
+
+    CheckResult result = check(R"(
+        type T = Not<false?>
+        local x: T = false :: false
+    )");
+
+    LUAU_REQUIRE_ERROR_COUNT(1, result);
+    CHECK_EQ(
+        "Expected this to be '~(false?)', but got 'false'; \n"
+            "the negation `~(false?)`, and `false` is not a subtype of `~(false?)`",
+        toString(result.errors[0])
+    );
+}
+
+TEST_CASE_FIXTURE(NegationFixture, "subtype_path_is_valid_for_intersections")
+{
+    ScopedFastFlag fixSubtypePath{FFlag::LuauNegationsFixSubtypePath, true};
+
+    CheckResult result = check(R"(
+        type T = Not<unknown & boolean>
+        local x: T = false
+    )");
+
+    LUAU_REQUIRE_ERROR_COUNT(1, result);
+    CHECK_EQ(
+        "Expected this to be '~(boolean & unknown)', but got 'boolean'; \n"
+            "the negation `~(boolean & unknown)`, and `boolean` is not a subtype of `~(boolean & unknown)`",
+        toString(result.errors[0])
+    );
+}
+
 TEST_SUITE_END();