diff --git a/Analysis/include/Luau/Constraint.h b/Analysis/include/Luau/Constraint.h
index 4370d0cf..16a08e87 100644
--- a/Analysis/include/Luau/Constraint.h
+++ b/Analysis/include/Luau/Constraint.h
@@ -132,6 +132,23 @@ struct HasPropConstraint
     std::string prop;
 };
 
+// result ~ setProp subjectType ["prop", "prop2", ...] propType
+//
+// If the subject is a table or table-like thing that already has the named
+// property chain, we unify propType with that existing property type.
+//
+// If the subject is a free table, we augment it in place.
+//
+// If the subject is an unsealed table, result is an augmented table that
+// includes that new prop.
+struct SetPropConstraint
+{
+    TypeId resultType;
+    TypeId subjectType;
+    std::vector<std::string> path;
+    TypeId propType;
+};
+
 // result ~ if isSingleton D then ~D else unknown where D = discriminantType
 struct SingletonOrTopTypeConstraint
 {
@@ -141,7 +158,7 @@ struct SingletonOrTopTypeConstraint
 
 using ConstraintV = Variant<SubtypeConstraint, PackSubtypeConstraint, GeneralizationConstraint, InstantiationConstraint, UnaryConstraint,
     BinaryConstraint, IterableConstraint, NameConstraint, TypeAliasExpansionConstraint, FunctionCallConstraint, PrimitiveTypeConstraint,
-    HasPropConstraint, SingletonOrTopTypeConstraint>;
+    HasPropConstraint, SetPropConstraint, SingletonOrTopTypeConstraint>;
 
 struct Constraint
 {
diff --git a/Analysis/include/Luau/ConstraintSolver.h b/Analysis/include/Luau/ConstraintSolver.h
index 7b89a278..e05f6f1f 100644
--- a/Analysis/include/Luau/ConstraintSolver.h
+++ b/Analysis/include/Luau/ConstraintSolver.h
@@ -110,6 +110,7 @@ struct ConstraintSolver
     bool tryDispatch(const FunctionCallConstraint& c, NotNull<const Constraint> constraint);
     bool tryDispatch(const PrimitiveTypeConstraint& c, NotNull<const Constraint> constraint);
     bool tryDispatch(const HasPropConstraint& c, NotNull<const Constraint> constraint);
+    bool tryDispatch(const SetPropConstraint& c, NotNull<const Constraint> constraint);
     bool tryDispatch(const SingletonOrTopTypeConstraint& c, NotNull<const Constraint> constraint);
 
     // for a, ... in some_table do
@@ -120,6 +121,8 @@ struct ConstraintSolver
     bool tryDispatchIterableFunction(
         TypeId nextTy, TypeId tableTy, TypeId firstIndexTy, const IterableConstraint& c, NotNull<const Constraint> constraint, bool force);
 
+    std::optional<TypeId> lookupTableProp(TypeId subjectType, const std::string& propName);
+
     void block(NotNull<const Constraint> target, NotNull<const Constraint> constraint);
     /**
      * Block a constraint on the resolution of a TypeVar.
diff --git a/Analysis/src/Autocomplete.cpp b/Analysis/src/Autocomplete.cpp
index 224e9440..50dc254f 100644
--- a/Analysis/src/Autocomplete.cpp
+++ b/Analysis/src/Autocomplete.cpp
@@ -1219,6 +1219,31 @@ static std::optional<const ClassTypeVar*> getMethodContainingClass(const ModuleP
     return std::nullopt;
 }
 
+static bool stringPartOfInterpString(const AstNode* node, Position position)
+{
+    const AstExprInterpString* interpString = node->as<AstExprInterpString>();
+    if (!interpString)
+    {
+        return false;
+    }
+
+    for (const AstExpr* expression : interpString->expressions)
+    {
+        if (expression->location.containsClosed(position))
+        {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+static bool isSimpleInterpolatedString(const AstNode* node)
+{
+    const AstExprInterpString* interpString = node->as<AstExprInterpString>();
+    return interpString != nullptr && interpString->expressions.size == 0;
+}
+
 static std::optional<AutocompleteEntryMap> autocompleteStringParams(const SourceModule& sourceModule, const ModulePtr& module,
     const std::vector<AstNode*>& nodes, Position position, StringCompletionCallback callback)
 {
@@ -1227,7 +1252,7 @@ static std::optional<AutocompleteEntryMap> autocompleteStringParams(const Source
         return std::nullopt;
     }
 
-    if (!nodes.back()->is<AstExprConstantString>() && !nodes.back()->is<AstExprError>())
+    if (!nodes.back()->is<AstExprConstantString>() && !isSimpleInterpolatedString(nodes.back()) && !nodes.back()->is<AstExprError>())
     {
         return std::nullopt;
     }
@@ -1432,7 +1457,7 @@ static AutocompleteResult autocomplete(const SourceModule& sourceModule, const M
         return autocompleteExpression(sourceModule, *module, singletonTypes, &typeArena, ancestry, position);
     else if (AstStatRepeat* statRepeat = extractStat<AstStatRepeat>(ancestry); statRepeat)
         return {autocompleteStatement(sourceModule, *module, ancestry, position), ancestry, AutocompleteContext::Statement};
-    else if (AstExprTable* exprTable = parent->as<AstExprTable>(); exprTable && (node->is<AstExprGlobal>() || node->is<AstExprConstantString>()))
+    else if (AstExprTable* exprTable = parent->as<AstExprTable>(); exprTable && (node->is<AstExprGlobal>() || node->is<AstExprConstantString>() || node->is<AstExprInterpString>()))
     {
         for (const auto& [kind, key, value] : exprTable->items)
         {
@@ -1471,7 +1496,7 @@ static AutocompleteResult autocomplete(const SourceModule& sourceModule, const M
     {
         return {*ret, ancestry, AutocompleteContext::String};
     }
-    else if (node->is<AstExprConstantString>())
+    else if (node->is<AstExprConstantString>() || isSimpleInterpolatedString(node))
     {
         AutocompleteEntryMap result;
 
@@ -1497,6 +1522,13 @@ static AutocompleteResult autocomplete(const SourceModule& sourceModule, const M
 
         return {result, ancestry, AutocompleteContext::String};
     }
+    else if (stringPartOfInterpString(node, position))
+    {
+        // We're not a simple interpolated string, we're something like `a{"b"}@1`, and we
+        // can't know what to format to
+        AutocompleteEntryMap map;
+        return {map, ancestry, AutocompleteContext::String};
+    }
 
     if (node->is<AstExprConstantNumber>())
         return {};
diff --git a/Analysis/src/ConstraintGraphBuilder.cpp b/Analysis/src/ConstraintGraphBuilder.cpp
index 42dc07f6..e3572fe8 100644
--- a/Analysis/src/ConstraintGraphBuilder.cpp
+++ b/Analysis/src/ConstraintGraphBuilder.cpp
@@ -11,6 +11,7 @@
 #include "Luau/Scope.h"
 #include "Luau/ToString.h"
 #include "Luau/TypeUtils.h"
+#include "Luau/TypeVar.h"
 
 LUAU_FASTINT(LuauCheckRecursionLimit);
 LUAU_FASTFLAG(DebugLuauLogSolverToJson);
@@ -1019,7 +1020,22 @@ InferencePack ConstraintGraphBuilder::checkPack(const ScopePtr& scope, AstExprCa
         args.push_back(check(scope, arg).ty);
     }
 
-    // TODO self
+    if (call->self)
+    {
+        AstExprIndexName* indexExpr = call->func->as<AstExprIndexName>();
+        if (!indexExpr)
+            ice->ice("method call expression has no 'self'");
+
+        // The call to `check` we already did on `call->func` should have already produced a type for
+        // `indexExpr->expr`, so we can get it from `astTypes` to avoid exponential blow-up.
+        TypeId selfType = astTypes[indexExpr->expr];
+
+        // If we don't have a type for self, it means we had a code too complex error already.
+        if (selfType == nullptr)
+            selfType = singletonTypes->errorRecoveryType();
+
+        args.insert(args.begin(), selfType);
+    }
 
     if (matchSetmetatable(*call))
     {
@@ -1428,13 +1444,6 @@ TypePackId ConstraintGraphBuilder::checkLValues(const ScopePtr& scope, AstArray<
     return arena->addTypePack(std::move(types));
 }
 
-static bool isUnsealedTable(TypeId ty)
-{
-    ty = follow(ty);
-    const TableTypeVar* ttv = get<TableTypeVar>(ty);
-    return ttv && ttv->state == TableState::Unsealed;
-};
-
 /**
  * If the expr is a dotted set of names, and if the root symbol refers to an
  * unsealed table, return that table type, plus the indeces that follow as a
@@ -1468,80 +1477,6 @@ static std::optional<std::pair<Symbol, std::vector<const char*>>> extractDottedN
     return std::nullopt;
 }
 
-/**
- * Create a shallow copy of `ty` and its properties along `path`.  Insert a new
- * property (the last segment of `path`) into the tail table with the value `t`.
- *
- * On success, returns the new outermost table type.  If the root table or any
- * of its subkeys are not unsealed tables, the function fails and returns
- * std::nullopt.
- *
- * TODO: Prove that we completely give up in the face of indexers and
- * metatables.
- */
-static std::optional<TypeId> updateTheTableType(NotNull<TypeArena> arena, TypeId ty, const std::vector<const char*>& path, TypeId replaceTy)
-{
-    if (path.empty())
-        return std::nullopt;
-
-    // First walk the path and ensure that it's unsealed tables all the way
-    // to the end.
-    {
-        TypeId t = ty;
-        for (size_t i = 0; i < path.size() - 1; ++i)
-        {
-            if (!isUnsealedTable(t))
-                return std::nullopt;
-
-            const TableTypeVar* tbl = get<TableTypeVar>(t);
-            auto it = tbl->props.find(path[i]);
-            if (it == tbl->props.end())
-                return std::nullopt;
-
-            t = it->second.type;
-        }
-
-        // The last path segment should not be a property of the table at all.
-        // We are not changing property types.  We are only admitting this one
-        // new property to be appended.
-        if (!isUnsealedTable(t))
-            return std::nullopt;
-        const TableTypeVar* tbl = get<TableTypeVar>(t);
-        auto it = tbl->props.find(path.back());
-        if (it != tbl->props.end())
-            return std::nullopt;
-    }
-
-    const TypeId res = shallowClone(ty, arena);
-    TypeId t = res;
-
-    for (size_t i = 0; i < path.size() - 1; ++i)
-    {
-        const std::string segment = path[i];
-
-        TableTypeVar* ttv = getMutable<TableTypeVar>(t);
-        LUAU_ASSERT(ttv);
-
-        auto propIt = ttv->props.find(segment);
-        if (propIt != ttv->props.end())
-        {
-            LUAU_ASSERT(isUnsealedTable(propIt->second.type));
-            t = shallowClone(follow(propIt->second.type), arena);
-            ttv->props[segment].type = t;
-        }
-        else
-            return std::nullopt;
-    }
-
-    TableTypeVar* ttv = getMutable<TableTypeVar>(t);
-    LUAU_ASSERT(ttv);
-
-    const std::string lastSegment = path.back();
-    LUAU_ASSERT(0 == ttv->props.count(lastSegment));
-    ttv->props[lastSegment] = Property{replaceTy};
-    return res;
-}
-
 /**
  * This function is mostly about identifying properties that are being inserted into unsealed tables.
  *
@@ -1559,31 +1494,36 @@ TypeId ConstraintGraphBuilder::checkLValue(const ScopePtr& scope, AstExpr* expr)
             return checkLValue(scope, &synthetic);
         }
     }
+    else if (!expr->is<AstExprIndexName>())
+        return check(scope, expr).ty;
 
     auto dottedPath = extractDottedName(expr);
     if (!dottedPath)
         return check(scope, expr).ty;
     const auto [sym, segments] = std::move(*dottedPath);
 
-    if (!sym.local)
-        return check(scope, expr).ty;
+    LUAU_ASSERT(!segments.empty());
 
     auto lookupResult = scope->lookupEx(sym);
     if (!lookupResult)
         return check(scope, expr).ty;
-    const auto [ty, symbolScope] = std::move(*lookupResult);
+    const auto [subjectType, symbolScope] = std::move(*lookupResult);
 
-    TypeId replaceTy = arena->freshType(scope.get());
+    TypeId propTy = freshType(scope);
 
-    std::optional<TypeId> updatedType = updateTheTableType(arena, ty, segments, replaceTy);
-    if (!updatedType)
-        return check(scope, expr).ty;
+    std::vector<std::string> segmentStrings(begin(segments), end(segments));
+
+    TypeId updatedType = arena->addType(BlockedTypeVar{});
+    addConstraint(scope, expr->location, SetPropConstraint{updatedType, subjectType, std::move(segmentStrings), propTy});
 
     std::optional<DefId> def = dfg->getDef(sym);
     LUAU_ASSERT(def);
-    symbolScope->bindings[sym].typeId = *updatedType;
-    symbolScope->dcrRefinements[*def] = *updatedType;
-    return replaceTy;
+    symbolScope->bindings[sym].typeId = updatedType;
+    symbolScope->dcrRefinements[*def] = updatedType;
+
+    astTypes[expr] = propTy;
+
+    return propTy;
 }
 
 Inference ConstraintGraphBuilder::check(const ScopePtr& scope, AstExprTable* expr, std::optional<TypeId> expectedType)
diff --git a/Analysis/src/ConstraintSolver.cpp b/Analysis/src/ConstraintSolver.cpp
index 533652e2..250e7ae2 100644
--- a/Analysis/src/ConstraintSolver.cpp
+++ b/Analysis/src/ConstraintSolver.cpp
@@ -2,6 +2,7 @@
 
 #include "Luau/Anyification.h"
 #include "Luau/ApplyTypeFunction.h"
+#include "Luau/Clone.h"
 #include "Luau/ConstraintSolver.h"
 #include "Luau/DcrLogger.h"
 #include "Luau/Instantiation.h"
@@ -415,6 +416,8 @@ bool ConstraintSolver::tryDispatch(NotNull<const Constraint> constraint, bool fo
         success = tryDispatch(*fcc, constraint);
     else if (auto hpc = get<HasPropConstraint>(*constraint))
         success = tryDispatch(*hpc, constraint);
+    else if (auto spc = get<SetPropConstraint>(*constraint))
+        success = tryDispatch(*spc, constraint);
     else if (auto sottc = get<SingletonOrTopTypeConstraint>(*constraint))
         success = tryDispatch(*sottc, constraint);
     else
@@ -1230,69 +1233,180 @@ bool ConstraintSolver::tryDispatch(const HasPropConstraint& c, NotNull<const Con
     if (isBlocked(subjectType) || get<PendingExpansionTypeVar>(subjectType))
         return block(subjectType, constraint);
 
-    TypeId resultType = nullptr;
+    std::optional<TypeId> resultType = lookupTableProp(subjectType, c.prop);
+    if (!resultType)
+        return false;
 
-    auto collectParts = [&](auto&& unionOrIntersection) -> std::pair<bool, std::vector<TypeId>> {
-        bool blocked = false;
+    if (isBlocked(*resultType))
+    {
+        block(*resultType, constraint);
+        return false;
+    }
 
-        std::vector<TypeId> parts;
-        for (TypeId expectedPart : unionOrIntersection)
+    asMutable(c.resultType)->ty.emplace<BoundTypeVar>(*resultType);
+    return true;
+}
+
+static bool isUnsealedTable(TypeId ty)
+{
+    ty = follow(ty);
+    const TableTypeVar* ttv = get<TableTypeVar>(ty);
+    return ttv && ttv->state == TableState::Unsealed;
+}
+
+/**
+ * Create a shallow copy of `ty` and its properties along `path`.  Insert a new
+ * property (the last segment of `path`) into the tail table with the value `t`.
+ *
+ * On success, returns the new outermost table type.  If the root table or any
+ * of its subkeys are not unsealed tables, the function fails and returns
+ * std::nullopt.
+ *
+ * TODO: Prove that we completely give up in the face of indexers and
+ * metatables.
+ */
+static std::optional<TypeId> updateTheTableType(NotNull<TypeArena> arena, TypeId ty, const std::vector<std::string>& path, TypeId replaceTy)
+{
+    if (path.empty())
+        return std::nullopt;
+
+    // First walk the path and ensure that it's unsealed tables all the way
+    // to the end.
+    {
+        TypeId t = ty;
+        for (size_t i = 0; i < path.size() - 1; ++i)
         {
-            expectedPart = follow(expectedPart);
-            if (isBlocked(expectedPart) || get<PendingExpansionTypeVar>(expectedPart))
-            {
-                blocked = true;
-                block(expectedPart, constraint);
-            }
-            else if (const TableTypeVar* ttv = get<TableTypeVar>(follow(expectedPart)))
-            {
-                if (auto prop = ttv->props.find(c.prop); prop != ttv->props.end())
-                    parts.push_back(prop->second.type);
-                else if (ttv->indexer && maybeString(ttv->indexer->indexType))
-                    parts.push_back(ttv->indexer->indexResultType);
-            }
+            if (!isUnsealedTable(t))
+                return std::nullopt;
+
+            const TableTypeVar* tbl = get<TableTypeVar>(t);
+            auto it = tbl->props.find(path[i]);
+            if (it == tbl->props.end())
+                return std::nullopt;
+
+            t = it->second.type;
         }
 
-        return {blocked, parts};
+        // The last path segment should not be a property of the table at all.
+        // We are not changing property types.  We are only admitting this one
+        // new property to be appended.
+        if (!isUnsealedTable(t))
+            return std::nullopt;
+        const TableTypeVar* tbl = get<TableTypeVar>(t);
+        if (0 != tbl->props.count(path.back()))
+            return std::nullopt;
+    }
+
+    const TypeId res = shallowClone(ty, arena);
+    TypeId t = res;
+
+    for (size_t i = 0; i < path.size() - 1; ++i)
+    {
+        const std::string segment = path[i];
+
+        TableTypeVar* ttv = getMutable<TableTypeVar>(t);
+        LUAU_ASSERT(ttv);
+
+        auto propIt = ttv->props.find(segment);
+        if (propIt != ttv->props.end())
+        {
+            LUAU_ASSERT(isUnsealedTable(propIt->second.type));
+            t = shallowClone(follow(propIt->second.type), arena);
+            ttv->props[segment].type = t;
+        }
+        else
+            return std::nullopt;
+    }
+
+    TableTypeVar* ttv = getMutable<TableTypeVar>(t);
+    LUAU_ASSERT(ttv);
+
+    const std::string lastSegment = path.back();
+    LUAU_ASSERT(0 == ttv->props.count(lastSegment));
+    ttv->props[lastSegment] = Property{replaceTy};
+    return res;
+}
+
+bool ConstraintSolver::tryDispatch(const SetPropConstraint& c, NotNull<const Constraint> constraint)
+{
+    TypeId subjectType = follow(c.subjectType);
+
+    if (isBlocked(subjectType))
+        return block(subjectType, constraint);
+
+    std::optional<TypeId> existingPropType = subjectType;
+    for (const std::string& segment : c.path)
+    {
+        ErrorVec e;
+        std::optional<TypeId> propTy = lookupTableProp(*existingPropType, segment);
+        if (!propTy)
+        {
+            existingPropType = std::nullopt;
+            break;
+        }
+        else if (isBlocked(*propTy))
+            return block(*propTy, constraint);
+        else
+            existingPropType = follow(*propTy);
+    }
+
+    auto bind = [](TypeId a, TypeId b) {
+        asMutable(a)->ty.emplace<BoundTypeVar>(b);
     };
 
-    if (auto ttv = get<TableTypeVar>(subjectType))
+    if (existingPropType)
     {
-        if (auto prop = ttv->props.find(c.prop); prop != ttv->props.end())
-            resultType = prop->second.type;
-        else if (ttv->indexer && maybeString(ttv->indexer->indexType))
-            resultType = ttv->indexer->indexResultType;
+        unify(c.propType, *existingPropType, constraint->scope);
+        bind(c.resultType, c.subjectType);
+        return true;
     }
-    else if (auto utv = get<UnionTypeVar>(subjectType))
-    {
-        auto [blocked, parts] = collectParts(utv);
 
-        if (blocked)
-            return false;
-        else if (parts.size() == 1)
-            resultType = parts[0];
-        else if (parts.size() > 1)
-            resultType = arena->addType(UnionTypeVar{std::move(parts)});
+    if (get<FreeTypeVar>(subjectType))
+    {
+        TypeId ty = arena->freshType(constraint->scope);
+
+        // Mint a chain of free tables per c.path
+        for (auto it = rbegin(c.path); it != rend(c.path); ++it)
+        {
+            TableTypeVar t{TableState::Free, TypeLevel{}, constraint->scope};
+            t.props[*it] = {ty};
+
+            ty = arena->addType(std::move(t));
+        }
+
+        LUAU_ASSERT(ty);
+
+        bind(subjectType, ty);
+        bind(c.resultType, ty);
+        return true;
+    }
+    else if (auto ttv = getMutable<TableTypeVar>(subjectType))
+    {
+        if (ttv->state == TableState::Free)
+        {
+            ttv->props[c.path[0]] = Property{c.propType};
+            bind(c.resultType, c.subjectType);
+            return true;
+        }
+        else if (ttv->state == TableState::Unsealed)
+        {
+            std::optional<TypeId> augmented = updateTheTableType(NotNull{arena}, subjectType, c.path, c.propType);
+            bind(c.resultType, augmented.value_or(subjectType));
+            return true;
+        }
         else
-            LUAU_ASSERT(false); // parts.size() == 0
+        {
+            bind(c.resultType, subjectType);
+            return true;
+        }
     }
-    else if (auto itv = get<IntersectionTypeVar>(subjectType))
+    else if (get<AnyTypeVar>(subjectType) || get<ErrorTypeVar>(subjectType))
     {
-        auto [blocked, parts] = collectParts(itv);
-
-        if (blocked)
-            return false;
-        else if (parts.size() == 1)
-            resultType = parts[0];
-        else if (parts.size() > 1)
-            resultType = arena->addType(IntersectionTypeVar{std::move(parts)});
-        else
-            LUAU_ASSERT(false); // parts.size() == 0
+        bind(c.resultType, subjectType);
+        return true;
     }
 
-    if (resultType)
-        asMutable(c.resultType)->ty.emplace<BoundTypeVar>(resultType);
-
+    LUAU_ASSERT(0);
     return true;
 }
 
@@ -1481,6 +1595,68 @@ bool ConstraintSolver::tryDispatchIterableFunction(
     return true;
 }
 
+std::optional<TypeId> ConstraintSolver::lookupTableProp(TypeId subjectType, const std::string& propName)
+{
+    auto collectParts = [&](auto&& unionOrIntersection) -> std::pair<std::optional<TypeId>, std::vector<TypeId>> {
+        std::optional<TypeId> blocked;
+
+        std::vector<TypeId> parts;
+        for (TypeId expectedPart : unionOrIntersection)
+        {
+            expectedPart = follow(expectedPart);
+            if (isBlocked(expectedPart) || get<PendingExpansionTypeVar>(expectedPart))
+                blocked = expectedPart;
+            else if (const TableTypeVar* ttv = get<TableTypeVar>(follow(expectedPart)))
+            {
+                if (auto prop = ttv->props.find(propName); prop != ttv->props.end())
+                    parts.push_back(prop->second.type);
+                else if (ttv->indexer && maybeString(ttv->indexer->indexType))
+                    parts.push_back(ttv->indexer->indexResultType);
+            }
+        }
+
+        return {blocked, parts};
+    };
+
+    std::optional<TypeId> resultType;
+
+    if (auto ttv = get<TableTypeVar>(subjectType))
+    {
+        if (auto prop = ttv->props.find(propName); prop != ttv->props.end())
+            resultType = prop->second.type;
+        else if (ttv->indexer && maybeString(ttv->indexer->indexType))
+            resultType = ttv->indexer->indexResultType;
+    }
+    else if (auto utv = get<UnionTypeVar>(subjectType))
+    {
+        auto [blocked, parts] = collectParts(utv);
+
+        if (blocked)
+            resultType = *blocked;
+        else if (parts.size() == 1)
+            resultType = parts[0];
+        else if (parts.size() > 1)
+            resultType = arena->addType(UnionTypeVar{std::move(parts)});
+        else
+            LUAU_ASSERT(false); // parts.size() == 0
+    }
+    else if (auto itv = get<IntersectionTypeVar>(subjectType))
+    {
+        auto [blocked, parts] = collectParts(itv);
+
+        if (blocked)
+            resultType = *blocked;
+        else if (parts.size() == 1)
+            resultType = parts[0];
+        else if (parts.size() > 1)
+            resultType = arena->addType(IntersectionTypeVar{std::move(parts)});
+        else
+            LUAU_ASSERT(false); // parts.size() == 0
+    }
+
+    return resultType;
+}
+
 void ConstraintSolver::block_(BlockedConstraintId target, NotNull<const Constraint> constraint)
 {
     blocked[target].push_back(constraint);
diff --git a/Analysis/src/ToString.cpp b/Analysis/src/ToString.cpp
index 5062c3f7..9e1fed26 100644
--- a/Analysis/src/ToString.cpp
+++ b/Analysis/src/ToString.cpp
@@ -1477,6 +1477,11 @@ std::string toString(const Constraint& constraint, ToStringOptions& opts)
         {
             return tos(c.resultType) + " ~ hasProp " + tos(c.subjectType) + ", \"" + c.prop + "\"";
         }
+        else if constexpr (std::is_same_v<T, SetPropConstraint>)
+        {
+            const std::string pathStr = c.path.size() == 1 ? "\"" + c.path[0] + "\"" : "[\"" + join(c.path, "\", \"") + "\"]";
+            return tos(c.resultType) + " ~ setProp " + tos(c.subjectType) + ", " + pathStr + " " + tos(c.propType);
+        }
         else if constexpr (std::is_same_v<T, SingletonOrTopTypeConstraint>)
         {
             std::string result = tos(c.resultType);
diff --git a/Analysis/src/TypeChecker2.cpp b/Analysis/src/TypeChecker2.cpp
index 03575c40..35493bdb 100644
--- a/Analysis/src/TypeChecker2.cpp
+++ b/Analysis/src/TypeChecker2.cpp
@@ -857,6 +857,15 @@ struct TypeChecker2
             args.head.push_back(argTy);
         }
 
+        if (call->self)
+        {
+            AstExprIndexName* indexExpr = call->func->as<AstExprIndexName>();
+            if (!indexExpr)
+                ice.ice("method call expression has no 'self'");
+
+            args.head.insert(args.head.begin(), lookupType(indexExpr->expr));
+        }
+
         TypePackId argsTp = arena.addTypePack(args);
         FunctionTypeVar ftv{argsTp, expectedRetType};
         TypeId expectedType = arena.addType(ftv);
diff --git a/Analysis/src/TypedAllocator.cpp b/Analysis/src/TypedAllocator.cpp
index c95c8eae..133104d3 100644
--- a/Analysis/src/TypedAllocator.cpp
+++ b/Analysis/src/TypedAllocator.cpp
@@ -17,8 +17,12 @@ const size_t kPageSize = 4096;
 #include <sys/mman.h>
 #include <unistd.h>
 
+#if defined(__FreeBSD__) && !(_POSIX_C_SOURCE >= 200112L)
+const size_t kPageSize = getpagesize();
+#else
 const size_t kPageSize = sysconf(_SC_PAGESIZE);
 #endif
+#endif
 
 #include <stdlib.h>
 
diff --git a/Ast/src/Parser.cpp b/Ast/src/Parser.cpp
index 8338a04a..85b0d31a 100644
--- a/Ast/src/Parser.cpp
+++ b/Ast/src/Parser.cpp
@@ -2661,6 +2661,7 @@ AstExpr* Parser::parseInterpString()
     TempVector<AstExpr*> expressions(scratchExpr);
 
     Location startLocation = lexer.current().location;
+    Location endLocation;
 
     do
     {
@@ -2668,16 +2669,16 @@ AstExpr* Parser::parseInterpString()
         LUAU_ASSERT(currentLexeme.type == Lexeme::InterpStringBegin || currentLexeme.type == Lexeme::InterpStringMid ||
                     currentLexeme.type == Lexeme::InterpStringEnd || currentLexeme.type == Lexeme::InterpStringSimple);
 
-        Location location = currentLexeme.location;
+        endLocation = currentLexeme.location;
 
-        Location startOfBrace = Location(location.end, 1);
+        Location startOfBrace = Location(endLocation.end, 1);
 
         scratchData.assign(currentLexeme.data, currentLexeme.length);
 
         if (!Lexer::fixupQuotedString(scratchData))
         {
             nextLexeme();
-            return reportExprError(startLocation, {}, "Interpolated string literal contains malformed escape sequence");
+            return reportExprError(Location{startLocation, endLocation}, {}, "Interpolated string literal contains malformed escape sequence");
         }
 
         AstArray<char> chars = copy(scratchData);
@@ -2688,15 +2689,36 @@ AstExpr* Parser::parseInterpString()
 
         if (currentLexeme.type == Lexeme::InterpStringEnd || currentLexeme.type == Lexeme::InterpStringSimple)
         {
-            AstArray<AstArray<char>> stringsArray = copy(strings);
-            AstArray<AstExpr*> expressionsArray = copy(expressions);
-
-            return allocator.alloc<AstExprInterpString>(startLocation, stringsArray, expressionsArray);
+            break;
         }
 
-        AstExpr* expression = parseExpr();
+        bool errorWhileChecking = false;
 
-        expressions.push_back(expression);
+        switch (lexer.current().type)
+        {
+        case Lexeme::InterpStringMid:
+        case Lexeme::InterpStringEnd:
+        {
+            errorWhileChecking = true;
+            nextLexeme();
+            expressions.push_back(reportExprError(endLocation, {}, "Malformed interpolated string, expected expression inside '{}'"));
+            break;
+        }
+        case Lexeme::BrokenString:
+        {
+            errorWhileChecking = true;
+            nextLexeme();
+            expressions.push_back(reportExprError(endLocation, {}, "Malformed interpolated string, did you forget to add a '`'?"));
+            break;
+        }
+        default:
+            expressions.push_back(parseExpr());
+        }
+
+        if (errorWhileChecking)
+        {
+            break;
+        }
 
         switch (lexer.current().type)
         {
@@ -2706,14 +2728,18 @@ AstExpr* Parser::parseInterpString()
             break;
         case Lexeme::BrokenInterpDoubleBrace:
             nextLexeme();
-            return reportExprError(location, {}, ERROR_INVALID_INTERP_DOUBLE_BRACE);
+            return reportExprError(endLocation, {}, ERROR_INVALID_INTERP_DOUBLE_BRACE);
         case Lexeme::BrokenString:
             nextLexeme();
-            return reportExprError(location, {}, "Malformed interpolated string, did you forget to add a '}'?");
+            return reportExprError(endLocation, {}, "Malformed interpolated string, did you forget to add a '}'?");
         default:
-            return reportExprError(location, {}, "Malformed interpolated string, got %s", lexer.current().toString().c_str());
+            return reportExprError(endLocation, {}, "Malformed interpolated string, got %s", lexer.current().toString().c_str());
         }
     } while (true);
+
+    AstArray<AstArray<char>> stringsArray = copy(strings);
+    AstArray<AstExpr*> expressionsArray = copy(expressions);
+    return allocator.alloc<AstExprInterpString>(Location{startLocation, endLocation}, stringsArray, expressionsArray);
 }
 
 AstExpr* Parser::parseNumber()
diff --git a/CodeGen/src/CodeAllocator.cpp b/CodeGen/src/CodeAllocator.cpp
index 823df0d8..e1950dbc 100644
--- a/CodeGen/src/CodeAllocator.cpp
+++ b/CodeGen/src/CodeAllocator.cpp
@@ -20,8 +20,12 @@ const size_t kPageSize = 4096;
 #include <sys/mman.h>
 #include <unistd.h>
 
+#if defined(__FreeBSD__) && !(_POSIX_C_SOURCE >= 200112L)
+const size_t kPageSize = getpagesize();
+#else
 const size_t kPageSize = sysconf(_SC_PAGESIZE);
 #endif
+#endif
 
 static size_t alignToPageSize(size_t size)
 {
diff --git a/Common/include/Luau/ExperimentalFlags.h b/Common/include/Luau/ExperimentalFlags.h
index 15db9ea3..41c1af59 100644
--- a/Common/include/Luau/ExperimentalFlags.h
+++ b/Common/include/Luau/ExperimentalFlags.h
@@ -13,7 +13,6 @@ inline bool isFlagExperimental(const char* flag)
     static const char* kList[] = {
         "LuauInterpolatedStringBaseSupport",
         "LuauInstantiateInSubtyping", // requires some fixes to lua-apps code
-        "LuauOptionalNextKey",        // waiting for a fix to land in lua-apps
         "LuauTryhardAnd",             // waiting for a fix in graphql-lua -> apollo-client-lia -> lua-apps
         // makes sure we always have at least one entry
         nullptr,
diff --git a/VM/src/lapi.cpp b/VM/src/lapi.cpp
index 28307eb9..d2091c6b 100644
--- a/VM/src/lapi.cpp
+++ b/VM/src/lapi.cpp
@@ -148,7 +148,6 @@ void lua_rawcheckstack(lua_State* L, int size)
 {
     luaD_checkstack(L, size);
     expandstacklimit(L, L->top + size);
-    return;
 }
 
 void lua_xmove(lua_State* from, lua_State* to, int n)
@@ -167,8 +166,6 @@ void lua_xmove(lua_State* from, lua_State* to, int n)
 
     from->top = ftop;
     to->top = ttop + n;
-
-    return;
 }
 
 void lua_xpush(lua_State* from, lua_State* to, int idx)
@@ -177,7 +174,6 @@ void lua_xpush(lua_State* from, lua_State* to, int idx)
     luaC_threadbarrier(to);
     setobj2s(to, to->top, index2addr(from, idx));
     api_incr_top(to);
-    return;
 }
 
 lua_State* lua_newthread(lua_State* L)
@@ -227,7 +223,6 @@ void lua_settop(lua_State* L, int idx)
         api_check(L, -(idx + 1) <= (L->top - L->base));
         L->top += idx + 1; // `subtract' index (index is negative)
     }
-    return;
 }
 
 void lua_remove(lua_State* L, int idx)
@@ -237,7 +232,6 @@ void lua_remove(lua_State* L, int idx)
     while (++p < L->top)
         setobj2s(L, p - 1, p);
     L->top--;
-    return;
 }
 
 void lua_insert(lua_State* L, int idx)
@@ -248,7 +242,6 @@ void lua_insert(lua_State* L, int idx)
     for (StkId q = L->top; q > p; q--)
         setobj2s(L, q, q - 1);
     setobj2s(L, p, L->top);
-    return;
 }
 
 void lua_replace(lua_State* L, int idx)
@@ -277,7 +270,6 @@ void lua_replace(lua_State* L, int idx)
             luaC_barrier(L, curr_func(L), L->top - 1);
     }
     L->top--;
-    return;
 }
 
 void lua_pushvalue(lua_State* L, int idx)
@@ -286,7 +278,6 @@ void lua_pushvalue(lua_State* L, int idx)
     StkId o = index2addr(L, idx);
     setobj2s(L, L->top, o);
     api_incr_top(L);
-    return;
 }
 
 /*
@@ -570,28 +561,24 @@ void lua_pushnil(lua_State* L)
 {
     setnilvalue(L->top);
     api_incr_top(L);
-    return;
 }
 
 void lua_pushnumber(lua_State* L, double n)
 {
     setnvalue(L->top, n);
     api_incr_top(L);
-    return;
 }
 
 void lua_pushinteger(lua_State* L, int n)
 {
     setnvalue(L->top, cast_num(n));
     api_incr_top(L);
-    return;
 }
 
 void lua_pushunsigned(lua_State* L, unsigned u)
 {
     setnvalue(L->top, cast_num(u));
     api_incr_top(L);
-    return;
 }
 
 #if LUA_VECTOR_SIZE == 4
@@ -599,14 +586,12 @@ void lua_pushvector(lua_State* L, float x, float y, float z, float w)
 {
     setvvalue(L->top, x, y, z, w);
     api_incr_top(L);
-    return;
 }
 #else
 void lua_pushvector(lua_State* L, float x, float y, float z)
 {
     setvvalue(L->top, x, y, z, 0.0f);
     api_incr_top(L);
-    return;
 }
 #endif
 
@@ -616,7 +601,6 @@ void lua_pushlstring(lua_State* L, const char* s, size_t len)
     luaC_threadbarrier(L);
     setsvalue(L, L->top, luaS_newlstr(L, s, len));
     api_incr_top(L);
-    return;
 }
 
 void lua_pushstring(lua_State* L, const char* s)
@@ -661,21 +645,18 @@ void lua_pushcclosurek(lua_State* L, lua_CFunction fn, const char* debugname, in
     setclvalue(L, L->top, cl);
     LUAU_ASSERT(iswhite(obj2gco(cl)));
     api_incr_top(L);
-    return;
 }
 
 void lua_pushboolean(lua_State* L, int b)
 {
     setbvalue(L->top, (b != 0)); // ensure that true is 1
     api_incr_top(L);
-    return;
 }
 
 void lua_pushlightuserdata(lua_State* L, void* p)
 {
     setpvalue(L->top, p);
     api_incr_top(L);
-    return;
 }
 
 int lua_pushthread(lua_State* L)
@@ -748,7 +729,6 @@ void lua_createtable(lua_State* L, int narray, int nrec)
     luaC_threadbarrier(L);
     sethvalue(L, L->top, luaH_new(L, narray, nrec));
     api_incr_top(L);
-    return;
 }
 
 void lua_setreadonly(lua_State* L, int objindex, int enabled)
@@ -758,7 +738,6 @@ void lua_setreadonly(lua_State* L, int objindex, int enabled)
     Table* t = hvalue(o);
     api_check(L, t != hvalue(registry(L)));
     t->readonly = bool(enabled);
-    return;
 }
 
 int lua_getreadonly(lua_State* L, int objindex)
@@ -776,7 +755,6 @@ void lua_setsafeenv(lua_State* L, int objindex, int enabled)
     api_check(L, ttistable(o));
     Table* t = hvalue(o);
     t->safeenv = bool(enabled);
-    return;
 }
 
 int lua_getmetatable(lua_State* L, int objindex)
@@ -822,7 +800,6 @@ void lua_getfenv(lua_State* L, int idx)
         break;
     }
     api_incr_top(L);
-    return;
 }
 
 /*
@@ -836,7 +813,6 @@ void lua_settable(lua_State* L, int idx)
     api_checkvalidindex(L, t);
     luaV_settable(L, t, L->top - 2, L->top - 1);
     L->top -= 2; // pop index and value
-    return;
 }
 
 void lua_setfield(lua_State* L, int idx, const char* k)
@@ -848,7 +824,6 @@ void lua_setfield(lua_State* L, int idx, const char* k)
     setsvalue(L, &key, luaS_new(L, k));
     luaV_settable(L, t, &key, L->top - 1);
     L->top--;
-    return;
 }
 
 void lua_rawsetfield(lua_State* L, int idx, const char* k)
@@ -861,7 +836,6 @@ void lua_rawsetfield(lua_State* L, int idx, const char* k)
     setobj2t(L, luaH_setstr(L, hvalue(t), luaS_new(L, k)), L->top - 1);
     luaC_barriert(L, hvalue(t), L->top - 1);
     L->top--;
-    return;
 }
 
 void lua_rawset(lua_State* L, int idx)
@@ -874,7 +848,6 @@ void lua_rawset(lua_State* L, int idx)
     setobj2t(L, luaH_set(L, hvalue(t), L->top - 2), L->top - 1);
     luaC_barriert(L, hvalue(t), L->top - 1);
     L->top -= 2;
-    return;
 }
 
 void lua_rawseti(lua_State* L, int idx, int n)
@@ -887,7 +860,6 @@ void lua_rawseti(lua_State* L, int idx, int n)
     setobj2t(L, luaH_setnum(L, hvalue(o), n), L->top - 1);
     luaC_barriert(L, hvalue(o), L->top - 1);
     L->top--;
-    return;
 }
 
 int lua_setmetatable(lua_State* L, int objindex)
@@ -979,7 +951,6 @@ void lua_call(lua_State* L, int nargs, int nresults)
     luaD_call(L, func, nresults);
 
     adjustresults(L, nresults);
-    return;
 }
 
 /*
@@ -995,7 +966,6 @@ static void f_call(lua_State* L, void* ud)
 {
     struct CallS* c = cast_to(struct CallS*, ud);
     luaD_call(L, c->func, c->nresults);
-    return;
 }
 
 int lua_pcall(lua_State* L, int nargs, int nresults, int errfunc)
@@ -1273,7 +1243,6 @@ void lua_concat(lua_State* L, int n)
         api_incr_top(L);
     }
     // else n == 1; nothing to do
-    return;
 }
 
 void* lua_newuserdatatagged(lua_State* L, size_t sz, int tag)
@@ -1397,7 +1366,6 @@ void lua_unref(lua_State* L, int ref)
     TValue* slot = luaH_setnum(L, reg, ref);
     setnvalue(slot, g->registryfree); // NB: no barrier needed because value isn't collectable
     g->registryfree = ref;
-    return;
 }
 
 void lua_setuserdatatag(lua_State* L, int idx, int tag)
diff --git a/tests/AstJsonEncoder.test.cpp b/tests/AstJsonEncoder.test.cpp
index 81e74941..a14d5f59 100644
--- a/tests/AstJsonEncoder.test.cpp
+++ b/tests/AstJsonEncoder.test.cpp
@@ -183,7 +183,7 @@ TEST_CASE_FIXTURE(JsonEncoderFixture, "encode_AstExprInterpString")
     AstStat* statement = expectParseStatement("local a = `var = {x}`");
 
     std::string_view expected =
-        R"({"type":"AstStatLocal","location":"0,0 - 0,18","vars":[{"luauType":null,"name":"a","type":"AstLocal","location":"0,6 - 0,7"}],"values":[{"type":"AstExprInterpString","location":"0,10 - 0,18","strings":["var = ",""],"expressions":[{"type":"AstExprGlobal","location":"0,18 - 0,19","global":"x"}]}]})";
+        R"({"type":"AstStatLocal","location":"0,0 - 0,21","vars":[{"luauType":null,"name":"a","type":"AstLocal","location":"0,6 - 0,7"}],"values":[{"type":"AstExprInterpString","location":"0,10 - 0,21","strings":["var = ",""],"expressions":[{"type":"AstExprGlobal","location":"0,18 - 0,19","global":"x"}]}]})";
 
     CHECK(toJson(statement) == expected);
 }
diff --git a/tests/Autocomplete.test.cpp b/tests/Autocomplete.test.cpp
index 9a5c3411..45baec2c 100644
--- a/tests/Autocomplete.test.cpp
+++ b/tests/Autocomplete.test.cpp
@@ -7,6 +7,7 @@
 #include "Luau/StringUtils.h"
 
 #include "Fixture.h"
+#include "ScopedFlags.h"
 
 #include "doctest.h"
 
@@ -2708,13 +2709,77 @@ a = if temp then even else abc@3
     CHECK(ac.entryMap.count("abcdef"));
 }
 
-TEST_CASE_FIXTURE(ACFixture, "autocomplete_interpolated_string")
+TEST_CASE_FIXTURE(ACFixture, "autocomplete_interpolated_string_constant")
 {
+    ScopedFastFlag sff{"LuauInterpolatedStringBaseSupport", true};
+
+    check(R"(f(`@1`))");
+    auto ac = autocomplete('1');
+    CHECK(ac.entryMap.empty());
+    CHECK_EQ(ac.context, AutocompleteContext::String);
+
+    check(R"(f(`@1 {"a"}`))");
+    ac = autocomplete('1');
+    CHECK(ac.entryMap.empty());
+    CHECK_EQ(ac.context, AutocompleteContext::String);
+
+    check(R"(f(`{"a"} @1`))");
+    ac = autocomplete('1');
+    CHECK(ac.entryMap.empty());
+    CHECK_EQ(ac.context, AutocompleteContext::String);
+
+    check(R"(f(`{"a"} @1 {"b"}`))");
+    ac = autocomplete('1');
+    CHECK(ac.entryMap.empty());
+    CHECK_EQ(ac.context, AutocompleteContext::String);
+}
+
+TEST_CASE_FIXTURE(ACFixture, "autocomplete_interpolated_string_expression")
+{
+    ScopedFastFlag sff{"LuauInterpolatedStringBaseSupport", true};
+
     check(R"(f(`expression = {@1}`))");
+    auto ac = autocomplete('1');
+    CHECK(ac.entryMap.count("table"));
+    CHECK_EQ(ac.context, AutocompleteContext::Expression);
+}
+
+TEST_CASE_FIXTURE(ACFixture, "autocomplete_interpolated_string_expression_with_comments")
+{
+    ScopedFastFlag sff{"LuauInterpolatedStringBaseSupport", true};
+
+    check(R"(f(`expression = {--[[ bla bla bla ]]@1`))");
 
     auto ac = autocomplete('1');
     CHECK(ac.entryMap.count("table"));
     CHECK_EQ(ac.context, AutocompleteContext::Expression);
+
+    check(R"(f(`expression = {@1 --[[ bla bla bla ]]`))");
+    ac = autocomplete('1');
+    CHECK(!ac.entryMap.empty());
+    CHECK(ac.entryMap.count("table"));
+    CHECK_EQ(ac.context, AutocompleteContext::Expression);
+}
+
+TEST_CASE_FIXTURE(ACFixture, "autocomplete_interpolated_string_as_singleton")
+{
+    ScopedFastFlag sff{"LuauInterpolatedStringBaseSupport", true};
+
+    check(R"(
+        --!strict
+        local function f(a: "cat" | "dog") end
+
+        f(`@1`)
+        f(`uhhh{'try'}@2`)
+    )");
+
+    auto ac = autocomplete('1');
+    CHECK(ac.entryMap.count("cat"));
+    CHECK_EQ(ac.context, AutocompleteContext::String);
+
+    ac = autocomplete('2');
+    CHECK(ac.entryMap.empty());
+    CHECK_EQ(ac.context, AutocompleteContext::String);
 }
 
 TEST_CASE_FIXTURE(ACFixture, "autocomplete_explicit_type_pack")
diff --git a/tests/TypeInfer.tables.test.cpp b/tests/TypeInfer.tables.test.cpp
index bf0a0af6..10186e3a 100644
--- a/tests/TypeInfer.tables.test.cpp
+++ b/tests/TypeInfer.tables.test.cpp
@@ -50,7 +50,7 @@ TEST_CASE_FIXTURE(Fixture, "augment_table")
     const TableTypeVar* tType = get<TableTypeVar>(requireType("t"));
     REQUIRE(tType != nullptr);
 
-    CHECK(1 == tType->props.count("foo"));
+    CHECK("{ foo: string }" == toString(requireType("t"), {true}));
 }
 
 TEST_CASE_FIXTURE(Fixture, "augment_nested_table")
@@ -65,7 +65,7 @@ TEST_CASE_FIXTURE(Fixture, "augment_nested_table")
     const TableTypeVar* pType = get<TableTypeVar>(tType->props["p"].type);
     REQUIRE(pType != nullptr);
 
-    CHECK(pType->props.find("foo") != pType->props.end());
+    CHECK("{ p: { foo: string } }" == toString(requireType("t"), {true}));
 }
 
 TEST_CASE_FIXTURE(Fixture, "cannot_augment_sealed_table")
diff --git a/tools/faillist.txt b/tools/faillist.txt
index a228c171..433d0cfb 100644
--- a/tools/faillist.txt
+++ b/tools/faillist.txt
@@ -51,7 +51,6 @@ BuiltinTests.dont_add_definitions_to_persistent_types
 BuiltinTests.find_capture_types
 BuiltinTests.find_capture_types2
 BuiltinTests.find_capture_types3
-BuiltinTests.gmatch_capture_types2
 BuiltinTests.gmatch_capture_types_balanced_escaped_parens
 BuiltinTests.gmatch_capture_types_default_capture
 BuiltinTests.gmatch_capture_types_parens_in_sets_are_ignored
@@ -73,9 +72,7 @@ BuiltinTests.string_format_arg_count_mismatch
 BuiltinTests.string_format_as_method
 BuiltinTests.string_format_correctly_ordered_types
 BuiltinTests.string_format_report_all_type_errors_at_correct_positions
-BuiltinTests.string_format_use_correct_argument
 BuiltinTests.string_format_use_correct_argument2
-BuiltinTests.strings_have_methods
 BuiltinTests.table_freeze_is_generic
 BuiltinTests.table_insert_correctly_infers_type_of_array_2_args_overload
 BuiltinTests.table_insert_correctly_infers_type_of_array_3_args_overload
@@ -115,7 +112,6 @@ GenericsTests.infer_generic_function_function_argument
 GenericsTests.infer_generic_function_function_argument_overloaded
 GenericsTests.infer_generic_methods
 GenericsTests.infer_generic_property
-GenericsTests.instantiate_cyclic_generic_function
 GenericsTests.instantiated_function_argument_names
 GenericsTests.instantiation_sharing_types
 GenericsTests.no_stack_overflow_from_quantifying
@@ -198,7 +194,6 @@ RefinementTest.x_as_any_if_x_is_instance_elseif_x_is_table
 RefinementTest.x_is_not_instance_or_else_not_part
 RuntimeLimits.typescript_port_of_Result_type
 TableTests.a_free_shape_can_turn_into_a_scalar_directly
-TableTests.a_free_shape_can_turn_into_a_scalar_if_it_is_compatible
 TableTests.a_free_shape_cannot_turn_into_a_scalar_if_it_is_not_compatible
 TableTests.access_index_metamethod_that_returns_variadic
 TableTests.accidentally_checked_prop_in_opposite_branch
@@ -269,7 +264,6 @@ TableTests.reasonable_error_when_adding_a_nonexistent_property_to_an_array_like_
 TableTests.result_is_always_any_if_lhs_is_any
 TableTests.result_is_bool_for_equality_operators_if_lhs_is_any
 TableTests.right_table_missing_key2
-TableTests.scalar_is_a_subtype_of_a_compatible_polymorphic_shape_type
 TableTests.scalar_is_not_a_subtype_of_a_compatible_polymorphic_shape_type
 TableTests.shared_selfs
 TableTests.shared_selfs_from_free_param
@@ -285,7 +279,6 @@ TableTests.table_subtyping_with_missing_props_dont_report_multiple_errors
 TableTests.tables_get_names_from_their_locals
 TableTests.tc_member_function
 TableTests.tc_member_function_2
-TableTests.type_mismatch_on_massive_table_is_cut_short
 TableTests.unification_of_unions_in_a_self_referential_type
 TableTests.unifying_tables_shouldnt_uaf2
 TableTests.used_colon_instead_of_dot
@@ -343,8 +336,6 @@ TypeInfer.type_infer_recursion_limit_no_ice
 TypeInfer.type_infer_recursion_limit_normalizer
 TypeInferAnyError.for_in_loop_iterator_is_any2
 TypeInferAnyError.for_in_loop_iterator_is_error2
-TypeInferClasses.call_base_method
-TypeInferClasses.call_instance_method
 TypeInferClasses.can_read_prop_of_base_class_using_string
 TypeInferClasses.class_type_mismatch_with_name_conflict
 TypeInferClasses.classes_without_overloaded_operators_cannot_be_added
@@ -429,10 +420,7 @@ TypeInferOperators.typecheck_overloaded_multiply_that_is_an_intersection
 TypeInferOperators.typecheck_overloaded_multiply_that_is_an_intersection_on_rhs
 TypeInferOperators.UnknownGlobalCompoundAssign
 TypeInferPrimitives.CheckMethodsOfNumber
-TypeInferPrimitives.singleton_types
-TypeInferPrimitives.string_function_other
 TypeInferPrimitives.string_index
-TypeInferPrimitives.string_method
 TypeInferUnknownNever.assign_to_global_which_is_never
 TypeInferUnknownNever.assign_to_local_which_is_never
 TypeInferUnknownNever.assign_to_prop_which_is_never