Sync to upstream/release/705 (#2200)

Hello Luaunauts, we're continuing into the second release of the year at
a brisk pace! We've got a number of improvements for both native code
generation and the new type solver, as well as some other assorted
changes, that keep us moving towards the goal of making the best
possible scripting language!

# Analysis

- Refinements against a union of tables would sometimes erroneously
refine to a narrower type than intended. The root cause here was a bug
in the logic that determines how to "simplify" types (for example
knowing that `true | false` is the same as `boolean`).
  ```luau
  export type States = "Closed" | "Closing" | "Opening" | "Open"
  export type MyType<A = any> = {
      State: States,
      IsOpen: boolean,
      Open: (self: MyType<A>) -> (),
  }
  
  local value = {} :: MyType
  
  function value:Open()
      if self.IsOpen == true then
      elseif self.State == "Closing" or self.State == "Opening" then
          -- Prior, this line errored as we were erroneously refining
          -- `self` with `{ State: "Closing" | "Opening" }` rather
          -- than `{ read State: "Closing" | "Opening" }
          self:Open()
      end
  end
  ```
- Adds an option in `ToString.cpp` to disable the use of synthetic
names, which can be used to improve the quality of hover type.
- Fixes a bug where `table.freeze` would incorrectly error on arguments
of `any` type (fixes #2181)
- Subtyping mistakenly did not allow for us to covariantly check tables
with missing properties against table types that gave those properties
optional types. This release should fix these issues, including fixes
#2164.
- Type functions have a global environment that defines all of the type
aliases present in the environment around the type function definition,
and the API of type functions also allows you to mutate types,
specifically table types and function types. Though we never supported
the type functions _actually_ mutating the aliases present in the
environment around them, the mutable API allowed for users to author
type functions that _appeared_ to do so, which could be confusing when
they later discover that their mutation did not take place. This release
introduces new errors for type functions that attempt to call mutable
APIs on types from their environment, e.g.
    ```luau
    type myType = {}
    type function create_table_with_key()
myType:setproperty(types.singleton "key", types.optional(types.number))
-- this errors now!
        return myType
    end
    local my_tbl: create_table_with_key<> = {key = "123"}
    ```
- Bidirectional inference for lambdas on extern types with generic
parameters should work more consistently.
- #2166 fixes a bug with `findBindingAtPosition` that should enable LSP
tools to better support finding references for local functions and their
parameters.
- This release also includes a broad-strokes improvement to error
suppression handling. The New Type Solver should now be more consistent
about not reporting (or re-reporting) errors involving `any` or
`*error-type*` or directly downstream of an existing type error.
- This release removes the experimental
`DebugLuauStringSingletonBasedOnQuotes` flag that trialed basing
singleton type inference solely on the usage of different quote styles.
We do not think we will be proceeding with this approach at this time.

# Native Code Generation

- Fixes a crash in `getOffsetBase` when the passed in IrOp is not an
IrInst.
- Improves inlining support by passing the argument value as the
initializer for the temporary being allocated in cases like anonymous
function arguments or referring to upvalues in a function body.
- Fixes the function end byte offset value, along side a number of other
internal values that could lead to incorrect code size values.
- Adds a more direct implementation of code generation for `vector`
equality and inequality that leads to fewer instructions in the IR and a
smaller number of produced basic blocks.
- Adds a more optimized code generation flow for situations where we're
indexing a table with keys that have unexpected type tags.
- Fixes a bug where NCG would sometimes mistakenly optimize away
necessary entry tag checks.
- Introduces a customizable per-VM storage for use from "execution
callbacks" system, with NCG as its first consumer for extra spill
spaces. This adds 32x 8-byte spill slots on arm64 (on top of existing
22) and 64x 8-byte spill slots on x64 (on top of existing 12*).
- Changes codegen for bit32 operations to use guards, rather than normal
control flow, leading to significant (~30%) performance improvements in
some benchmarks that heavily leverage these operations.
- Adds a combined instruction `UINT_TO_FLOAT` to replace instances where
we needed to emit `UINT_TO_NUM` and `NUM_TO_FLOAT` paired up. This leads
to some very modest performance improvements.

# Runtime
- We previously added constant string constant folding with the results
stored in AST allocator. This release also moves interpolation
formatting strings to AST allocator to resolve #1965.
- #2069 adds support for using `os.clock` in Emscripten build targets,
like the [Luau Playground](https://play.luau.org).
- #2149 extends the C++ Require library to support constructing aliases
with tags associated with them.
- #2054 fixes a bugged comparison in `api_update_top` that would cause
an unnecessary runtime error if the API was used in a way that should be
a noop.

# Internal Contributors
Co-authored-by: Andy Friesen <afriesen@roblox.com>
Co-authored-by: Annie Tang <annietang@roblox.com>
Co-authored-by: Ariel Weiss <arielweiss@roblox.com>
Co-authored-by: Hunter Goldstein <hgoldstein@roblox.com>
Co-authored-by: James McNellis <jmcnellis@roblox.com>
Co-authored-by: Sora Kanosue <skanosue@roblox.com>
Co-authored-by: Vighnesh Vijay <vvijay@roblox.com>
Co-authored-by: Vyacheslav Egorov <vegorov@roblox.com>

---------

Co-authored-by: Hunter Goldstein <hgoldstein@roblox.com>
Co-authored-by: Varun Saini <61795485+vrn-sn@users.noreply.github.com>
Co-authored-by: Alexander Youngblood <ayoungblood@roblox.com>
Co-authored-by: Menarul Alam <malam@roblox.com>
Co-authored-by: Aviral Goel <agoel@roblox.com>
Co-authored-by: Vighnesh <vvijay@roblox.com>
Co-authored-by: Vyacheslav Egorov <vegorov@roblox.com>
Co-authored-by: Andy Friesen <afriesen@roblox.com>
Co-authored-by: Ilya Rezvov <irezvov@roblox.com>

Author: 10 people

Analysis/include/Luau/ConfigResolver.h

@@ -20,7 +20,7 @@ struct NullConfigResolver : ConfigResolver
 {
     Config defaultConfig;
 
-    virtual const Config& getConfig(const ModuleName& name, const TypeCheckLimits& limits) const override
+    const Config& getConfig(const ModuleName& name, const TypeCheckLimits& limits) const override
     {
         return defaultConfig;
     }

Analysis/include/Luau/Error.h

@@ -755,7 +755,7 @@ class InternalCompilerError : public std::exception
         , location(location)
     {
     }
-    virtual const char* what() const throw();
+    const char* what() const throw() override;
 
     const std::string message;
     const std::optional<std::string> moduleName;

Analysis/include/Luau/IterativeTypeFunctionTypeVisitor.h

@@ -0,0 +1,100 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#pragma once
+
+#include "Luau/TypeFunctionRuntime.h"
+#include "Luau/TypeFwd.h"
+#include "Luau/Set.h"
+
+namespace Luau
+{
+
+struct IterativeTypeFunctionTypeVisitor
+{
+    using SeenSet = Set<const void*>;
+
+    // We avoid Luau::Variant here because we can move the tag bit and make this struct 64 bits shorter.
+    struct WorkItem
+    {
+        WorkItem(TypeFunctionTypeId ty, int32_t parent);
+        WorkItem(TypeFunctionTypePackId tp, int32_t parent);
+
+        const TypeFunctionTypeId* asType() const;
+        const TypeFunctionTypePackId* asTypePack() const;
+
+        bool operator==(TypeFunctionTypeId ty) const;
+        bool operator==(TypeFunctionTypePackId tp) const;
+
+    private:
+        // TypeFunctionTypeId if isType, else TypeFunctionTypePackId
+        const void* t;
+        bool isType;
+
+    public:
+        // -1 indicates no parent
+        int32_t parent;
+    };
+
+    explicit IterativeTypeFunctionTypeVisitor(std::string visitorName);
+    explicit IterativeTypeFunctionTypeVisitor(std::string visitorName, bool visitOnce);
+    explicit IterativeTypeFunctionTypeVisitor(std::string visitorName, SeenSet seen, bool visitOnce);
+
+    IterativeTypeFunctionTypeVisitor(const IterativeTypeFunctionTypeVisitor&) = delete;
+    IterativeTypeFunctionTypeVisitor& operator=(const IterativeTypeFunctionTypeVisitor&) = delete;
+
+    virtual ~IterativeTypeFunctionTypeVisitor() = default;
+
+    virtual void cycle(TypeFunctionTypeId ty);
+    virtual void cycle(TypeFunctionTypePackId tp);
+
+    virtual bool visit(TypeFunctionTypeId ty);
+    virtual bool visit(TypeFunctionTypeId ty, const TypeFunctionPrimitiveType& tfpt);
+    virtual bool visit(TypeFunctionTypeId ty, const TypeFunctionAnyType& tfat);
+    virtual bool visit(TypeFunctionTypeId ty, const TypeFunctionUnknownType& tfut);
+    virtual bool visit(TypeFunctionTypeId ty, const TypeFunctionNeverType& tfnt);
+    virtual bool visit(TypeFunctionTypeId ty, const TypeFunctionSingletonType& tfst);
+    virtual bool visit(TypeFunctionTypeId ty, const TypeFunctionUnionType& tfut);
+    virtual bool visit(TypeFunctionTypeId ty, const TypeFunctionIntersectionType& tfit);
+    virtual bool visit(TypeFunctionTypeId ty, const TypeFunctionNegationType& tfnt);
+    virtual bool visit(TypeFunctionTypeId ty, const TypeFunctionFunctionType& tfft);
+    virtual bool visit(TypeFunctionTypeId ty, const TypeFunctionTableType& tftt);
+    virtual bool visit(TypeFunctionTypeId ty, const TypeFunctionExternType& tfet);
+    virtual bool visit(TypeFunctionTypeId ty, const TypeFunctionGenericType& tfgt);
+
+    virtual bool visit(TypeFunctionTypePackId tp);
+    virtual bool visit(TypeFunctionTypePackId tp, const TypeFunctionTypePack& tftp);
+    virtual bool visit(TypeFunctionTypePackId tp, const TypeFunctionVariadicTypePack& tfvtp);
+    virtual bool visit(TypeFunctionTypePackId tp, const TypeFunctionGenericTypePack& tfgtp);
+
+    void run(TypeFunctionTypeId ty);
+    void run(TypeFunctionTypePackId tp);
+
+protected:
+    /// Add this type (or pack) to the queue of things to traverse. Does not
+    /// immediately process the thing!  You cannot use this to effect in-order
+    /// traversal.
+    void traverse(TypeFunctionTypeId ty);
+    void traverse(TypeFunctionTypePackId tp);
+
+private:
+    void process(TypeFunctionTypeId ty);
+    void process(TypeFunctionTypePackId tp);
+
+    bool hasSeen(const void* tv);
+    void unsee(const void* tv);
+
+    template<typename TID>
+    bool isCyclic(TID ty) const;
+
+    void processWorkQueue();
+
+    SeenSet seen{nullptr};
+
+    std::vector<WorkItem> workQueue;
+    int32_t parentCursor = -1;
+    uint32_t workCursor = 0;
+
+    const std::string visitorName;
+    bool visitOnce = true;
+};
+
+} // namespace Luau

Analysis/include/Luau/Subtyping.h

@@ -102,11 +102,18 @@ struct MappedGenericEnvironment
     bool bindGeneric(TypePackId genericTp, TypePackId bindeeTp);
 };
 
+enum class SubtypingSuppressionPolicy
+{
+    Any,
+    All
+};
+
 struct SubtypingResult
 {
     bool isSubtype = false;
     bool normalizationTooComplex = false;
     bool isCacheable = true;
+    bool isErrorSuppressing = false;
     ErrorVec errors;
     /// The reason for isSubtype to be false. May not be present even if
     /// isSubtype is false, depending on the input types.
@@ -120,7 +127,7 @@ struct SubtypingResult
     /// If any generic bounds were invalid, report them here
     std::vector<GenericBoundsMismatch> genericBoundsMismatches;
 
-    SubtypingResult& andAlso(const SubtypingResult& other);
+    SubtypingResult& andAlso(const SubtypingResult& other, SubtypingSuppressionPolicy policy = SubtypingSuppressionPolicy::Any);
     SubtypingResult& orElse(const SubtypingResult& other);
     SubtypingResult& withBothComponent(TypePath::Component component);
     SubtypingResult& withSuperComponent(TypePath::Component component);
@@ -327,6 +334,12 @@ struct Subtyping
         const FunctionType* superFunction,
         NotNull<Scope> scope
     );
+    SubtypingResult isCovariantWith(
+        SubtypingEnvironment& env,
+        const MetatableType* subMt,
+        const PrimitiveType* superPrim,
+        NotNull<Scope> scope
+    );
     SubtypingResult isCovariantWith(SubtypingEnvironment& env, const TableType* subTable, const PrimitiveType* superPrim, NotNull<Scope> scope);
     SubtypingResult isCovariantWith(SubtypingEnvironment& env, const PrimitiveType* subPrim, const TableType* superTable, NotNull<Scope> scope);
     SubtypingResult isCovariantWith(SubtypingEnvironment& env, const SingletonType* subSingleton, const TableType* superTable, NotNull<Scope> scope);

Analysis/include/Luau/ToString.h

@@ -47,6 +47,7 @@ struct ToStringOptions
     bool hideFunctionSelfArgument = false;        // If true, `self: X` will be omitted from the function signature if the function has self
     bool hideTableAliasExpansions = false;        // If true, all table aliases will not be expanded
     bool useQuestionMarks = true;                 // If true, use a postfix ? for options, else write them out as unions that include nil.
+    bool ignoreSyntheticName = false;             // If true, ignore synthetic names on table types.
     size_t maxTableLength = size_t(FInt::LuauTableTypeMaximumStringifierLength); // Only applied to TableTypes
     size_t maxTypeLength = size_t(FInt::LuauTypeMaximumStringifierLength);
     size_t compositeTypesSingleLineLimit = 5; // The number of type elements permitted on a single line when printing type unions/intersections

Analysis/include/Luau/TypeChecker2.h

@@ -104,6 +104,9 @@ struct TypeChecker2
     Reasonings explainReasonings(TypeId subTy, TypeId superTy, Location location, const SubtypingResult& r);
     Reasonings explainReasonings(TypePackId subTp, TypePackId superTp, Location location, const SubtypingResult& r);
 
+    bool testIsSubtype(TypeId subTy, TypeId superTy, Location location);
+    bool testIsSubtype(TypePackId subTy, TypePackId superTy, Location location);
+
 private:
     static bool allowsNoReturnValues(const TypePackId tp);
     static Location getEndLocation(const AstExprFunction* function);
@@ -196,9 +199,6 @@ struct TypeChecker2
 
     bool testPotentialLiteralIsSubtype(AstExpr* expr, TypeId expectedType);
 
-    bool testIsSubtype(TypeId subTy, TypeId superTy, Location location);
-    bool testIsSubtype(TypePackId subTy, TypePackId superTy, Location location);
-
     void maybeReportSubtypingError(TypeId subTy, TypeId superTy, const Location& location);
     // Tests whether subTy is a subtype of superTy in the context of a function iterator for a for-in statement.
     // Includes some extra logic to help locate errors to the values and variables of the for-in statement.

Analysis/include/Luau/TypeFunctionRuntime.h

@@ -194,6 +194,7 @@ struct TypeFunctionProperty
     static TypeFunctionProperty rw(TypeFunctionTypeId ty);                             // Shared read-write type.
     static TypeFunctionProperty rw(TypeFunctionTypeId read, TypeFunctionTypeId write); // Separate read-write type.
 
+    bool isShared() const;
     bool isReadOnly() const;
     bool isWriteOnly() const;
 
@@ -256,8 +257,9 @@ using TypeFunctionTypeVariant = Luau::Variant<
 struct TypeFunctionType
 {
     TypeFunctionTypeVariant type;
+    bool frozen = false;
 
-    TypeFunctionType(TypeFunctionTypeVariant type)
+    explicit TypeFunctionType(TypeFunctionTypeVariant type)
         : type(std::move(type))
     {
     }
@@ -327,7 +329,7 @@ TypeFunctionTypePackVar* allocateTypeFunctionTypePack(lua_State* L, TypeFunction
 void pushType(lua_State* L, TypeFunctionTypeId type);
 void pushTypePack(lua_State* L, TypeFunctionTypePackId tp);
 
-void allocTypeUserData(lua_State* L, TypeFunctionTypeVariant type);
+void allocTypeUserData(lua_State* L, TypeFunctionTypeVariant type, bool frozen = false);
 
 bool isTypeUserData(lua_State* L, int idx);
 TypeFunctionTypeId getTypeUserData(lua_State* L, int idx);

Analysis/include/Luau/TypeUtils.h

@@ -398,6 +398,8 @@ struct ContainsAnyGeneric final : public TypeOnceVisitor
     bool visit(TypeId ty) override;
     bool visit(TypePackId ty) override;
 
+    bool visit(TypeId ty, const ExternType&) override;
+
     /**
      * @returns if there is _any_ generic in `ty`
      */

Analysis/src/AstQuery.cpp

@@ -487,7 +487,7 @@ struct FindExprOrLocal : public AstVisitor
         return true;
     }
 
-    virtual bool visit(AstExprFunction* fn) override
+    bool visit(AstExprFunction* fn) override
     {
         for (size_t i = 0; i < fn->args.size; ++i)
         {
@@ -496,13 +496,13 @@ struct FindExprOrLocal : public AstVisitor
         return visit((class AstExpr*)fn);
     }
 
-    virtual bool visit(AstStatFor* forStat) override
+    bool visit(AstStatFor* forStat) override
     {
         visitLocal(forStat->var);
         return true;
     }
 
-    virtual bool visit(AstStatForIn* forIn) override
+    bool visit(AstStatForIn* forIn) override
     {
         for (AstLocal* var : forIn->vars)
         {

Analysis/src/BuiltinDefinitions.cpp

@@ -34,9 +34,9 @@
 LUAU_FASTFLAG(LuauSolverV2)
 LUAU_FASTFLAGVARIABLE(LuauTableCloneClonesType4)
 LUAU_FASTFLAG(LuauUseWorkspacePropToChooseSolver)
-LUAU_FASTFLAG(LuauBuiltinTypeFunctionsArentGlobal)
 LUAU_FASTFLAGVARIABLE(LuauCloneForIntersectionsUnions)
 LUAU_FASTFLAG(LuauStorePolarityInline)
+LUAU_FASTFLAGVARIABLE(LuauTableFreezeCheckIsSubtype)
 
 namespace Luau
 {
@@ -116,6 +116,7 @@ struct MagicFreeze final : MagicFunction
         WithPredicate<TypePackId>
     ) override;
     bool infer(const MagicFunctionCallContext& ctx) override;
+    bool typeCheck(const MagicFunctionTypeCheckContext& ctx) override;
 };
 
 struct MagicFormat final : MagicFunction
@@ -362,16 +363,8 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
     NotNull<BuiltinTypes> builtinTypes = globals.builtinTypes;
     NotNull<Scope> globalScope{globals.globalScope.get()};
 
-    if (FFlag::LuauBuiltinTypeFunctionsArentGlobal)
-    {
-        if (frontend.getLuauSolverMode() == SolverMode::New)
-            builtinTypes->typeFunctions->addToScope(NotNull{&arena}, NotNull{globals.globalScope.get()});
-    }
-    else
-    {
-        if (frontend.getLuauSolverMode() == SolverMode::New)
-            builtinTypeFunctions_DEPRECATED().addToScope(NotNull{&arena}, NotNull{globals.globalScope.get()});
-    }
+    if (frontend.getLuauSolverMode() == SolverMode::New)
+        builtinTypes->typeFunctions->addToScope(NotNull{&arena}, NotNull{globals.globalScope.get()});
 
 
     LoadDefinitionFileResult loadResult = frontend.loadDefinitionFile(
@@ -445,13 +438,7 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
     if (frontend.getLuauSolverMode() == SolverMode::New)
     {
         // getmetatable : <T>(T) -> getmetatable<T>
-        TypeId getmtReturn = arena.addType(
-            TypeFunctionInstanceType{
-                FFlag::LuauBuiltinTypeFunctionsArentGlobal ? builtinTypes->typeFunctions->getmetatableFunc
-                                                           : builtinTypeFunctions_DEPRECATED().getmetatableFunc,
-                {genericT}
-            }
-        );
+        TypeId getmtReturn = arena.addType(TypeFunctionInstanceType{builtinTypes->typeFunctions->getmetatableFunc, {genericT}});
         addGlobalBinding(globals, "getmetatable", makeFunction(arena, std::nullopt, {genericT}, {}, {genericT}, {getmtReturn}), "@luau");
     }
     else
@@ -463,13 +450,7 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
     if (frontend.getLuauSolverMode() == SolverMode::New)
     {
         // setmetatable<T: {}, MT>(T, MT) -> setmetatable<T, MT>
-        TypeId setmtReturn = arena.addType(
-            TypeFunctionInstanceType{
-                FFlag::LuauBuiltinTypeFunctionsArentGlobal ? builtinTypes->typeFunctions->setmetatableFunc
-                                                           : builtinTypeFunctions_DEPRECATED().setmetatableFunc,
-                {genericT, genericMT}
-            }
-        );
+        TypeId setmtReturn = arena.addType(TypeFunctionInstanceType{builtinTypes->typeFunctions->setmetatableFunc, {genericT, genericMT}});
         addGlobalBinding(
             globals, "setmetatable", makeFunction(arena, std::nullopt, {genericT, genericMT}, {}, {genericT, genericMT}, {setmtReturn}), "@luau"
         );
@@ -503,12 +484,7 @@ void registerBuiltinGlobals(Frontend& frontend, GlobalTypes& globals, bool typeC
 
         TypeId refinedTy = arena.addType(
             TypeFunctionInstanceType{
-                NotNull{
-                    FFlag::LuauBuiltinTypeFunctionsArentGlobal ? &builtinTypes->typeFunctions->intersectFunc
-                                                               : &builtinTypeFunctions_DEPRECATED().intersectFunc
-                },
-                {genericT, arena.addType(NegationType{builtinTypes->falsyType})},
-                {}
+                NotNull{&builtinTypes->typeFunctions->intersectFunc}, {genericT, arena.addType(NegationType{builtinTypes->falsyType})}, {}
             }
         );
 
@@ -1710,7 +1686,10 @@ static std::optional<TypeId> freezeTable(TypeId inputType, const MagicFunctionCa
         return resultType;
     }
 
-    context.solver->reportError(TypeMismatch{context.solver->builtinTypes->tableType, inputType}, context.callSite->argLocation);
+    if (!FFlag::LuauTableFreezeCheckIsSubtype)
+    {
+        context.solver->reportError(TypeMismatch{context.solver->builtinTypes->tableType, inputType}, context.callSite->argLocation);
+    }
     return std::nullopt;
 }
 
@@ -1768,6 +1747,55 @@ bool MagicFreeze::infer(const MagicFunctionCallContext& context)
     return true;
 }
 
+// MagicFreeze is a magic function because table.freeze is a bounded version of the identity function with a custom output (accepts any subtype of `table` and returns a read-only version of that table).
+bool MagicFreeze::typeCheck(const MagicFunctionTypeCheckContext& ctx)
+{
+    if (!FFlag::LuauTableFreezeCheckIsSubtype)
+        return false;
+
+    const auto& [paramTypes, paramTail] = flatten(ctx.arguments);
+
+    if (paramTypes.size() < 1 && !paramTail)
+    {
+        ctx.typechecker->reportError(CountMismatch{1, 1, 0, CountMismatch::Arg, false, "table.freeze"}, ctx.callSite->location);
+        return true;
+    }
+
+    std::optional<TypeId> firstParamType;
+
+    if (paramTypes.size() > 0)
+    {
+        firstParamType = paramTypes[0];
+    }
+    else if (paramTail)
+    {
+        // TODO (CLI-185019): We ideally want to report a Count Mismatch error if there's no head but a variadic tail, but CountMismatch requires actual count size, which we don't have with variadic tails, so we can't report it properly yet.
+        // Instead, we continue to typecheck with the first argument in the variadic tail and report a type mismatch error based on that, which is more informative than reporting a count mismatch where the head (paramTypes.size()) is 0.
+        firstParamType = first(*paramTail);
+    }
+
+    if (firstParamType)
+    {
+        // If a type is found, check if it is a subtype of table.
+        ctx.typechecker->testIsSubtype(follow(*firstParamType), ctx.builtinTypes->tableType, ctx.callSite->location);
+    }
+    else
+    {
+        // If we can't get a type from the type or type pack, we testIsSubtype against the entire context's argument type pack to report a Type Pack Mismatch error.
+        TypePackId tableTyPack = ctx.typechecker->module->internalTypes.addTypePack({ctx.typechecker->builtinTypes->tableType});
+        ctx.typechecker->testIsSubtype(follow(ctx.arguments), tableTyPack, ctx.callSite->location);
+        return true;
+    }
+
+    // Also report error if there's more than 1 argument explicitly provided to table.freeze.
+    if (paramTypes.size() > 1)
+    {
+        ctx.typechecker->reportError(CountMismatch{1, 1, ctx.callSite->args.size, CountMismatch::Arg, false, "table.freeze"}, ctx.callSite->location);
+    }
+
+    return true;
+}
+
 static bool checkRequirePath(TypeChecker& typechecker, AstExpr* expr)
 {
     // require(foo.parent.bar) will technically work, but it depends on legacy goop that