mirror of
https://github.com/luau-lang/luau.git
synced 2024-11-15 14:25:44 +08:00
218159140c
* Added support for async typechecking cancellation using a token passed through frontend options * Added luaC_enumheap for building debug tools that need a graph of Luau heap In our new typechecker: * Errors or now suppressed when checking property lookup of error-suppressing unions In our native code generation (jit): * Fixed unhandled value type in NOT_ANY lowering * Fast-call tag checks will exit to VM on failure, instead of relying on a native fallback * Added vector type to the type information * Eliminated redundant direct jumps across dead blocks * Debugger APIs are now disabled for call frames executing natively * Implemented support for unwind registration on macOS 14
1003 lines
29 KiB
C++
1003 lines
29 KiB
C++
// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
|
|
#include "Luau/Differ.h"
|
|
#include "Luau/Common.h"
|
|
#include "Luau/Error.h"
|
|
#include "Luau/Frontend.h"
|
|
|
|
#include "Fixture.h"
|
|
|
|
#include "Luau/Symbol.h"
|
|
#include "ScopedFlags.h"
|
|
#include "doctest.h"
|
|
#include <iostream>
|
|
|
|
using namespace Luau;
|
|
|
|
LUAU_FASTFLAG(DebugLuauDeferredConstraintResolution)
|
|
|
|
TEST_SUITE_BEGIN("Differ");
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "equal_numbers")
|
|
{
|
|
CheckResult result = check(R"(
|
|
local foo = 5
|
|
local almostFoo = 78
|
|
almostFoo = foo
|
|
)");
|
|
LUAU_REQUIRE_NO_ERRORS(result);
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
try
|
|
{
|
|
DifferResult diffRes = diff(foo, almostFoo);
|
|
CHECK(!diffRes.diffError.has_value());
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "equal_strings")
|
|
{
|
|
CheckResult result = check(R"(
|
|
local foo = "hello"
|
|
local almostFoo = "world"
|
|
almostFoo = foo
|
|
)");
|
|
LUAU_REQUIRE_NO_ERRORS(result);
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
try
|
|
{
|
|
DifferResult diffRes = diff(foo, almostFoo);
|
|
CHECK(!diffRes.diffError.has_value());
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "equal_tables")
|
|
{
|
|
CheckResult result = check(R"(
|
|
local foo = { x = 1, y = "where" }
|
|
local almostFoo = { x = 5, y = "when" }
|
|
almostFoo = foo
|
|
)");
|
|
LUAU_REQUIRE_NO_ERRORS(result);
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
try
|
|
{
|
|
DifferResult diffRes = diff(foo, almostFoo);
|
|
CHECK(!diffRes.diffError.has_value());
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "a_table_missing_property")
|
|
{
|
|
CheckResult result = check(R"(
|
|
local foo = { x = 1, y = 2 }
|
|
local almostFoo = { x = 1, z = 3 }
|
|
almostFoo = foo
|
|
)");
|
|
LUAU_REQUIRE_ERRORS(result);
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
diffMessage = diff(foo, almostFoo).diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ("DiffError: these two types are not equal because the left type at foo.y has type number, while the right type at almostFoo is missing "
|
|
"the property y",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "left_table_missing_property")
|
|
{
|
|
CheckResult result = check(R"(
|
|
local foo = { x = 1 }
|
|
local almostFoo = { x = 1, z = 3 }
|
|
almostFoo = foo
|
|
)");
|
|
LUAU_REQUIRE_ERRORS(result);
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
diffMessage = diff(foo, almostFoo).diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ("DiffError: these two types are not equal because the left type at foo is missing the property z, while the right type at almostFoo.z "
|
|
"has type number",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "a_table_wrong_type")
|
|
{
|
|
CheckResult result = check(R"(
|
|
local foo = { x = 1, y = 2 }
|
|
local almostFoo = { x = 1, y = "two" }
|
|
almostFoo = foo
|
|
)");
|
|
LUAU_REQUIRE_ERRORS(result);
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
diffMessage = diff(foo, almostFoo).diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ("DiffError: these two types are not equal because the left type at foo.y has type number, while the right type at almostFoo.y has type "
|
|
"string",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "a_table_wrong_type")
|
|
{
|
|
CheckResult result = check(R"(
|
|
local foo: string
|
|
local almostFoo: number
|
|
almostFoo = foo
|
|
)");
|
|
LUAU_REQUIRE_ERRORS(result);
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
diffMessage = diff(foo, almostFoo).diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ("DiffError: these two types are not equal because the left type at <unlabeled-symbol> has type string, while the right type at "
|
|
"<unlabeled-symbol> has type number",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "a_nested_table_wrong_type")
|
|
{
|
|
CheckResult result = check(R"(
|
|
local foo = { x = 1, inner = { table = { has = { wrong = { value = 5 } } } } }
|
|
local almostFoo = { x = 1, inner = { table = { has = { wrong = { value = "five" } } } } }
|
|
almostFoo = foo
|
|
)");
|
|
LUAU_REQUIRE_ERRORS(result);
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
diffMessage = diff(foo, almostFoo).diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ("DiffError: these two types are not equal because the left type at foo.inner.table.has.wrong.value has type number, while the right "
|
|
"type at almostFoo.inner.table.has.wrong.value has type string",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "a_nested_table_wrong_match")
|
|
{
|
|
CheckResult result = check(R"(
|
|
local foo = { x = 1, inner = { table = { has = { wrong = { variant = { because = { it = { goes = { on = "five" } } } } } } } } }
|
|
local almostFoo = { x = 1, inner = { table = { has = { wrong = { variant = "five" } } } } }
|
|
almostFoo = foo
|
|
)");
|
|
LUAU_REQUIRE_ERRORS(result);
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
diffMessage = diff(foo, almostFoo).diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ("DiffError: these two types are not equal because the left type at foo.inner.table.has.wrong.variant has type { because: { it: { goes: "
|
|
"{ on: string } } } }, while the right type at almostFoo.inner.table.has.wrong.variant has type string",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "singleton")
|
|
{
|
|
CheckResult result = check(R"(
|
|
local foo: "hello" = "hello"
|
|
local almostFoo: true = true
|
|
almostFoo = foo
|
|
)");
|
|
LUAU_REQUIRE_ERRORS(result);
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
diffMessage = diff(foo, almostFoo).diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ(
|
|
R"(DiffError: these two types are not equal because the left type at <unlabeled-symbol> has type "hello", while the right type at <unlabeled-symbol> has type true)",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "equal_singleton")
|
|
{
|
|
CheckResult result = check(R"(
|
|
local foo: "hello" = "hello"
|
|
local almostFoo: "hello"
|
|
almostFoo = foo
|
|
)");
|
|
LUAU_REQUIRE_NO_ERRORS(result);
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
try
|
|
{
|
|
DifferResult diffRes = diff(foo, almostFoo);
|
|
INFO(diffRes.diffError->toString());
|
|
CHECK(!diffRes.diffError.has_value());
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "singleton_string")
|
|
{
|
|
CheckResult result = check(R"(
|
|
local foo: "hello" = "hello"
|
|
local almostFoo: "world" = "world"
|
|
almostFoo = foo
|
|
)");
|
|
LUAU_REQUIRE_ERRORS(result);
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
diffMessage = diff(foo, almostFoo).diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ(
|
|
R"(DiffError: these two types are not equal because the left type at <unlabeled-symbol> has type "hello", while the right type at <unlabeled-symbol> has type "world")",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "equal_function")
|
|
{
|
|
// Old solver does not correctly infer function typepacks
|
|
ScopedFastFlag sff{"DebugLuauDeferredConstraintResolution", true};
|
|
|
|
CheckResult result = check(R"(
|
|
function foo(x: number)
|
|
return x
|
|
end
|
|
function almostFoo(y: number)
|
|
return y + 10
|
|
end
|
|
)");
|
|
LUAU_REQUIRE_NO_ERRORS(result);
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
try
|
|
{
|
|
DifferResult diffRes = diff(foo, almostFoo);
|
|
INFO(diffRes.diffError->toString());
|
|
CHECK(!diffRes.diffError.has_value());
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "equal_function_inferred_ret_length")
|
|
{
|
|
// Old solver does not correctly infer function typepacks
|
|
ScopedFastFlag sff{"DebugLuauDeferredConstraintResolution", true};
|
|
|
|
CheckResult result = check(R"(
|
|
function bar(x: number, y: string)
|
|
return x, y
|
|
end
|
|
function almostBar(a: number, b: string)
|
|
return a, b
|
|
end
|
|
function foo(x: number, y: string, z: boolean)
|
|
return z, bar(x, y)
|
|
end
|
|
function almostFoo(a: number, b: string, c: boolean)
|
|
return c, almostBar(a, b)
|
|
end
|
|
)");
|
|
LUAU_REQUIRE_NO_ERRORS(result);
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
try
|
|
{
|
|
DifferResult diffRes = diff(foo, almostFoo);
|
|
INFO(diffRes.diffError->toString());
|
|
CHECK(!diffRes.diffError.has_value());
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "equal_function_inferred_ret_length_2")
|
|
{
|
|
// Old solver does not correctly infer function typepacks
|
|
ScopedFastFlag sff{"DebugLuauDeferredConstraintResolution", true};
|
|
|
|
CheckResult result = check(R"(
|
|
function bar(x: number, y: string)
|
|
return x, y
|
|
end
|
|
function foo(x: number, y: string, z: boolean)
|
|
return bar(x, y), z
|
|
end
|
|
function almostFoo(a: number, b: string, c: boolean)
|
|
return a, c
|
|
end
|
|
)");
|
|
LUAU_REQUIRE_NO_ERRORS(result);
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
try
|
|
{
|
|
DifferResult diffRes = diff(foo, almostFoo);
|
|
INFO(diffRes.diffError->toString());
|
|
CHECK(!diffRes.diffError.has_value());
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "function_arg_normal")
|
|
{
|
|
// Old solver does not correctly infer function typepacks
|
|
ScopedFastFlag sff{"DebugLuauDeferredConstraintResolution", true};
|
|
|
|
CheckResult result = check(R"(
|
|
function foo(x: number, y: number, z: number)
|
|
return x * y * z
|
|
end
|
|
function almostFoo(a: number, b: number, msg: string)
|
|
return a
|
|
almostFoo = foo
|
|
)");
|
|
LUAU_REQUIRE_ERRORS(result);
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
diffMessage = diff(foo, almostFoo).diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ(
|
|
R"(DiffError: these two types are not equal because the left type at <unlabeled-symbol>.Arg[3] has type number, while the right type at <unlabeled-symbol>.Arg[3] has type string)",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "function_arg_normal_2")
|
|
{
|
|
// Old solver does not correctly infer function typepacks
|
|
ScopedFastFlag sff{"DebugLuauDeferredConstraintResolution", true};
|
|
|
|
CheckResult result = check(R"(
|
|
function foo(x: number, y: number, z: string)
|
|
return x * y
|
|
end
|
|
function almostFoo(a: number, y: string, msg: string)
|
|
return a
|
|
almostFoo = foo
|
|
)");
|
|
LUAU_REQUIRE_ERRORS(result);
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
diffMessage = diff(foo, almostFoo).diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ(
|
|
R"(DiffError: these two types are not equal because the left type at <unlabeled-symbol>.Arg[2] has type number, while the right type at <unlabeled-symbol>.Arg[2] has type string)",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "function_ret_normal")
|
|
{
|
|
// Old solver does not correctly infer function typepacks
|
|
ScopedFastFlag sff{"DebugLuauDeferredConstraintResolution", true};
|
|
|
|
CheckResult result = check(R"(
|
|
function foo(x: number, y: number, z: string)
|
|
return x
|
|
end
|
|
function almostFoo(a: number, b: number, msg: string)
|
|
return msg
|
|
end
|
|
)");
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
DifferResult diffRes = diff(foo, almostFoo);
|
|
if (!diffRes.diffError.has_value())
|
|
{
|
|
INFO("Differ did not report type error, even though types are unequal");
|
|
CHECK(false);
|
|
}
|
|
diffMessage = diffRes.diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ(
|
|
R"(DiffError: these two types are not equal because the left type at <unlabeled-symbol>.Ret[1] has type number, while the right type at <unlabeled-symbol>.Ret[1] has type string)",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "function_arg_length")
|
|
{
|
|
// Old solver does not correctly infer function typepacks
|
|
ScopedFastFlag sff{"DebugLuauDeferredConstraintResolution", true};
|
|
|
|
CheckResult result = check(R"(
|
|
function foo(x: number, y: number)
|
|
return x
|
|
end
|
|
function almostFoo(x: number, y: number, c: number)
|
|
return x
|
|
end
|
|
)");
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
DifferResult diffRes = diff(foo, almostFoo);
|
|
if (!diffRes.diffError.has_value())
|
|
{
|
|
INFO("Differ did not report type error, even though types are unequal");
|
|
CHECK(false);
|
|
}
|
|
diffMessage = diffRes.diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ(
|
|
R"(DiffError: these two types are not equal because the left type at <unlabeled-symbol> takes 2 or more arguments, while the right type at <unlabeled-symbol> takes 3 or more arguments)",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "function_arg_length_2")
|
|
{
|
|
// Old solver does not correctly infer function typepacks
|
|
ScopedFastFlag sff{"DebugLuauDeferredConstraintResolution", true};
|
|
|
|
CheckResult result = check(R"(
|
|
function foo(x: number, y: string, z: number)
|
|
return z
|
|
end
|
|
function almostFoo(x: number, y: string)
|
|
return x
|
|
end
|
|
)");
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
DifferResult diffRes = diff(foo, almostFoo);
|
|
if (!diffRes.diffError.has_value())
|
|
{
|
|
INFO("Differ did not report type error, even though types are unequal");
|
|
CHECK(false);
|
|
}
|
|
diffMessage = diffRes.diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ(
|
|
R"(DiffError: these two types are not equal because the left type at <unlabeled-symbol> takes 3 or more arguments, while the right type at <unlabeled-symbol> takes 2 or more arguments)",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "function_arg_length_none")
|
|
{
|
|
// Old solver does not correctly infer function typepacks
|
|
ScopedFastFlag sff{"DebugLuauDeferredConstraintResolution", true};
|
|
|
|
CheckResult result = check(R"(
|
|
function foo()
|
|
return 5
|
|
end
|
|
function almostFoo(x: number, y: string)
|
|
return x
|
|
end
|
|
)");
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
DifferResult diffRes = diff(foo, almostFoo);
|
|
if (!diffRes.diffError.has_value())
|
|
{
|
|
INFO("Differ did not report type error, even though types are unequal");
|
|
CHECK(false);
|
|
}
|
|
diffMessage = diffRes.diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ(
|
|
R"(DiffError: these two types are not equal because the left type at <unlabeled-symbol> takes 0 or more arguments, while the right type at <unlabeled-symbol> takes 2 or more arguments)",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "function_arg_length_none_2")
|
|
{
|
|
// Old solver does not correctly infer function typepacks
|
|
ScopedFastFlag sff{"DebugLuauDeferredConstraintResolution", true};
|
|
|
|
CheckResult result = check(R"(
|
|
function foo(x: number)
|
|
return x
|
|
end
|
|
function almostFoo()
|
|
return 5
|
|
end
|
|
)");
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
DifferResult diffRes = diff(foo, almostFoo);
|
|
if (!diffRes.diffError.has_value())
|
|
{
|
|
INFO("Differ did not report type error, even though types are unequal");
|
|
CHECK(false);
|
|
}
|
|
diffMessage = diffRes.diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ(
|
|
R"(DiffError: these two types are not equal because the left type at <unlabeled-symbol> takes 1 or more arguments, while the right type at <unlabeled-symbol> takes 0 or more arguments)",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "function_ret_length")
|
|
{
|
|
// Old solver does not correctly infer function typepacks
|
|
ScopedFastFlag sff{"DebugLuauDeferredConstraintResolution", true};
|
|
|
|
CheckResult result = check(R"(
|
|
function foo(x: number, y: number)
|
|
return x
|
|
end
|
|
function almostFoo(x: number, y: number)
|
|
return x, y
|
|
end
|
|
)");
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
DifferResult diffRes = diff(foo, almostFoo);
|
|
if (!diffRes.diffError.has_value())
|
|
{
|
|
INFO("Differ did not report type error, even though types are unequal");
|
|
CHECK(false);
|
|
}
|
|
diffMessage = diffRes.diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ(
|
|
R"(DiffError: these two types are not equal because the left type at <unlabeled-symbol> returns 1 values, while the right type at <unlabeled-symbol> returns 2 values)",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "function_ret_length_2")
|
|
{
|
|
// Old solver does not correctly infer function typepacks
|
|
ScopedFastFlag sff{"DebugLuauDeferredConstraintResolution", true};
|
|
|
|
CheckResult result = check(R"(
|
|
function foo(x: number, y: string, z: number)
|
|
return y, x, z
|
|
end
|
|
function almostFoo(x: number, y: string, z: number)
|
|
return y, x
|
|
end
|
|
)");
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
DifferResult diffRes = diff(foo, almostFoo);
|
|
if (!diffRes.diffError.has_value())
|
|
{
|
|
INFO("Differ did not report type error, even though types are unequal");
|
|
CHECK(false);
|
|
}
|
|
diffMessage = diffRes.diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ(
|
|
R"(DiffError: these two types are not equal because the left type at <unlabeled-symbol> returns 3 values, while the right type at <unlabeled-symbol> returns 2 values)",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "function_ret_length_none")
|
|
{
|
|
// Old solver does not correctly infer function typepacks
|
|
ScopedFastFlag sff{"DebugLuauDeferredConstraintResolution", true};
|
|
|
|
CheckResult result = check(R"(
|
|
function foo(x: number, y: string)
|
|
return
|
|
end
|
|
function almostFoo(x: number, y: string)
|
|
return x
|
|
end
|
|
)");
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
DifferResult diffRes = diff(foo, almostFoo);
|
|
if (!diffRes.diffError.has_value())
|
|
{
|
|
INFO("Differ did not report type error, even though types are unequal");
|
|
CHECK(false);
|
|
}
|
|
diffMessage = diffRes.diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ(
|
|
R"(DiffError: these two types are not equal because the left type at <unlabeled-symbol> returns 0 values, while the right type at <unlabeled-symbol> returns 1 values)",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "function_ret_length_none_2")
|
|
{
|
|
// Old solver does not correctly infer function typepacks
|
|
ScopedFastFlag sff{"DebugLuauDeferredConstraintResolution", true};
|
|
|
|
CheckResult result = check(R"(
|
|
function foo()
|
|
return 5
|
|
end
|
|
function almostFoo()
|
|
return
|
|
end
|
|
)");
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
DifferResult diffRes = diff(foo, almostFoo);
|
|
if (!diffRes.diffError.has_value())
|
|
{
|
|
INFO("Differ did not report type error, even though types are unequal");
|
|
CHECK(false);
|
|
}
|
|
diffMessage = diffRes.diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ(
|
|
R"(DiffError: these two types are not equal because the left type at <unlabeled-symbol> returns 1 values, while the right type at <unlabeled-symbol> returns 0 values)",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "function_variadic_arg_normal")
|
|
{
|
|
// Old solver does not correctly infer function typepacks
|
|
ScopedFastFlag sff{"DebugLuauDeferredConstraintResolution", true};
|
|
|
|
CheckResult result = check(R"(
|
|
function foo(x: number, y: string, ...: number)
|
|
return x, y
|
|
end
|
|
function almostFoo(a: number, b: string, ...: string)
|
|
return a, b
|
|
end
|
|
)");
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
DifferResult diffRes = diff(foo, almostFoo);
|
|
if (!diffRes.diffError.has_value())
|
|
{
|
|
INFO("Differ did not report type error, even though types are unequal");
|
|
CHECK(false);
|
|
}
|
|
diffMessage = diffRes.diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ(
|
|
R"(DiffError: these two types are not equal because the left type at <unlabeled-symbol>.Arg[Variadic] has type number, while the right type at <unlabeled-symbol>.Arg[Variadic] has type string)",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "function_variadic_arg_missing")
|
|
{
|
|
// Old solver does not correctly infer function typepacks
|
|
ScopedFastFlag sff{"DebugLuauDeferredConstraintResolution", true};
|
|
|
|
CheckResult result = check(R"(
|
|
function foo(x: number, y: string, ...: number)
|
|
return x, y
|
|
end
|
|
function almostFoo(a: number, b: string)
|
|
return a, b
|
|
end
|
|
)");
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
DifferResult diffRes = diff(foo, almostFoo);
|
|
if (!diffRes.diffError.has_value())
|
|
{
|
|
INFO("Differ did not report type error, even though types are unequal");
|
|
CHECK(false);
|
|
}
|
|
diffMessage = diffRes.diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ(
|
|
R"(DiffError: these two types are not equal because the left type at <unlabeled-symbol>.Arg[Variadic] has type number, while the right type at <unlabeled-symbol>.Arg[Variadic] has type any)",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "function_variadic_arg_missing_2")
|
|
{
|
|
// Old solver does not correctly infer function typepacks
|
|
ScopedFastFlag sff{"DebugLuauDeferredConstraintResolution", true};
|
|
|
|
CheckResult result = check(R"(
|
|
function foo(x: number, y: string)
|
|
return x, y
|
|
end
|
|
function almostFoo(a: number, b: string, ...: string)
|
|
return a, b
|
|
end
|
|
)");
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
DifferResult diffRes = diff(foo, almostFoo);
|
|
if (!diffRes.diffError.has_value())
|
|
{
|
|
INFO("Differ did not report type error, even though types are unequal");
|
|
CHECK(false);
|
|
}
|
|
diffMessage = diffRes.diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ(
|
|
R"(DiffError: these two types are not equal because the left type at <unlabeled-symbol>.Arg[Variadic] has type any, while the right type at <unlabeled-symbol>.Arg[Variadic] has type string)",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "function_variadic_oversaturation")
|
|
{
|
|
// Old solver does not correctly infer function typepacks
|
|
ScopedFastFlag sff{"DebugLuauDeferredConstraintResolution", true};
|
|
|
|
CheckResult result = check(R"(
|
|
-- allowed to be oversaturated
|
|
function foo(x: number, y: string)
|
|
return x, y
|
|
end
|
|
-- must not be oversaturated
|
|
local almostFoo: (number, string) -> (number, string) = foo
|
|
)");
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
DifferResult diffRes = diff(foo, almostFoo);
|
|
if (!diffRes.diffError.has_value())
|
|
{
|
|
INFO("Differ did not report type error, even though types are unequal");
|
|
CHECK(false);
|
|
}
|
|
diffMessage = diffRes.diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ(
|
|
R"(DiffError: these two types are not equal because the left type at <unlabeled-symbol> takes 2 or more arguments, while the right type at <unlabeled-symbol> takes 2 arguments)",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_CASE_FIXTURE(Fixture, "function_variadic_oversaturation_2")
|
|
{
|
|
// Old solver does not correctly infer function typepacks
|
|
ScopedFastFlag sff{"DebugLuauDeferredConstraintResolution", true};
|
|
|
|
CheckResult result = check(R"(
|
|
-- must not be oversaturated
|
|
local foo: (number, string) -> (number, string)
|
|
-- allowed to be oversaturated
|
|
function almostFoo(x: number, y: string)
|
|
return x, y
|
|
end
|
|
)");
|
|
|
|
TypeId foo = requireType("foo");
|
|
TypeId almostFoo = requireType("almostFoo");
|
|
std::string diffMessage;
|
|
try
|
|
{
|
|
DifferResult diffRes = diff(foo, almostFoo);
|
|
if (!diffRes.diffError.has_value())
|
|
{
|
|
INFO("Differ did not report type error, even though types are unequal");
|
|
CHECK(false);
|
|
}
|
|
diffMessage = diffRes.diffError->toString();
|
|
}
|
|
catch (const InternalCompilerError& e)
|
|
{
|
|
INFO(("InternalCompilerError: " + e.message));
|
|
CHECK(false);
|
|
}
|
|
CHECK_EQ(
|
|
R"(DiffError: these two types are not equal because the left type at <unlabeled-symbol> takes 2 arguments, while the right type at <unlabeled-symbol> takes 2 or more arguments)",
|
|
diffMessage);
|
|
}
|
|
|
|
TEST_SUITE_END();
|