mirrors/luau
1
0
Fork 0
mirror of https://github.com/luau-lang/luau.git synced 2024-11-15 22:35:43 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Sync to upstream/release/531

Browse Source
This commit is contained in:
Arseny Kapoulkine 2022-06-16 17:52:23 -07:00
parent 871a3a21c5
commit 316838f253
35 changed files with 544 additions and 474 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
Analysis/include/Luau/TypePack.h
View File

@ -48,13 +48,24 @@ struct TypePackVar
explicit TypePackVar(const TypePackVariant& ty); explicit TypePackVar(const TypePackVariant& ty);
explicit TypePackVar(TypePackVariant&& ty); explicit TypePackVar(TypePackVariant&& ty);
TypePackVar(TypePackVariant&& ty, bool persistent); TypePackVar(TypePackVariant&& ty, bool persistent);
bool operator==(const TypePackVar& rhs) const; bool operator==(const TypePackVar& rhs) const;
TypePackVar& operator=(TypePackVariant&& tp); TypePackVar& operator=(TypePackVariant&& tp);
TypePackVar& operator=(const TypePackVar& rhs);
// Re-assignes the content of the pack, but doesn't change the owning arena and can't make pack persistent.
void reassign(const TypePackVar& rhs)
{
ty = rhs.ty;
}
TypePackVariant ty; TypePackVariant ty;
bool persistent = false; bool persistent = false;
// Pointer to the type arena that allocated this type. // Pointer to the type arena that allocated this pack.
TypeArena* owningArena = nullptr; TypeArena* owningArena = nullptr;
}; };

11
Analysis/include/Luau/TypeVar.h
View File

@ -334,7 +334,6 @@ struct TableTypeVar
// We need to know which is which when we stringify types. // We need to know which is which when we stringify types.
std::optional<std::string> syntheticName; std::optional<std::string> syntheticName;
std::map<Name, Location> methodDefinitionLocations; // TODO: Remove with FFlag::LuauNoMethodLocations
std::vector<TypeId> instantiatedTypeParams; std::vector<TypeId> instantiatedTypeParams;
std::vector<TypePackId> instantiatedTypePackParams; std::vector<TypePackId> instantiatedTypePackParams;
ModuleName definitionModuleName; ModuleName definitionModuleName;
@ -465,6 +464,14 @@ struct TypeVar final
{ {
} }
// Re-assignes the content of the type, but doesn't change the owning arena and can't make type persistent.
void reassign(const TypeVar& rhs)
{
ty = rhs.ty;
normal = rhs.normal;
documentationSymbol = rhs.documentationSymbol;
}
TypeVariant ty; TypeVariant ty;
// Kludge: A persistent TypeVar is one that belongs to the global scope. // Kludge: A persistent TypeVar is one that belongs to the global scope.
@ -486,6 +493,8 @@ struct TypeVar final
TypeVar& operator=(const TypeVariant& rhs); TypeVar& operator=(const TypeVariant& rhs);
TypeVar& operator=(TypeVariant&& rhs); TypeVar& operator=(TypeVariant&& rhs);
TypeVar& operator=(const TypeVar& rhs);
}; };
using SeenSet = std::set<std::pair<const void*, const void*>>; using SeenSet = std::set<std::pair<const void*, const void*>>;

1
Analysis/include/Luau/Variant.h
View File

@ -6,6 +6,7 @@
#include <type_traits> #include <type_traits>
#include <initializer_list> #include <initializer_list>
#include <stddef.h> #include <stddef.h>
#include <utility>
namespace Luau namespace Luau
{ {

35
Analysis/src/Autocomplete.cpp
View File

@ -14,8 +14,7 @@
#include <utility> #include <utility>
LUAU_FASTFLAGVARIABLE(LuauIfElseExprFixCompletionIssue, false); LUAU_FASTFLAGVARIABLE(LuauIfElseExprFixCompletionIssue, false);
LUAU_FASTFLAGVARIABLE(LuauFixAutocompleteClassSecurityLevel, false); LUAU_FASTFLAG(LuauSelfCallAutocompleteFix2)
LUAU_FASTFLAG(LuauSelfCallAutocompleteFix)
static const std::unordered_set<std::string> kStatementStartingKeywords = { static const std::unordered_set<std::string> kStatementStartingKeywords = {
"while", "if", "local", "repeat", "function", "do", "for", "return", "break", "continue", "type", "export"}; "while", "if", "local", "repeat", "function", "do", "for", "return", "break", "continue", "type", "export"};
@ -248,7 +247,7 @@ static TypeCorrectKind checkTypeCorrectKind(const Module& module, TypeArena* typ
ty = follow(ty); ty = follow(ty);
auto canUnify = [&typeArena](TypeId subTy, TypeId superTy) { auto canUnify = [&typeArena](TypeId subTy, TypeId superTy) {
LUAU_ASSERT(!FFlag::LuauSelfCallAutocompleteFix); LUAU_ASSERT(!FFlag::LuauSelfCallAutocompleteFix2);
InternalErrorReporter iceReporter; InternalErrorReporter iceReporter;
UnifierSharedState unifierState(&iceReporter); UnifierSharedState unifierState(&iceReporter);
@ -267,7 +266,7 @@ static TypeCorrectKind checkTypeCorrectKind(const Module& module, TypeArena* typ
TypeId expectedType = follow(*typeAtPosition); TypeId expectedType = follow(*typeAtPosition);
auto checkFunctionType = [typeArena, &canUnify, &expectedType](const FunctionTypeVar* ftv) { auto checkFunctionType = [typeArena, &canUnify, &expectedType](const FunctionTypeVar* ftv) {
if (FFlag::LuauSelfCallAutocompleteFix) if (FFlag::LuauSelfCallAutocompleteFix2)
{ {
if (std::optional<TypeId> firstRetTy = first(ftv->retType)) if (std::optional<TypeId> firstRetTy = first(ftv->retType))
return checkTypeMatch(typeArena, *firstRetTy, expectedType); return checkTypeMatch(typeArena, *firstRetTy, expectedType);
@ -308,7 +307,7 @@ static TypeCorrectKind checkTypeCorrectKind(const Module& module, TypeArena* typ
} }
} }
if (FFlag::LuauSelfCallAutocompleteFix) if (FFlag::LuauSelfCallAutocompleteFix2)
return checkTypeMatch(typeArena, ty, expectedType) ? TypeCorrectKind::Correct : TypeCorrectKind::None; return checkTypeMatch(typeArena, ty, expectedType) ? TypeCorrectKind::Correct : TypeCorrectKind::None;
else else
return canUnify(ty, expectedType) ? TypeCorrectKind::Correct : TypeCorrectKind::None; return canUnify(ty, expectedType) ? TypeCorrectKind::Correct : TypeCorrectKind::None;
@ -325,7 +324,7 @@ static void autocompleteProps(const Module& module, TypeArena* typeArena, TypeId
const std::vector<AstNode*>& nodes, AutocompleteEntryMap& result, std::unordered_set<TypeId>& seen, const std::vector<AstNode*>& nodes, AutocompleteEntryMap& result, std::unordered_set<TypeId>& seen,
std::optional<const ClassTypeVar*> containingClass = std::nullopt) std::optional<const ClassTypeVar*> containingClass = std::nullopt)
{ {
if (FFlag::LuauSelfCallAutocompleteFix) if (FFlag::LuauSelfCallAutocompleteFix2)
rootTy = follow(rootTy); rootTy = follow(rootTy);
ty = follow(ty); ty = follow(ty);
@ -335,7 +334,7 @@ static void autocompleteProps(const Module& module, TypeArena* typeArena, TypeId
seen.insert(ty); seen.insert(ty);
auto isWrongIndexer_DEPRECATED = [indexType, useStrictFunctionIndexers = !!get<ClassTypeVar>(ty)](Luau::TypeId type) { auto isWrongIndexer_DEPRECATED = [indexType, useStrictFunctionIndexers = !!get<ClassTypeVar>(ty)](Luau::TypeId type) {
LUAU_ASSERT(!FFlag::LuauSelfCallAutocompleteFix); LUAU_ASSERT(!FFlag::LuauSelfCallAutocompleteFix2);
if (indexType == PropIndexType::Key) if (indexType == PropIndexType::Key)
return false; return false;
@ -368,7 +367,7 @@ static void autocompleteProps(const Module& module, TypeArena* typeArena, TypeId
} }
}; };
auto isWrongIndexer = [typeArena, rootTy, indexType](Luau::TypeId type) { auto isWrongIndexer = [typeArena, rootTy, indexType](Luau::TypeId type) {
LUAU_ASSERT(FFlag::LuauSelfCallAutocompleteFix); LUAU_ASSERT(FFlag::LuauSelfCallAutocompleteFix2);
if (indexType == PropIndexType::Key) if (indexType == PropIndexType::Key)
return false; return false;
@ -382,11 +381,16 @@ static void autocompleteProps(const Module& module, TypeArena* typeArena, TypeId
return calledWithSelf == ftv->hasSelf; return calledWithSelf == ftv->hasSelf;
} }
// If a call is made with ':', it is invalid if a function has incompatible first argument or no arguments at all
// If a call is made with '.', but it was declared with 'self', it is considered invalid if first argument is compatible
if (calledWithSelf || ftv->hasSelf)
{
if (std::optional<TypeId> firstArgTy = first(ftv->argTypes)) if (std::optional<TypeId> firstArgTy = first(ftv->argTypes))
{ {
if (checkTypeMatch(typeArena, rootTy, *firstArgTy)) if (checkTypeMatch(typeArena, rootTy, *firstArgTy))
return calledWithSelf; return calledWithSelf;
} }
}
return !calledWithSelf; return !calledWithSelf;
}; };
@ -427,7 +431,7 @@ static void autocompleteProps(const Module& module, TypeArena* typeArena, TypeId
AutocompleteEntryKind::Property, AutocompleteEntryKind::Property,
type, type,
prop.deprecated, prop.deprecated,
FFlag::LuauSelfCallAutocompleteFix ? isWrongIndexer(type) : isWrongIndexer_DEPRECATED(type), FFlag::LuauSelfCallAutocompleteFix2 ? isWrongIndexer(type) : isWrongIndexer_DEPRECATED(type),
typeCorrect, typeCorrect,
containingClass, containingClass,
&prop, &prop,
@ -462,8 +466,7 @@ static void autocompleteProps(const Module& module, TypeArena* typeArena, TypeId
containingClass = containingClass.value_or(cls); containingClass = containingClass.value_or(cls);
fillProps(cls->props); fillProps(cls->props);
if (cls->parent) if (cls->parent)
autocompleteProps(module, typeArena, rootTy, *cls->parent, indexType, nodes, result, seen, autocompleteProps(module, typeArena, rootTy, *cls->parent, indexType, nodes, result, seen, containingClass);
FFlag::LuauFixAutocompleteClassSecurityLevel ? containingClass : cls);
} }
else if (auto tbl = get<TableTypeVar>(ty)) else if (auto tbl = get<TableTypeVar>(ty))
fillProps(tbl->props); fillProps(tbl->props);
@ -471,7 +474,7 @@ static void autocompleteProps(const Module& module, TypeArena* typeArena, TypeId
{ {
autocompleteProps(module, typeArena, rootTy, mt->table, indexType, nodes, result, seen); autocompleteProps(module, typeArena, rootTy, mt->table, indexType, nodes, result, seen);
if (FFlag::LuauSelfCallAutocompleteFix) if (FFlag::LuauSelfCallAutocompleteFix2)
{ {
if (auto mtable = get<TableTypeVar>(mt->metatable)) if (auto mtable = get<TableTypeVar>(mt->metatable))
fillMetatableProps(mtable); fillMetatableProps(mtable);
@ -537,7 +540,7 @@ static void autocompleteProps(const Module& module, TypeArena* typeArena, TypeId
AutocompleteEntryMap inner; AutocompleteEntryMap inner;
std::unordered_set<TypeId> innerSeen; std::unordered_set<TypeId> innerSeen;
if (!FFlag::LuauSelfCallAutocompleteFix) if (!FFlag::LuauSelfCallAutocompleteFix2)
innerSeen = seen; innerSeen = seen;
if (isNil(*iter)) if (isNil(*iter))
@ -563,7 +566,7 @@ static void autocompleteProps(const Module& module, TypeArena* typeArena, TypeId
++iter; ++iter;
} }
} }
else if (auto pt = get<PrimitiveTypeVar>(ty); pt && FFlag::LuauSelfCallAutocompleteFix) else if (auto pt = get<PrimitiveTypeVar>(ty); pt && FFlag::LuauSelfCallAutocompleteFix2)
{ {
if (pt->metatable) if (pt->metatable)
{ {
@ -571,7 +574,7 @@ static void autocompleteProps(const Module& module, TypeArena* typeArena, TypeId
fillMetatableProps(mtable); fillMetatableProps(mtable);
} }
} }
else if (FFlag::LuauSelfCallAutocompleteFix && get<StringSingleton>(get<SingletonTypeVar>(ty))) else if (FFlag::LuauSelfCallAutocompleteFix2 && get<StringSingleton>(get<SingletonTypeVar>(ty)))
{ {
autocompleteProps(module, typeArena, rootTy, getSingletonTypes().stringType, indexType, nodes, result, seen); autocompleteProps(module, typeArena, rootTy, getSingletonTypes().stringType, indexType, nodes, result, seen);
} }
@ -1501,7 +1504,7 @@ static AutocompleteResult autocomplete(const SourceModule& sourceModule, const M
TypeId ty = follow(*it); TypeId ty = follow(*it);
PropIndexType indexType = indexName->op == ':' ? PropIndexType::Colon : PropIndexType::Point; PropIndexType indexType = indexName->op == ':' ? PropIndexType::Colon : PropIndexType::Point;
if (!FFlag::LuauSelfCallAutocompleteFix && isString(ty)) if (!FFlag::LuauSelfCallAutocompleteFix2 && isString(ty))
return {autocompleteProps(*module, typeArena, typeChecker.globalScope->bindings[AstName{"string"}].typeId, indexType, finder.ancestry), return {autocompleteProps(*module, typeArena, typeChecker.globalScope->bindings[AstName{"string"}].typeId, indexType, finder.ancestry),
finder.ancestry}; finder.ancestry};
else else

36
Analysis/src/BuiltinDefinitions.cpp
View File

@ -179,44 +179,13 @@ void registerBuiltinTypes(TypeChecker& typeChecker)
LUAU_ASSERT(!typeChecker.globalTypes.typeVars.isFrozen()); LUAU_ASSERT(!typeChecker.globalTypes.typeVars.isFrozen());
LUAU_ASSERT(!typeChecker.globalTypes.typePacks.isFrozen()); LUAU_ASSERT(!typeChecker.globalTypes.typePacks.isFrozen());
TypeId numberType = typeChecker.numberType;
TypeId booleanType = typeChecker.booleanType;
TypeId nilType = typeChecker.nilType; TypeId nilType = typeChecker.nilType;
TypeArena& arena = typeChecker.globalTypes; TypeArena& arena = typeChecker.globalTypes;
TypePackId oneNumberPack = arena.addTypePack({numberType});
TypePackId oneBooleanPack = arena.addTypePack({booleanType});
TypePackId numberVariadicList = arena.addTypePack(TypePackVar{VariadicTypePack{numberType}});
TypePackId listOfAtLeastOneNumber = arena.addTypePack(TypePack{{numberType}, numberVariadicList});
TypeId listOfAtLeastOneNumberToNumberType = arena.addType(FunctionTypeVar{
listOfAtLeastOneNumber,
oneNumberPack,
});
TypeId listOfAtLeastZeroNumbersToNumberType = arena.addType(FunctionTypeVar{numberVariadicList, oneNumberPack});
LoadDefinitionFileResult loadResult = Luau::loadDefinitionFile(typeChecker, typeChecker.globalScope, getBuiltinDefinitionSource(), "@luau"); LoadDefinitionFileResult loadResult = Luau::loadDefinitionFile(typeChecker, typeChecker.globalScope, getBuiltinDefinitionSource(), "@luau");
LUAU_ASSERT(loadResult.success); LUAU_ASSERT(loadResult.success);
TypeId mathLibType = getGlobalBinding(typeChecker, "math");
if (TableTypeVar* ttv = getMutable<TableTypeVar>(mathLibType))
{
ttv->props["min"] = makeProperty(listOfAtLeastOneNumberToNumberType, "@luau/global/math.min");
ttv->props["max"] = makeProperty(listOfAtLeastOneNumberToNumberType, "@luau/global/math.max");
}
TypeId bit32LibType = getGlobalBinding(typeChecker, "bit32");
if (TableTypeVar* ttv = getMutable<TableTypeVar>(bit32LibType))
{
ttv->props["band"] = makeProperty(listOfAtLeastZeroNumbersToNumberType, "@luau/global/bit32.band");
ttv->props["bor"] = makeProperty(listOfAtLeastZeroNumbersToNumberType, "@luau/global/bit32.bor");
ttv->props["bxor"] = makeProperty(listOfAtLeastZeroNumbersToNumberType, "@luau/global/bit32.bxor");
ttv->props["btest"] = makeProperty(arena.addType(FunctionTypeVar{listOfAtLeastOneNumber, oneBooleanPack}), "@luau/global/bit32.btest");
}
TypeId genericK = arena.addType(GenericTypeVar{"K"}); TypeId genericK = arena.addType(GenericTypeVar{"K"});
TypeId genericV = arena.addType(GenericTypeVar{"V"}); TypeId genericV = arena.addType(GenericTypeVar{"V"});
TypeId mapOfKtoV = arena.addType(TableTypeVar{{}, TableIndexer(genericK, genericV), typeChecker.globalScope->level, TableState::Generic}); TypeId mapOfKtoV = arena.addType(TableTypeVar{{}, TableIndexer(genericK, genericV), typeChecker.globalScope->level, TableState::Generic});
@ -231,7 +200,7 @@ void registerBuiltinTypes(TypeChecker& typeChecker)
addGlobalBinding(typeChecker, "string", it->second.type, "@luau"); addGlobalBinding(typeChecker, "string", it->second.type, "@luau");
// next<K, V>(t: Table<K, V>, i: K | nil) -> (K, V) // next<K, V>(t: Table<K, V>, i: K?) -> (K, V)
TypePackId nextArgsTypePack = arena.addTypePack(TypePack{{mapOfKtoV, makeOption(typeChecker, arena, genericK)}}); TypePackId nextArgsTypePack = arena.addTypePack(TypePack{{mapOfKtoV, makeOption(typeChecker, arena, genericK)}});
addGlobalBinding(typeChecker, "next", addGlobalBinding(typeChecker, "next",
arena.addType(FunctionTypeVar{{genericK, genericV}, {}, nextArgsTypePack, arena.addTypePack(TypePack{{genericK, genericV}})}), "@luau"); arena.addType(FunctionTypeVar{{genericK, genericV}, {}, nextArgsTypePack, arena.addTypePack(TypePack{{genericK, genericV}})}), "@luau");
@ -241,8 +210,7 @@ void registerBuiltinTypes(TypeChecker& typeChecker)
TypeId pairsNext = arena.addType(FunctionTypeVar{nextArgsTypePack, arena.addTypePack(TypePack{{genericK, genericV}})}); TypeId pairsNext = arena.addType(FunctionTypeVar{nextArgsTypePack, arena.addTypePack(TypePack{{genericK, genericV}})});
TypePackId pairsReturnTypePack = arena.addTypePack(TypePack{{pairsNext, mapOfKtoV, nilType}}); TypePackId pairsReturnTypePack = arena.addTypePack(TypePack{{pairsNext, mapOfKtoV, nilType}});
// NOTE we are missing 'i: K | nil' argument in the first return types' argument. // pairs<K, V>(t: Table<K, V>) -> ((Table<K, V>, K?) -> (K, V), Table<K, V>, nil)
// pairs<K, V>(t: Table<K, V>) -> ((Table<K, V>) -> (K, V), Table<K, V>, nil)
addGlobalBinding(typeChecker, "pairs", arena.addType(FunctionTypeVar{{genericK, genericV}, {}, pairsArgsTypePack, pairsReturnTypePack}), "@luau"); addGlobalBinding(typeChecker, "pairs", arena.addType(FunctionTypeVar{{genericK, genericV}, {}, pairsArgsTypePack, pairsReturnTypePack}), "@luau");
TypeId genericMT = arena.addType(GenericTypeVar{"MT"}); TypeId genericMT = arena.addType(GenericTypeVar{"MT"});

5
Analysis/src/Clone.cpp
View File

@ -9,7 +9,6 @@
LUAU_FASTFLAG(DebugLuauCopyBeforeNormalizing) LUAU_FASTFLAG(DebugLuauCopyBeforeNormalizing)
LUAU_FASTINTVARIABLE(LuauTypeCloneRecursionLimit, 300) LUAU_FASTINTVARIABLE(LuauTypeCloneRecursionLimit, 300)
LUAU_FASTFLAG(LuauNoMethodLocations)
namespace Luau namespace Luau
{ {
@ -241,8 +240,6 @@ void TypeCloner::operator()(const TableTypeVar& t)
arg = clone(arg, dest, cloneState); arg = clone(arg, dest, cloneState);
ttv->definitionModuleName = t.definitionModuleName; ttv->definitionModuleName = t.definitionModuleName;
if (!FFlag::LuauNoMethodLocations)
ttv->methodDefinitionLocations = t.methodDefinitionLocations;
ttv->tags = t.tags; ttv->tags = t.tags;
} }
@ -406,8 +403,6 @@ TypeId shallowClone(TypeId ty, TypeArena& dest, const TxnLog* log)
{ {
LUAU_ASSERT(!ttv->boundTo); LUAU_ASSERT(!ttv->boundTo);
TableTypeVar clone = TableTypeVar{ttv->props, ttv->indexer, ttv->level, ttv->state}; TableTypeVar clone = TableTypeVar{ttv->props, ttv->indexer, ttv->level, ttv->state};
if (!FFlag::LuauNoMethodLocations)
clone.methodDefinitionLocations = ttv->methodDefinitionLocations;
clone.definitionModuleName = ttv->definitionModuleName; clone.definitionModuleName = ttv->definitionModuleName;
clone.name = ttv->name; clone.name = ttv->name;
clone.syntheticName = ttv->syntheticName; clone.syntheticName = ttv->syntheticName;

8
Analysis/src/EmbeddedBuiltinDefinitions.cpp
View File

@ -7,7 +7,10 @@ namespace Luau
static const std::string kBuiltinDefinitionLuaSrc = R"BUILTIN_SRC( static const std::string kBuiltinDefinitionLuaSrc = R"BUILTIN_SRC(
declare bit32: { declare bit32: {
-- band, bor, bxor, and btest are declared in C++ band: (...number) -> number,
bor: (...number) -> number,
bxor: (...number) -> number,
btest: (number, ...number) -> boolean,
rrotate: (number, number) -> number, rrotate: (number, number) -> number,
lrotate: (number, number) -> number, lrotate: (number, number) -> number,
lshift: (number, number) -> number, lshift: (number, number) -> number,
@ -50,7 +53,8 @@ declare math: {
asin: (number) -> number, asin: (number) -> number,
atan2: (number, number) -> number, atan2: (number, number) -> number,
-- min and max are declared in C++. min: (number, ...number) -> number,
max: (number, ...number) -> number,
pi: number, pi: number,
huge: number, huge: number,

4
Analysis/src/Instantiation.cpp
View File

@ -4,8 +4,6 @@
#include "Luau/TxnLog.h" #include "Luau/TxnLog.h"
#include "Luau/TypeArena.h" #include "Luau/TypeArena.h"
LUAU_FASTFLAG(LuauNoMethodLocations)
namespace Luau namespace Luau
{ {
@ -110,8 +108,6 @@ TypeId ReplaceGenerics::clean(TypeId ty)
if (const TableTypeVar* ttv = log->getMutable<TableTypeVar>(ty)) if (const TableTypeVar* ttv = log->getMutable<TableTypeVar>(ty))
{ {
TableTypeVar clone = TableTypeVar{ttv->props, ttv->indexer, level, TableState::Free}; TableTypeVar clone = TableTypeVar{ttv->props, ttv->indexer, level, TableState::Free};
if (!FFlag::LuauNoMethodLocations)
clone.methodDefinitionLocations = ttv->methodDefinitionLocations;
clone.definitionModuleName = ttv->definitionModuleName; clone.definitionModuleName = ttv->definitionModuleName;
return addType(std::move(clone)); return addType(std::move(clone));
} }

35
Analysis/src/Quantify.cpp
View File

@ -32,41 +32,6 @@ struct Quantifier final : TypeVarOnceVisitor
LUAU_ASSERT(FFlag::DebugLuauDeferredConstraintResolution); LUAU_ASSERT(FFlag::DebugLuauDeferredConstraintResolution);
} }
void cycle(TypeId) override {}
void cycle(TypePackId) override {}
bool operator()(TypeId ty, const FreeTypeVar& ftv)
{
return visit(ty, ftv);
}
template<typename T>
bool operator()(TypeId ty, const T& t)
{
return true;
}
template<typename T>
bool operator()(TypePackId, const T&)
{
return true;
}
bool operator()(TypeId ty, const ConstrainedTypeVar&)
{
return true;
}
bool operator()(TypeId ty, const TableTypeVar& ttv)
{
return visit(ty, ttv);
}
bool operator()(TypePackId tp, const FreeTypePack& ftp)
{
return visit(tp, ftp);
}
/// @return true if outer encloses inner /// @return true if outer encloses inner
bool subsumes(Scope2* outer, Scope2* inner) bool subsumes(Scope2* outer, Scope2* inner)
{ {

3
Analysis/src/Scope.cpp
View File

@ -2,8 +2,6 @@
#include "Luau/Scope.h" #include "Luau/Scope.h"
LUAU_FASTFLAG(LuauTwoPassAliasDefinitionFix);
namespace Luau namespace Luau
{ {
@ -19,7 +17,6 @@ Scope::Scope(const ScopePtr& parent, int subLevel)
, returnType(parent->returnType) , returnType(parent->returnType)
, level(parent->level.incr()) , level(parent->level.incr())
{ {
if (FFlag::LuauTwoPassAliasDefinitionFix)
level = level.incr(); level = level.incr();
level.subLevel = subLevel; level.subLevel = subLevel;
} }

1
Analysis/src/Substitution.cpp
View File

@ -10,7 +10,6 @@
LUAU_FASTFLAG(LuauLowerBoundsCalculation) LUAU_FASTFLAG(LuauLowerBoundsCalculation)
LUAU_FASTINTVARIABLE(LuauTarjanChildLimit, 10000) LUAU_FASTINTVARIABLE(LuauTarjanChildLimit, 10000)
LUAU_FASTFLAG(LuauNoMethodLocations)
namespace Luau namespace Luau
{ {

36
Analysis/src/TxnLog.cpp
View File

@ -7,6 +7,8 @@
#include <algorithm> #include <algorithm>
#include <stdexcept> #include <stdexcept>
LUAU_FASTFLAG(LuauNonCopyableTypeVarFields)
namespace Luau namespace Luau
{ {
@ -79,20 +81,34 @@ void TxnLog::concat(TxnLog rhs)
void TxnLog::commit() void TxnLog::commit()
{ {
for (auto& [ty, rep] : typeVarChanges) for (auto& [ty, rep] : typeVarChanges)
{
if (FFlag::LuauNonCopyableTypeVarFields)
{
asMutable(ty)->reassign(rep.get()->pending);
}
else
{ {
TypeArena* owningArena = ty->owningArena; TypeArena* owningArena = ty->owningArena;
TypeVar* mtv = asMutable(ty); TypeVar* mtv = asMutable(ty);
*mtv = rep.get()->pending; *mtv = rep.get()->pending;
mtv->owningArena = owningArena; mtv->owningArena = owningArena;
} }
}
for (auto& [tp, rep] : typePackChanges) for (auto& [tp, rep] : typePackChanges)
{
if (FFlag::LuauNonCopyableTypeVarFields)
{
asMutable(tp)->reassign(rep.get()->pending);
}
else
{ {
TypeArena* owningArena = tp->owningArena; TypeArena* owningArena = tp->owningArena;
TypePackVar* mpv = asMutable(tp); TypePackVar* mpv = asMutable(tp);
*mpv = rep.get()->pending; *mpv = rep.get()->pending;
mpv->owningArena = owningArena; mpv->owningArena = owningArena;
} }
}
clear(); clear();
} }
@ -178,8 +194,13 @@ PendingType* TxnLog::queue(TypeId ty)
// about this type, we don't want to mutate the parent's state. // about this type, we don't want to mutate the parent's state.
auto& pending = typeVarChanges[ty]; auto& pending = typeVarChanges[ty];
if (!pending) if (!pending)
{
pending = std::make_unique<PendingType>(*ty); pending = std::make_unique<PendingType>(*ty);
if (FFlag::LuauNonCopyableTypeVarFields)
pending->pending.owningArena = nullptr;
}
return pending.get(); return pending.get();
} }
@ -191,8 +212,13 @@ PendingTypePack* TxnLog::queue(TypePackId tp)
// about this type, we don't want to mutate the parent's state. // about this type, we don't want to mutate the parent's state.
auto& pending = typePackChanges[tp]; auto& pending = typePackChanges[tp];
if (!pending) if (!pending)
{
pending = std::make_unique<PendingTypePack>(*tp); pending = std::make_unique<PendingTypePack>(*tp);
if (FFlag::LuauNonCopyableTypeVarFields)
pending->pending.owningArena = nullptr;
}
return pending.get(); return pending.get();
} }
@ -229,14 +255,24 @@ PendingTypePack* TxnLog::pending(TypePackId tp) const
PendingType* TxnLog::replace(TypeId ty, TypeVar replacement) PendingType* TxnLog::replace(TypeId ty, TypeVar replacement)
{ {
PendingType* newTy = queue(ty); PendingType* newTy = queue(ty);
if (FFlag::LuauNonCopyableTypeVarFields)
newTy->pending.reassign(replacement);
else
newTy->pending = replacement; newTy->pending = replacement;
return newTy; return newTy;
} }
PendingTypePack* TxnLog::replace(TypePackId tp, TypePackVar replacement) PendingTypePack* TxnLog::replace(TypePackId tp, TypePackVar replacement)
{ {
PendingTypePack* newTp = queue(tp); PendingTypePack* newTp = queue(tp);
if (FFlag::LuauNonCopyableTypeVarFields)
newTp->pending.reassign(replacement);
else
newTp->pending = replacement; newTp->pending = replacement;
return newTp; return newTp;
} }

47
Analysis/src/TypeInfer.cpp
View File

@ -33,21 +33,20 @@ LUAU_FASTFLAG(LuauAutocompleteDynamicLimits)
LUAU_FASTFLAGVARIABLE(LuauExpectedPropTypeFromIndexer, false) LUAU_FASTFLAGVARIABLE(LuauExpectedPropTypeFromIndexer, false)
LUAU_FASTFLAGVARIABLE(LuauLowerBoundsCalculation, false) LUAU_FASTFLAGVARIABLE(LuauLowerBoundsCalculation, false)
LUAU_FASTFLAGVARIABLE(DebugLuauFreezeDuringUnification, false) LUAU_FASTFLAGVARIABLE(DebugLuauFreezeDuringUnification, false)
LUAU_FASTFLAGVARIABLE(LuauSelfCallAutocompleteFix, false) LUAU_FASTFLAGVARIABLE(LuauSelfCallAutocompleteFix2, false)
LUAU_FASTFLAGVARIABLE(LuauReduceUnionRecursion, false) LUAU_FASTFLAGVARIABLE(LuauReduceUnionRecursion, false)
LUAU_FASTFLAGVARIABLE(LuauOnlyMutateInstantiatedTables, false) LUAU_FASTFLAGVARIABLE(LuauOnlyMutateInstantiatedTables, false)
LUAU_FASTFLAGVARIABLE(LuauUnsealedTableLiteral, false) LUAU_FASTFLAGVARIABLE(LuauUnsealedTableLiteral, false)
LUAU_FASTFLAGVARIABLE(LuauTwoPassAliasDefinitionFix, false)
LUAU_FASTFLAGVARIABLE(LuauReturnAnyInsteadOfICE, false) // Eventually removed as false. LUAU_FASTFLAGVARIABLE(LuauReturnAnyInsteadOfICE, false) // Eventually removed as false.
LUAU_FASTFLAG(LuauNormalizeFlagIsConservative) LUAU_FASTFLAG(LuauNormalizeFlagIsConservative)
LUAU_FASTFLAGVARIABLE(LuauReturnTypeInferenceInNonstrict, false) LUAU_FASTFLAGVARIABLE(LuauReturnTypeInferenceInNonstrict, false)
LUAU_FASTFLAGVARIABLE(LuauRecursionLimitException, false); LUAU_FASTFLAGVARIABLE(LuauRecursionLimitException, false);
LUAU_FASTFLAGVARIABLE(LuauApplyTypeFunctionFix, false); LUAU_FASTFLAGVARIABLE(LuauApplyTypeFunctionFix, false);
LUAU_FASTFLAGVARIABLE(LuauTypecheckIter, false);
LUAU_FASTFLAGVARIABLE(LuauSuccessTypingForEqualityOperations, false) LUAU_FASTFLAGVARIABLE(LuauSuccessTypingForEqualityOperations, false)
LUAU_FASTFLAGVARIABLE(LuauNoMethodLocations, false);
LUAU_FASTFLAGVARIABLE(LuauAlwaysQuantify, false); LUAU_FASTFLAGVARIABLE(LuauAlwaysQuantify, false);
LUAU_FASTFLAGVARIABLE(LuauReportErrorsOnIndexerKeyMismatch, false) LUAU_FASTFLAGVARIABLE(LuauReportErrorsOnIndexerKeyMismatch, false)
LUAU_FASTFLAGVARIABLE(LuauFalsyPredicateReturnsNilInstead, false)
LUAU_FASTFLAGVARIABLE(LuauNonCopyableTypeVarFields, false)
namespace Luau namespace Luau
{ {
@ -358,7 +357,6 @@ ModulePtr TypeChecker::checkWithoutRecursionCheck(const SourceModule& module, Mo
unifierState.cachedUnifyError.clear(); unifierState.cachedUnifyError.clear();
unifierState.skipCacheForType.clear(); unifierState.skipCacheForType.clear();
if (FFlag::LuauTwoPassAliasDefinitionFix)
duplicateTypeAliases.clear(); duplicateTypeAliases.clear();
return std::move(currentModule); return std::move(currentModule);
@ -610,7 +608,7 @@ LUAU_NOINLINE void TypeChecker::checkBlockTypeAliases(const ScopePtr& scope, std
{ {
if (const auto& typealias = stat->as<AstStatTypeAlias>()) if (const auto& typealias = stat->as<AstStatTypeAlias>())
{ {
if (FFlag::LuauTwoPassAliasDefinitionFix && typealias->name == kParseNameError) if (typealias->name == kParseNameError)
continue; continue;
auto& bindings = typealias->exported ? scope->exportedTypeBindings : scope->privateTypeBindings; auto& bindings = typealias->exported ? scope->exportedTypeBindings : scope->privateTypeBindings;
@ -618,8 +616,17 @@ LUAU_NOINLINE void TypeChecker::checkBlockTypeAliases(const ScopePtr& scope, std
Name name = typealias->name.value; Name name = typealias->name.value;
TypeId type = bindings[name].type; TypeId type = bindings[name].type;
if (get<FreeTypeVar>(follow(type))) if (get<FreeTypeVar>(follow(type)))
{
if (FFlag::LuauNonCopyableTypeVarFields)
{
TypeVar* mty = asMutable(follow(type));
mty->reassign(*errorRecoveryType(anyType));
}
else
{ {
*asMutable(type) = *errorRecoveryType(anyType); *asMutable(type) = *errorRecoveryType(anyType);
}
reportError(TypeError{typealias->location, OccursCheckFailed{}}); reportError(TypeError{typealias->location, OccursCheckFailed{}});
} }
} }
@ -1131,8 +1138,6 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatForIn& forin)
iterTy = instantiate(scope, checkExpr(scope, *firstValue).type, firstValue->location); iterTy = instantiate(scope, checkExpr(scope, *firstValue).type, firstValue->location);
} }
if (FFlag::LuauTypecheckIter)
{
if (std::optional<TypeId> iterMM = findMetatableEntry(iterTy, "__iter", firstValue->location)) if (std::optional<TypeId> iterMM = findMetatableEntry(iterTy, "__iter", firstValue->location))
{ {
// if __iter metamethod is present, it will be called and the results are going to be called as if they are functions // if __iter metamethod is present, it will be called and the results are going to be called as if they are functions
@ -1143,7 +1148,8 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatForIn& forin)
return check(loopScope, *forin.body); return check(loopScope, *forin.body);
} }
else if (const TableTypeVar* iterTable = get<TableTypeVar>(iterTy))
if (const TableTypeVar* iterTable = get<TableTypeVar>(iterTy))
{ {
// TODO: note that this doesn't cleanly handle iteration over mixed tables and tables without an indexer // TODO: note that this doesn't cleanly handle iteration over mixed tables and tables without an indexer
// this behavior is more or less consistent with what we do for pairs(), but really both are pretty wrong and need revisiting // this behavior is more or less consistent with what we do for pairs(), but really both are pretty wrong and need revisiting
@ -1170,7 +1176,6 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatForIn& forin)
return check(loopScope, *forin.body); return check(loopScope, *forin.body);
} }
}
const FunctionTypeVar* iterFunc = get<FunctionTypeVar>(iterTy); const FunctionTypeVar* iterFunc = get<FunctionTypeVar>(iterTy);
if (!iterFunc) if (!iterFunc)
@ -1334,7 +1339,7 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatTypeAlias& typealias
Name name = typealias.name.value; Name name = typealias.name.value;
// If the alias is missing a name, we can't do anything with it. Ignore it. // If the alias is missing a name, we can't do anything with it. Ignore it.
if (FFlag::LuauTwoPassAliasDefinitionFix && name == kParseNameError) if (name == kParseNameError)
return; return;
std::optional<TypeFun> binding; std::optional<TypeFun> binding;
@ -1353,7 +1358,6 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatTypeAlias& typealias
reportError(TypeError{typealias.location, DuplicateTypeDefinition{name, location}}); reportError(TypeError{typealias.location, DuplicateTypeDefinition{name, location}});
bindingsMap[name] = TypeFun{binding->typeParams, binding->typePackParams, errorRecoveryType(anyType)}; bindingsMap[name] = TypeFun{binding->typeParams, binding->typePackParams, errorRecoveryType(anyType)};
if (FFlag::LuauTwoPassAliasDefinitionFix)
duplicateTypeAliases.insert({typealias.exported, name}); duplicateTypeAliases.insert({typealias.exported, name});
} }
else else
@ -1378,7 +1382,7 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatTypeAlias& typealias
{ {
// If the first pass failed (this should mean a duplicate definition), the second pass isn't going to be // If the first pass failed (this should mean a duplicate definition), the second pass isn't going to be
// interesting. // interesting.
if (FFlag::LuauTwoPassAliasDefinitionFix && duplicateTypeAliases.find({typealias.exported, name})) if (duplicateTypeAliases.find({typealias.exported, name}))
return; return;
if (!binding) if (!binding)
@ -1422,9 +1426,6 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatTypeAlias& typealias
{ {
// This is a shallow clone, original recursive links to self are not updated // This is a shallow clone, original recursive links to self are not updated
TableTypeVar clone = TableTypeVar{ttv->props, ttv->indexer, ttv->level, ttv->state}; TableTypeVar clone = TableTypeVar{ttv->props, ttv->indexer, ttv->level, ttv->state};
if (!FFlag::LuauNoMethodLocations)
clone.methodDefinitionLocations = ttv->methodDefinitionLocations;
clone.definitionModuleName = ttv->definitionModuleName; clone.definitionModuleName = ttv->definitionModuleName;
clone.name = name; clone.name = name;
@ -1462,9 +1463,8 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatTypeAlias& typealias
} }
TypeId& bindingType = bindingsMap[name].type; TypeId& bindingType = bindingsMap[name].type;
bool ok = unify(ty, bindingType, typealias.location);
if (FFlag::LuauTwoPassAliasDefinitionFix && ok) if (unify(ty, bindingType, typealias.location))
bindingType = ty; bindingType = ty;
if (FFlag::LuauLowerBoundsCalculation) if (FFlag::LuauLowerBoundsCalculation)
@ -1532,7 +1532,7 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatDeclareClass& declar
ftv->argNames.insert(ftv->argNames.begin(), FunctionArgument{"self", {}}); ftv->argNames.insert(ftv->argNames.begin(), FunctionArgument{"self", {}});
ftv->argTypes = addTypePack(TypePack{{classTy}, ftv->argTypes}); ftv->argTypes = addTypePack(TypePack{{classTy}, ftv->argTypes});
if (FFlag::LuauSelfCallAutocompleteFix) if (FFlag::LuauSelfCallAutocompleteFix2)
ftv->hasSelf = true; ftv->hasSelf = true;
} }
} }
@ -3099,8 +3099,6 @@ TypeId TypeChecker::checkFunctionName(const ScopePtr& scope, AstExpr& funName, T
property.type = freshTy(); property.type = freshTy();
property.location = indexName->indexLocation; property.location = indexName->indexLocation;
if (!FFlag::LuauNoMethodLocations)
ttv->methodDefinitionLocations[name] = funName.location;
return property.type; return property.type;
} }
else if (funName.is<AstExprError>()) else if (funName.is<AstExprError>())
@ -4393,8 +4391,6 @@ TypeId Anyification::clean(TypeId ty)
if (const TableTypeVar* ttv = log->getMutable<TableTypeVar>(ty)) if (const TableTypeVar* ttv = log->getMutable<TableTypeVar>(ty))
{ {
TableTypeVar clone = TableTypeVar{ttv->props, ttv->indexer, ttv->level, TableState::Sealed}; TableTypeVar clone = TableTypeVar{ttv->props, ttv->indexer, ttv->level, TableState::Sealed};
if (!FFlag::LuauNoMethodLocations)
clone.methodDefinitionLocations = ttv->methodDefinitionLocations;
clone.definitionModuleName = ttv->definitionModuleName; clone.definitionModuleName = ttv->definitionModuleName;
clone.name = ttv->name; clone.name = ttv->name;
clone.syntheticName = ttv->syntheticName; clone.syntheticName = ttv->syntheticName;
@ -4705,7 +4701,10 @@ TypeIdPredicate TypeChecker::mkTruthyPredicate(bool sense)
if (isNil(ty)) if (isNil(ty))
return sense ? std::nullopt : std::optional<TypeId>(ty); return sense ? std::nullopt : std::optional<TypeId>(ty);
// at this point, anything else is kept if sense is true, or eliminated otherwise // at this point, anything else is kept if sense is true, or replaced by nil
if (FFlag::LuauFalsyPredicateReturnsNilInstead)
return sense ? ty : nilType;
else
return sense ? std::optional<TypeId>(ty) : std::nullopt; return sense ? std::optional<TypeId>(ty) : std::nullopt;
}; };
} }

21
Analysis/src/TypePack.cpp
View File

@ -5,6 +5,8 @@
#include <stdexcept> #include <stdexcept>
LUAU_FASTFLAG(LuauNonCopyableTypeVarFields)
namespace Luau namespace Luau
{ {
@ -36,6 +38,25 @@ TypePackVar& TypePackVar::operator=(TypePackVariant&& tp)
return *this; return *this;
} }
TypePackVar& TypePackVar::operator=(const TypePackVar& rhs)
{
if (FFlag::LuauNonCopyableTypeVarFields)
{
LUAU_ASSERT(owningArena == rhs.owningArena);
LUAU_ASSERT(!rhs.persistent);
reassign(rhs);
}
else
{
ty = rhs.ty;
persistent = rhs.persistent;
owningArena = rhs.owningArena;
}
return *this;
}
TypePackIterator::TypePackIterator(TypePackId typePack) TypePackIterator::TypePackIterator(TypePackId typePack)
: TypePackIterator(typePack, TxnLog::empty()) : TypePackIterator(typePack, TxnLog::empty())
{ {

21
Analysis/src/TypeVar.cpp
View File

@ -24,6 +24,7 @@ LUAU_FASTINTVARIABLE(LuauTypeMaximumStringifierLength, 500)
LUAU_FASTINTVARIABLE(LuauTableTypeMaximumStringifierLength, 0) LUAU_FASTINTVARIABLE(LuauTableTypeMaximumStringifierLength, 0)
LUAU_FASTINT(LuauTypeInferRecursionLimit) LUAU_FASTINT(LuauTypeInferRecursionLimit)
LUAU_FASTFLAG(LuauSubtypingAddOptPropsToUnsealedTables) LUAU_FASTFLAG(LuauSubtypingAddOptPropsToUnsealedTables)
LUAU_FASTFLAG(LuauNonCopyableTypeVarFields)
namespace Luau namespace Luau
{ {
@ -644,6 +645,26 @@ TypeVar& TypeVar::operator=(TypeVariant&& rhs)
return *this; return *this;
} }
TypeVar& TypeVar::operator=(const TypeVar& rhs)
{
if (FFlag::LuauNonCopyableTypeVarFields)
{
LUAU_ASSERT(owningArena == rhs.owningArena);
LUAU_ASSERT(!rhs.persistent);
reassign(rhs);
}
else
{
ty = rhs.ty;
persistent = rhs.persistent;
normal = rhs.normal;
owningArena = rhs.owningArena;
}
return *this;
}
TypeId makeFunction(TypeArena& arena, std::optional<TypeId> selfType, std::initializer_list<TypeId> generics, TypeId makeFunction(TypeArena& arena, std::optional<TypeId> selfType, std::initializer_list<TypeId> generics,
std::initializer_list<TypePackId> genericPacks, std::initializer_list<TypeId> paramTypes, std::initializer_list<std::string> paramNames, std::initializer_list<TypePackId> genericPacks, std::initializer_list<TypeId> paramTypes, std::initializer_list<std::string> paramNames,
std::initializer_list<TypeId> retTypes); std::initializer_list<TypeId> retTypes);

22
Ast/src/Parser.cpp
View File

@ -12,6 +12,7 @@ LUAU_FASTINTVARIABLE(LuauRecursionLimit, 1000)
LUAU_FASTINTVARIABLE(LuauParseErrorLimit, 100) LUAU_FASTINTVARIABLE(LuauParseErrorLimit, 100)
LUAU_FASTFLAGVARIABLE(LuauParserFunctionKeywordAsTypeHelp, false) LUAU_FASTFLAGVARIABLE(LuauParserFunctionKeywordAsTypeHelp, false)
LUAU_FASTFLAGVARIABLE(LuauReturnTypeTokenConfusion, false)
namespace Luau namespace Luau
{ {
@ -1118,8 +1119,12 @@ AstTypePack* Parser::parseTypeList(TempVector<AstType*>& result, TempVector<std:
std::optional<AstTypeList> Parser::parseOptionalReturnTypeAnnotation() std::optional<AstTypeList> Parser::parseOptionalReturnTypeAnnotation()
{ {
if (options.allowTypeAnnotations && lexer.current().type == ':') if (options.allowTypeAnnotations &&
(lexer.current().type == ':' || (FFlag::LuauReturnTypeTokenConfusion && lexer.current().type == Lexeme::SkinnyArrow)))
{ {
if (FFlag::LuauReturnTypeTokenConfusion && lexer.current().type == Lexeme::SkinnyArrow)
report(lexer.current().location, "Function return type annotations are written after ':' instead of '->'");
nextLexeme(); nextLexeme();
unsigned int oldRecursionCount = recursionCounter; unsigned int oldRecursionCount = recursionCounter;
@ -1350,8 +1355,12 @@ AstTypeOrPack Parser::parseFunctionTypeAnnotation(bool allowPack)
AstArray<AstType*> paramTypes = copy(params); AstArray<AstType*> paramTypes = copy(params);
bool returnTypeIntroducer =
FFlag::LuauReturnTypeTokenConfusion ? lexer.current().type == Lexeme::SkinnyArrow || lexer.current().type == ':' : false;
// Not a function at all. Just a parenthesized type. Or maybe a type pack with a single element // Not a function at all. Just a parenthesized type. Or maybe a type pack with a single element
if (params.size() == 1 && !varargAnnotation && monomorphic && lexer.current().type != Lexeme::SkinnyArrow) if (params.size() == 1 && !varargAnnotation && monomorphic &&
(FFlag::LuauReturnTypeTokenConfusion ? !returnTypeIntroducer : lexer.current().type != Lexeme::SkinnyArrow))
{ {
if (allowPack) if (allowPack)
return {{}, allocator.alloc<AstTypePackExplicit>(begin.location, AstTypeList{paramTypes, nullptr})}; return {{}, allocator.alloc<AstTypePackExplicit>(begin.location, AstTypeList{paramTypes, nullptr})};
@ -1359,7 +1368,7 @@ AstTypeOrPack Parser::parseFunctionTypeAnnotation(bool allowPack)
return {params[0], {}}; return {params[0], {}};
} }
if (lexer.current().type != Lexeme::SkinnyArrow && monomorphic && allowPack) if ((FFlag::LuauReturnTypeTokenConfusion ? !returnTypeIntroducer : lexer.current().type != Lexeme::SkinnyArrow) && monomorphic && allowPack)
return {{}, allocator.alloc<AstTypePackExplicit>(begin.location, AstTypeList{paramTypes, varargAnnotation})}; return {{}, allocator.alloc<AstTypePackExplicit>(begin.location, AstTypeList{paramTypes, varargAnnotation})};
AstArray<std::optional<AstArgumentName>> paramNames = copy(names); AstArray<std::optional<AstArgumentName>> paramNames = copy(names);
@ -1373,8 +1382,13 @@ AstType* Parser::parseFunctionTypeAnnotationTail(const Lexeme& begin, AstArray<A
{ {
incrementRecursionCounter("type annotation"); incrementRecursionCounter("type annotation");
if (FFlag::LuauReturnTypeTokenConfusion && lexer.current().type == ':')
{
report(lexer.current().location, "Return types in function type annotations are written after '->' instead of ':'");
lexer.next();
}
// Users occasionally write '()' as the 'unit' type when they actually want to use 'nil', here we'll try to give a more specific error // Users occasionally write '()' as the 'unit' type when they actually want to use 'nil', here we'll try to give a more specific error
if (lexer.current().type != Lexeme::SkinnyArrow && generics.size == 0 && genericPacks.size == 0 && params.size == 0) else if (lexer.current().type != Lexeme::SkinnyArrow && generics.size == 0 && genericPacks.size == 0 && params.size == 0)
{ {
report(Location(begin.location, lexer.previousLocation()), "Expected '->' after '()' when parsing function type; did you mean 'nil'?"); report(Location(begin.location, lexer.previousLocation()), "Expected '->' after '()' when parsing function type; did you mean 'nil'?");

4
Compiler/src/BytecodeBuilder.cpp
View File

@ -6,8 +6,6 @@
#include <algorithm> #include <algorithm>
#include <string.h> #include <string.h>
LUAU_FASTFLAG(LuauCompileNestedClosureO2)
namespace Luau namespace Luau
{ {
@ -390,7 +388,6 @@ int32_t BytecodeBuilder::addConstantClosure(uint32_t fid)
int16_t BytecodeBuilder::addChildFunction(uint32_t fid) int16_t BytecodeBuilder::addChildFunction(uint32_t fid)
{ {
if (FFlag::LuauCompileNestedClosureO2)
if (int16_t* cache = protoMap.find(fid)) if (int16_t* cache = protoMap.find(fid))
return *cache; return *cache;
@ -399,7 +396,6 @@ int16_t BytecodeBuilder::addChildFunction(uint32_t fid)
if (id >= kMaxClosureCount) if (id >= kMaxClosureCount)
return -1; return -1;
if (FFlag::LuauCompileNestedClosureO2)
protoMap[fid] = int16_t(id); protoMap[fid] = int16_t(id);
protos.push_back(fid); protos.push_back(fid);

117
Compiler/src/Compiler.cpp
View File

@ -16,7 +16,6 @@
#include <bitset> #include <bitset>
#include <math.h> #include <math.h>
LUAU_FASTFLAGVARIABLE(LuauCompileIter, false)
LUAU_FASTFLAGVARIABLE(LuauCompileIterNoPairs, false) LUAU_FASTFLAGVARIABLE(LuauCompileIterNoPairs, false)
LUAU_FASTINTVARIABLE(LuauCompileLoopUnrollThreshold, 25) LUAU_FASTINTVARIABLE(LuauCompileLoopUnrollThreshold, 25)
@ -26,8 +25,6 @@ LUAU_FASTINTVARIABLE(LuauCompileInlineThreshold, 25)
LUAU_FASTINTVARIABLE(LuauCompileInlineThresholdMaxBoost, 300) LUAU_FASTINTVARIABLE(LuauCompileInlineThresholdMaxBoost, 300)
LUAU_FASTINTVARIABLE(LuauCompileInlineDepth, 5) LUAU_FASTINTVARIABLE(LuauCompileInlineDepth, 5)
LUAU_FASTFLAGVARIABLE(LuauCompileNestedClosureO2, false)
namespace Luau namespace Luau
{ {
@ -172,30 +169,6 @@ struct Compiler
return node->as<AstExprFunction>(); return node->as<AstExprFunction>();
} }
bool canInlineFunctionBody(AstStat* stat)
{
if (FFlag::LuauCompileNestedClosureO2)
return true; // TODO: remove this function
struct CanInlineVisitor : AstVisitor
{
bool result = true;
bool visit(AstExprFunction* node) override
{
result = false;
// short-circuit to avoid analyzing nested closure bodies
return false;
}
};
CanInlineVisitor canInline;
stat->visit(&canInline);
return canInline.result;
}
uint32_t compileFunction(AstExprFunction* func) uint32_t compileFunction(AstExprFunction* func)
{ {
LUAU_TIMETRACE_SCOPE("Compiler::compileFunction", "Compiler"); LUAU_TIMETRACE_SCOPE("Compiler::compileFunction", "Compiler");
@ -268,7 +241,7 @@ struct Compiler
f.upvals = upvals; f.upvals = upvals;
// record information for inlining // record information for inlining
if (options.optimizationLevel >= 2 && !func->vararg && canInlineFunctionBody(func->body) && !getfenvUsed && !setfenvUsed) if (options.optimizationLevel >= 2 && !func->vararg && !getfenvUsed && !setfenvUsed)
{ {
f.canInline = true; f.canInline = true;
f.stackSize = stackSize; f.stackSize = stackSize;
@ -827,8 +800,7 @@ struct Compiler
if (pid < 0) if (pid < 0)
CompileError::raise(expr->location, "Exceeded closure limit; simplify the code to compile"); CompileError::raise(expr->location, "Exceeded closure limit; simplify the code to compile");
if (FFlag::LuauCompileNestedClosureO2) // we use a scratch vector to reduce allocations; this is safe since compileExprFunction is not reentrant
{
captures.clear(); captures.clear();
captures.reserve(f->upvals.size()); captures.reserve(f->upvals.size());
@ -884,53 +856,6 @@ struct Compiler
for (const Capture& c : captures) for (const Capture& c : captures)
bytecode.emitABC(LOP_CAPTURE, uint8_t(c.type), c.data, 0); bytecode.emitABC(LOP_CAPTURE, uint8_t(c.type), c.data, 0);
return;
}
bool shared = false;
// Optimization: when closure has no upvalues, or upvalues are safe to share, instead of allocating it every time we can share closure
// objects (this breaks assumptions about function identity which can lead to setfenv not working as expected, so we disable this when it
// is used)
if (options.optimizationLevel >= 1 && shouldShareClosure(expr) && !setfenvUsed)
{
int32_t cid = bytecode.addConstantClosure(f->id);
if (cid >= 0 && cid < 32768)
{
bytecode.emitAD(LOP_DUPCLOSURE, target, int16_t(cid));
shared = true;
}
}
if (!shared)
bytecode.emitAD(LOP_NEWCLOSURE, target, pid);
for (AstLocal* uv : f->upvals)
{
LUAU_ASSERT(uv->functionDepth < expr->functionDepth);
Variable* ul = variables.find(uv);
bool immutable = !ul || !ul->written;
if (uv->functionDepth == expr->functionDepth - 1)
{
// get local variable
int reg = getLocalReg(uv);
LUAU_ASSERT(reg >= 0);
bytecode.emitABC(LOP_CAPTURE, uint8_t(immutable ? LCT_VAL : LCT_REF), uint8_t(reg), 0);
}
else
{
// get upvalue from parent frame
// note: this will add uv to the current upvalue list if necessary
uint8_t uid = getUpval(uv);
bytecode.emitABC(LOP_CAPTURE, LCT_UPVAL, uid, 0);
}
}
} }
LuauOpcode getUnaryOp(AstExprUnary::Op op) LuauOpcode getUnaryOp(AstExprUnary::Op op)
@ -2511,30 +2436,6 @@ struct Compiler
pushLocal(stat->vars.data[i], uint8_t(vars + i)); pushLocal(stat->vars.data[i], uint8_t(vars + i));
} }
bool canUnrollForBody(AstStatFor* stat)
{
if (FFlag::LuauCompileNestedClosureO2)
return true; // TODO: remove this function
struct CanUnrollVisitor : AstVisitor
{
bool result = true;
bool visit(AstExprFunction* node) override
{
result = false;
// short-circuit to avoid analyzing nested closure bodies
return false;
}
};
CanUnrollVisitor canUnroll;
stat->body->visit(&canUnroll);
return canUnroll.result;
}
bool tryCompileUnrolledFor(AstStatFor* stat, int thresholdBase, int thresholdMaxBoost) bool tryCompileUnrolledFor(AstStatFor* stat, int thresholdBase, int thresholdMaxBoost)
{ {
Constant one = {Constant::Type_Number}; Constant one = {Constant::Type_Number};
@ -2560,12 +2461,6 @@ struct Compiler
return false; return false;
} }
if (!canUnrollForBody(stat))
{
bytecode.addDebugRemark("loop unroll failed: unsupported loop body");
return false;
}
if (Variable* lv = variables.find(stat->var); lv && lv->written) if (Variable* lv = variables.find(stat->var); lv && lv->written)
{ {
bytecode.addDebugRemark("loop unroll failed: mutable loop variable"); bytecode.addDebugRemark("loop unroll failed: mutable loop variable");
@ -2730,12 +2625,12 @@ struct Compiler
uint8_t vars = allocReg(stat, std::max(unsigned(stat->vars.size), 2u)); uint8_t vars = allocReg(stat, std::max(unsigned(stat->vars.size), 2u));
LUAU_ASSERT(vars == regs + 3); LUAU_ASSERT(vars == regs + 3);
// Optimization: when we iterate through pairs/ipairs, we generate special bytecode that optimizes the traversal using internal iteration LuauOpcode skipOp = LOP_FORGPREP;
// index These instructions dynamically check if generator is equal to next/inext and bail out They assume that the generator produces 2
// variables, which is why we allocate at least 2 above (see vars assignment)
LuauOpcode skipOp = FFlag::LuauCompileIter ? LOP_FORGPREP : LOP_JUMP;
LuauOpcode loopOp = LOP_FORGLOOP; LuauOpcode loopOp = LOP_FORGLOOP;
// Optimization: when we iterate via pairs/ipairs, we generate special bytecode that optimizes the traversal using internal iteration index
// These instructions dynamically check if generator is equal to next/inext and bail out
// They assume that the generator produces 2 variables, which is why we allocate at least 2 above (see vars assignment)
if (options.optimizationLevel >= 1 && stat->vars.size <= 2) if (options.optimizationLevel >= 1 && stat->vars.size <= 2)
{ {
if (stat->values.size == 1 && stat->values.data[0]->is<AstExprCall>()) if (stat->values.size == 1 && stat->values.data[0]->is<AstExprCall>())

106
VM/src/lapi.cpp
View File

@ -14,6 +14,26 @@
#include <string.h> #include <string.h>
/*
* This file contains most implementations of core Lua APIs from lua.h.
*
* These implementations should use api_check macros to verify that stack and type contracts hold; it's the callers
* responsibility to, for example, pass a valid table index to lua_rawgetfield. Generally errors should only be raised
* for conditions caller can't predict such as an out-of-memory error.
*
* The caller is expected to handle stack reservation (by using less than LUA_MINSTACK slots or by calling lua_checkstack).
* To ensure this is handled correctly, use api_incr_top(L) when pushing values to the stack.
*
* Functions that push any collectable objects to the stack *should* call luaC_checkthreadsleep. Failure to do this can result
* in stack references that point to dead objects since sleeping threads don't get rescanned.
*
* Functions that push newly created objects to the stack *should* call luaC_checkGC in addition to luaC_checkthreadsleep.
* Failure to do this can result in OOM since GC may never run.
*
* Note that luaC_checkGC may scan the thread and put it back to sleep; functions that call both before pushing objects must
* therefore call luaC_checkGC before luaC_checkthreadsleep to guarantee the object is pushed to an awake thread.
*/
const char* lua_ident = "$Lua: Lua 5.1.4 Copyright (C) 1994-2008 Lua.org, PUC-Rio $\n" const char* lua_ident = "$Lua: Lua 5.1.4 Copyright (C) 1994-2008 Lua.org, PUC-Rio $\n"
"$Authors: R. Ierusalimschy, L. H. de Figueiredo & W. Celes $\n" "$Authors: R. Ierusalimschy, L. H. de Figueiredo & W. Celes $\n"
"$URL: www.lua.org $\n"; "$URL: www.lua.org $\n";
@ -221,15 +241,13 @@ void lua_insert(lua_State* L, int idx)
void lua_replace(lua_State* L, int idx) void lua_replace(lua_State* L, int idx)
{ {
/* explicit test for incompatible code */
if (idx == LUA_ENVIRONINDEX && L->ci == L->base_ci)
luaG_runerror(L, "no calling environment");
api_checknelems(L, 1); api_checknelems(L, 1);
luaC_checkthreadsleep(L); luaC_checkthreadsleep(L);
StkId o = index2addr(L, idx); StkId o = index2addr(L, idx);
api_checkvalidindex(L, o); api_checkvalidindex(L, o);
if (idx == LUA_ENVIRONINDEX) if (idx == LUA_ENVIRONINDEX)
{ {
api_check(L, L->ci != L->base_ci);
Closure* func = curr_func(L); Closure* func = curr_func(L);
api_check(L, ttistable(L->top - 1)); api_check(L, ttistable(L->top - 1));
func->env = hvalue(L->top - 1); func->env = hvalue(L->top - 1);
@ -443,9 +461,7 @@ const float* lua_tovector(lua_State* L, int idx)
{ {
StkId o = index2addr(L, idx); StkId o = index2addr(L, idx);
if (!ttisvector(o)) if (!ttisvector(o))
{
return NULL; return NULL;
}
return vvalue(o); return vvalue(o);
} }
@ -460,11 +476,6 @@ int lua_objlen(lua_State* L, int idx)
return uvalue(o)->len; return uvalue(o)->len;
case LUA_TTABLE: case LUA_TTABLE:
return luaH_getn(hvalue(o)); return luaH_getn(hvalue(o));
case LUA_TNUMBER:
{
int l = (luaV_tostring(L, o) ? tsvalue(o)->len : 0);
return l;
}
default: default:
return 0; return 0;
} }
@ -752,10 +763,9 @@ void lua_setsafeenv(lua_State* L, int objindex, int enabled)
int lua_getmetatable(lua_State* L, int objindex) int lua_getmetatable(lua_State* L, int objindex)
{ {
const TValue* obj; luaC_checkthreadsleep(L);
Table* mt = NULL; Table* mt = NULL;
int res; const TValue* obj = index2addr(L, objindex);
obj = index2addr(L, objindex);
switch (ttype(obj)) switch (ttype(obj))
{ {
case LUA_TTABLE: case LUA_TTABLE:
@ -768,21 +778,18 @@ int lua_getmetatable(lua_State* L, int objindex)
mt = L->global->mt[ttype(obj)]; mt = L->global->mt[ttype(obj)];
break; break;
} }
if (mt == NULL) if (mt)
res = 0;
else
{ {
sethvalue(L, L->top, mt); sethvalue(L, L->top, mt);
api_incr_top(L); api_incr_top(L);
res = 1;
} }
return res; return mt != NULL;
} }
void lua_getfenv(lua_State* L, int idx) void lua_getfenv(lua_State* L, int idx)
{ {
StkId o; luaC_checkthreadsleep(L);
o = index2addr(L, idx); StkId o = index2addr(L, idx);
api_checkvalidindex(L, o); api_checkvalidindex(L, o);
switch (ttype(o)) switch (ttype(o))
{ {
@ -806,9 +813,8 @@ void lua_getfenv(lua_State* L, int idx)
void lua_settable(lua_State* L, int idx) void lua_settable(lua_State* L, int idx)
{ {
StkId t;
api_checknelems(L, 2); api_checknelems(L, 2);
t = index2addr(L, idx); StkId t = index2addr(L, idx);
api_checkvalidindex(L, t); api_checkvalidindex(L, t);
luaV_settable(L, t, L->top - 2, L->top - 1); luaV_settable(L, t, L->top - 2, L->top - 1);
L->top -= 2; /* pop index and value */ L->top -= 2; /* pop index and value */
@ -817,22 +823,20 @@ void lua_settable(lua_State* L, int idx)
void lua_setfield(lua_State* L, int idx, const char* k) void lua_setfield(lua_State* L, int idx, const char* k)
{ {
StkId t;
TValue key;
api_checknelems(L, 1); api_checknelems(L, 1);
t = index2addr(L, idx); StkId t = index2addr(L, idx);
api_checkvalidindex(L, t); api_checkvalidindex(L, t);
TValue key;
setsvalue(L, &key, luaS_new(L, k)); setsvalue(L, &key, luaS_new(L, k));
luaV_settable(L, t, &key, L->top - 1); luaV_settable(L, t, &key, L->top - 1);
L->top--; /* pop value */ L->top--;
return; return;
} }
void lua_rawset(lua_State* L, int idx) void lua_rawset(lua_State* L, int idx)
{ {
StkId t;
api_checknelems(L, 2); api_checknelems(L, 2);
t = index2addr(L, idx); StkId t = index2addr(L, idx);
api_check(L, ttistable(t)); api_check(L, ttistable(t));
if (hvalue(t)->readonly) if (hvalue(t)->readonly)
luaG_runerror(L, "Attempt to modify a readonly table"); luaG_runerror(L, "Attempt to modify a readonly table");
@ -844,9 +848,8 @@ void lua_rawset(lua_State* L, int idx)
void lua_rawseti(lua_State* L, int idx, int n) void lua_rawseti(lua_State* L, int idx, int n)
{ {
StkId o;
api_checknelems(L, 1); api_checknelems(L, 1);
o = index2addr(L, idx); StkId o = index2addr(L, idx);
api_check(L, ttistable(o)); api_check(L, ttistable(o));
if (hvalue(o)->readonly) if (hvalue(o)->readonly)
luaG_runerror(L, "Attempt to modify a readonly table"); luaG_runerror(L, "Attempt to modify a readonly table");
@ -858,14 +861,11 @@ void lua_rawseti(lua_State* L, int idx, int n)
int lua_setmetatable(lua_State* L, int objindex) int lua_setmetatable(lua_State* L, int objindex)
{ {
TValue* obj;
Table* mt;
api_checknelems(L, 1); api_checknelems(L, 1);
obj = index2addr(L, objindex); TValue* obj = index2addr(L, objindex);
api_checkvalidindex(L, obj); api_checkvalidindex(L, obj);
if (ttisnil(L->top - 1)) Table* mt = NULL;
mt = NULL; if (!ttisnil(L->top - 1))
else
{ {
api_check(L, ttistable(L->top - 1)); api_check(L, ttistable(L->top - 1));
mt = hvalue(L->top - 1); mt = hvalue(L->top - 1);
@ -900,10 +900,9 @@ int lua_setmetatable(lua_State* L, int objindex)
int lua_setfenv(lua_State* L, int idx) int lua_setfenv(lua_State* L, int idx)
{ {
StkId o;
int res = 1; int res = 1;
api_checknelems(L, 1); api_checknelems(L, 1);
o = index2addr(L, idx); StkId o = index2addr(L, idx);
api_checkvalidindex(L, o); api_checkvalidindex(L, o);
api_check(L, ttistable(L->top - 1)); api_check(L, ttistable(L->top - 1));
switch (ttype(o)) switch (ttype(o))
@ -970,24 +969,21 @@ static void f_call(lua_State* L, void* ud)
int lua_pcall(lua_State* L, int nargs, int nresults, int errfunc) int lua_pcall(lua_State* L, int nargs, int nresults, int errfunc)
{ {
struct CallS c;
int status;
ptrdiff_t func;
api_checknelems(L, nargs + 1); api_checknelems(L, nargs + 1);
api_check(L, L->status == 0); api_check(L, L->status == 0);
checkresults(L, nargs, nresults); checkresults(L, nargs, nresults);
if (errfunc == 0) ptrdiff_t func = 0;
func = 0; if (errfunc != 0)
else
{ {
StkId o = index2addr(L, errfunc); StkId o = index2addr(L, errfunc);
api_checkvalidindex(L, o); api_checkvalidindex(L, o);
func = savestack(L, o); func = savestack(L, o);
} }
struct CallS c;
c.func = L->top - (nargs + 1); /* function to be called */ c.func = L->top - (nargs + 1); /* function to be called */
c.nresults = nresults; c.nresults = nresults;
status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func); int status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);
adjustresults(L, nresults); adjustresults(L, nresults);
return status; return status;
@ -1247,12 +1243,10 @@ const char* lua_getupvalue(lua_State* L, int funcindex, int n)
const char* lua_setupvalue(lua_State* L, int funcindex, int n) const char* lua_setupvalue(lua_State* L, int funcindex, int n)
{ {
const char* name;
TValue* val;
StkId fi;
fi = index2addr(L, funcindex);
api_checknelems(L, 1); api_checknelems(L, 1);
name = aux_upvalue(fi, n, &val); StkId fi = index2addr(L, funcindex);
TValue* val;
const char* name = aux_upvalue(fi, n, &val);
if (name) if (name)
{ {
L->top--; L->top--;
@ -1319,14 +1313,16 @@ void lua_setuserdatadtor(lua_State* L, int tag, void (*dtor)(lua_State*, void*))
void lua_clonefunction(lua_State* L, int idx) void lua_clonefunction(lua_State* L, int idx)
{ {
luaC_checkGC(L);
luaC_checkthreadsleep(L);
StkId p = index2addr(L, idx); StkId p = index2addr(L, idx);
api_check(L, isLfunction(p)); api_check(L, isLfunction(p));
luaC_checkthreadsleep(L);
Closure* cl = clvalue(p); Closure* cl = clvalue(p);
Closure* newcl = luaF_newLclosure(L, 0, L->gt, cl->l.p); Closure* newcl = luaF_newLclosure(L, cl->nupvalues, L->gt, cl->l.p);
setclvalue(L, L->top - 1, newcl); for (int i = 0; i < cl->nupvalues; ++i)
setobj2n(L, &newcl->l.uprefs[i], &cl->l.uprefs[i]);
setclvalue(L, L->top, newcl);
api_incr_top(L);
} }
lua_Callbacks* lua_callbacks(lua_State* L) lua_Callbacks* lua_callbacks(lua_State* L)

12
VM/src/lbuiltins.cpp
View File

@ -1018,18 +1018,20 @@ static int luauF_tunpack(lua_State* L, StkId res, TValue* arg0, int nresults, St
static int luauF_vector(lua_State* L, StkId res, TValue* arg0, int nresults, StkId args, int nparams) static int luauF_vector(lua_State* L, StkId res, TValue* arg0, int nresults, StkId args, int nparams)
{ {
#if LUA_VECTOR_SIZE == 4
if (nparams >= 4 && nresults <= 1 && ttisnumber(arg0) && ttisnumber(args) && ttisnumber(args + 1) && ttisnumber(args + 2))
#else
if (nparams >= 3 && nresults <= 1 && ttisnumber(arg0) && ttisnumber(args) && ttisnumber(args + 1)) if (nparams >= 3 && nresults <= 1 && ttisnumber(arg0) && ttisnumber(args) && ttisnumber(args + 1))
#endif
{ {
double x = nvalue(arg0); double x = nvalue(arg0);
double y = nvalue(args); double y = nvalue(args);
double z = nvalue(args + 1); double z = nvalue(args + 1);
#if LUA_VECTOR_SIZE == 4 #if LUA_VECTOR_SIZE == 4
double w = nvalue(args + 2); double w = 0.0;
if (nparams >= 4)
{
if (!ttisnumber(args + 2))
return -1;
w = nvalue(args + 2);
}
setvvalue(res, float(x), float(y), float(z), float(w)); setvvalue(res, float(x), float(y), float(z), float(w));
#else #else
setvvalue(res, float(x), float(y), float(z), 0.0f); setvvalue(res, float(x), float(y), float(z), 0.0f);

21
VM/src/ldo.cpp
View File

@ -202,22 +202,29 @@ void luaD_growstack(lua_State* L, int n)
CallInfo* luaD_growCI(lua_State* L) CallInfo* luaD_growCI(lua_State* L)
{ {
if (L->size_ci > LUAI_MAXCALLS) /* overflow while handling overflow? */ /* allow extra stack space to handle stack overflow in xpcall */
luaD_throw(L, LUA_ERRERR); const int hardlimit = LUAI_MAXCALLS + (LUAI_MAXCALLS >> 3);
else
{ if (L->size_ci >= hardlimit)
luaD_reallocCI(L, 2 * L->size_ci); luaD_throw(L, LUA_ERRERR); /* error while handling stack error */
int request = L->size_ci * 2;
luaD_reallocCI(L, L->size_ci >= LUAI_MAXCALLS ? hardlimit : request < LUAI_MAXCALLS ? request : LUAI_MAXCALLS);
if (L->size_ci > LUAI_MAXCALLS) if (L->size_ci > LUAI_MAXCALLS)
luaG_runerror(L, "stack overflow"); luaG_runerror(L, "stack overflow");
}
return ++L->ci; return ++L->ci;
} }
void luaD_checkCstack(lua_State* L) void luaD_checkCstack(lua_State* L)
{ {
/* allow extra stack space to handle stack overflow in xpcall */
const int hardlimit = LUAI_MAXCCALLS + (LUAI_MAXCCALLS >> 3);
if (L->nCcalls == LUAI_MAXCCALLS) if (L->nCcalls == LUAI_MAXCCALLS)
luaG_runerror(L, "C stack overflow"); luaG_runerror(L, "C stack overflow");
else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS >> 3))) else if (L->nCcalls >= hardlimit)
luaD_throw(L, LUA_ERRERR); /* error while handling stack error */ luaD_throw(L, LUA_ERRERR); /* error while handling stack error */
} }

19
VM/src/lvmexecute.cpp
View File

@ -16,8 +16,6 @@
#include <string.h> #include <string.h>
LUAU_FASTFLAGVARIABLE(LuauIter, false)
// Disable c99-designator to avoid the warning in CGOTO dispatch table // Disable c99-designator to avoid the warning in CGOTO dispatch table
#ifdef __clang__ #ifdef __clang__
#if __has_warning("-Wc99-designator") #if __has_warning("-Wc99-designator")
@ -2214,7 +2212,7 @@ static void luau_execute(lua_State* L)
{ {
/* will be called during FORGLOOP */ /* will be called during FORGLOOP */
} }
else if (FFlag::LuauIter) else
{ {
Table* mt = ttistable(ra) ? hvalue(ra)->metatable : ttisuserdata(ra) ? uvalue(ra)->metatable : cast_to(Table*, NULL); Table* mt = ttistable(ra) ? hvalue(ra)->metatable : ttisuserdata(ra) ? uvalue(ra)->metatable : cast_to(Table*, NULL);
@ -2259,17 +2257,6 @@ static void luau_execute(lua_State* L)
StkId ra = VM_REG(LUAU_INSN_A(insn)); StkId ra = VM_REG(LUAU_INSN_A(insn));
uint32_t aux = *pc; uint32_t aux = *pc;
if (!FFlag::LuauIter)
{
bool stop;
VM_PROTECT(stop = luau_loopFORG(L, LUAU_INSN_A(insn), aux));
// note that we need to increment pc by 1 to exit the loop since we need to skip over aux
pc += stop ? 1 : LUAU_INSN_D(insn);
LUAU_ASSERT(unsigned(pc - cl->l.p->code) < unsigned(cl->l.p->sizecode));
VM_NEXT();
}
// fast-path: builtin table iteration // fast-path: builtin table iteration
if (ttisnil(ra) && ttistable(ra + 1) && ttislightuserdata(ra + 2)) if (ttisnil(ra) && ttistable(ra + 1) && ttislightuserdata(ra + 2))
{ {
@ -2362,7 +2349,7 @@ static void luau_execute(lua_State* L)
/* ra+1 is already the table */ /* ra+1 is already the table */
setpvalue(ra + 2, reinterpret_cast<void*>(uintptr_t(0))); setpvalue(ra + 2, reinterpret_cast<void*>(uintptr_t(0)));
} }
else if (FFlag::LuauIter && !ttisfunction(ra)) else if (!ttisfunction(ra))
{ {
VM_PROTECT(luaG_typeerror(L, ra, "iterate over")); VM_PROTECT(luaG_typeerror(L, ra, "iterate over"));
} }
@ -2434,7 +2421,7 @@ static void luau_execute(lua_State* L)
/* ra+1 is already the table */ /* ra+1 is already the table */
setpvalue(ra + 2, reinterpret_cast<void*>(uintptr_t(0))); setpvalue(ra + 2, reinterpret_cast<void*>(uintptr_t(0)));
} }
else if (FFlag::LuauIter && !ttisfunction(ra)) else if (!ttisfunction(ra))
{ {
VM_PROTECT(luaG_typeerror(L, ra, "iterate over")); VM_PROTECT(luaG_typeerror(L, ra, "iterate over"));
} }

37
tests/Autocomplete.test.cpp
View File

@ -2764,8 +2764,6 @@ TEST_CASE_FIXTURE(ACBuiltinsFixture, "autocomplete_on_string_singletons")
TEST_CASE_FIXTURE(ACFixture, "autocomplete_string_singletons") TEST_CASE_FIXTURE(ACFixture, "autocomplete_string_singletons")
{ {
ScopedFastFlag sff{"LuauTwoPassAliasDefinitionFix", true};
check(R"( check(R"(
type tag = "cat" | "dog" type tag = "cat" | "dog"
local function f(a: tag) end local function f(a: tag) end
@ -2838,8 +2836,6 @@ f(@1)
TEST_CASE_FIXTURE(ACFixture, "autocomplete_string_singleton_escape") TEST_CASE_FIXTURE(ACFixture, "autocomplete_string_singleton_escape")
{ {
ScopedFastFlag sff{"LuauTwoPassAliasDefinitionFix", true};
check(R"( check(R"(
type tag = "strange\t\"cat\"" | 'nice\t"dog"' type tag = "strange\t\"cat\"" | 'nice\t"dog"'
local function f(x: tag) end local function f(x: tag) end
@ -2873,7 +2869,7 @@ local abc = b@1
TEST_CASE_FIXTURE(ACFixture, "no_incompatible_self_calls_on_class") TEST_CASE_FIXTURE(ACFixture, "no_incompatible_self_calls_on_class")
{ {
ScopedFastFlag selfCallAutocompleteFix{"LuauSelfCallAutocompleteFix", true}; ScopedFastFlag selfCallAutocompleteFix2{"LuauSelfCallAutocompleteFix2", true};
loadDefinition(R"( loadDefinition(R"(
declare class Foo declare class Foo
@ -2913,7 +2909,7 @@ t.@1
TEST_CASE_FIXTURE(ACFixture, "no_incompatible_self_calls") TEST_CASE_FIXTURE(ACFixture, "no_incompatible_self_calls")
{ {
ScopedFastFlag selfCallAutocompleteFix{"LuauSelfCallAutocompleteFix", true}; ScopedFastFlag selfCallAutocompleteFix2{"LuauSelfCallAutocompleteFix2", true};
check(R"( check(R"(
local t = {} local t = {}
@ -2929,7 +2925,7 @@ t:@1
TEST_CASE_FIXTURE(ACFixture, "no_incompatible_self_calls_2") TEST_CASE_FIXTURE(ACFixture, "no_incompatible_self_calls_2")
{ {
ScopedFastFlag selfCallAutocompleteFix{"LuauSelfCallAutocompleteFix", true}; ScopedFastFlag selfCallAutocompleteFix2{"LuauSelfCallAutocompleteFix2", true};
check(R"( check(R"(
local f: (() -> number) & ((number) -> number) = function(x: number?) return 2 end local f: (() -> number) & ((number) -> number) = function(x: number?) return 2 end
@ -2961,7 +2957,7 @@ t:@1
TEST_CASE_FIXTURE(ACFixture, "string_prim_self_calls_are_fine") TEST_CASE_FIXTURE(ACFixture, "string_prim_self_calls_are_fine")
{ {
ScopedFastFlag selfCallAutocompleteFix{"LuauSelfCallAutocompleteFix", true}; ScopedFastFlag selfCallAutocompleteFix2{"LuauSelfCallAutocompleteFix2", true};
check(R"( check(R"(
local s = "hello" local s = "hello"
@ -2980,7 +2976,7 @@ s:@1
TEST_CASE_FIXTURE(ACFixture, "string_prim_non_self_calls_are_avoided") TEST_CASE_FIXTURE(ACFixture, "string_prim_non_self_calls_are_avoided")
{ {
ScopedFastFlag selfCallAutocompleteFix{"LuauSelfCallAutocompleteFix", true}; ScopedFastFlag selfCallAutocompleteFix2{"LuauSelfCallAutocompleteFix2", true};
check(R"( check(R"(
local s = "hello" local s = "hello"
@ -2989,17 +2985,15 @@ s.@1
auto ac = autocomplete('1'); auto ac = autocomplete('1');
REQUIRE(ac.entryMap.count("byte"));
CHECK(ac.entryMap["byte"].wrongIndexType == true);
REQUIRE(ac.entryMap.count("char")); REQUIRE(ac.entryMap.count("char"));
CHECK(ac.entryMap["char"].wrongIndexType == false); CHECK(ac.entryMap["char"].wrongIndexType == false);
REQUIRE(ac.entryMap.count("sub")); REQUIRE(ac.entryMap.count("sub"));
CHECK(ac.entryMap["sub"].wrongIndexType == true); CHECK(ac.entryMap["sub"].wrongIndexType == true);
} }
TEST_CASE_FIXTURE(ACBuiltinsFixture, "string_library_non_self_calls_are_fine") TEST_CASE_FIXTURE(ACBuiltinsFixture, "library_non_self_calls_are_fine")
{ {
ScopedFastFlag selfCallAutocompleteFix{"LuauSelfCallAutocompleteFix", true}; ScopedFastFlag selfCallAutocompleteFix2{"LuauSelfCallAutocompleteFix2", true};
check(R"( check(R"(
string.@1 string.@1
@ -3013,11 +3007,24 @@ string.@1
CHECK(ac.entryMap["char"].wrongIndexType == false); CHECK(ac.entryMap["char"].wrongIndexType == false);
REQUIRE(ac.entryMap.count("sub")); REQUIRE(ac.entryMap.count("sub"));
CHECK(ac.entryMap["sub"].wrongIndexType == false); CHECK(ac.entryMap["sub"].wrongIndexType == false);
check(R"(
table.@1
)");
ac = autocomplete('1');
REQUIRE(ac.entryMap.count("remove"));
CHECK(ac.entryMap["remove"].wrongIndexType == false);
REQUIRE(ac.entryMap.count("getn"));
CHECK(ac.entryMap["getn"].wrongIndexType == false);
REQUIRE(ac.entryMap.count("insert"));
CHECK(ac.entryMap["insert"].wrongIndexType == false);
} }
TEST_CASE_FIXTURE(ACBuiltinsFixture, "string_library_self_calls_are_invalid") TEST_CASE_FIXTURE(ACBuiltinsFixture, "library_self_calls_are_invalid")
{ {
ScopedFastFlag selfCallAutocompleteFix{"LuauSelfCallAutocompleteFix", true}; ScopedFastFlag selfCallAutocompleteFix2{"LuauSelfCallAutocompleteFix2", true};
check(R"( check(R"(
string:@1 string:@1

13
tests/Compiler.test.cpp
View File

@ -261,7 +261,6 @@ L1: RETURN R0 0
TEST_CASE("ForBytecode") TEST_CASE("ForBytecode")
{ {
ScopedFastFlag sff("LuauCompileIter", true);
ScopedFastFlag sff2("LuauCompileIterNoPairs", false); ScopedFastFlag sff2("LuauCompileIterNoPairs", false);
// basic for loop: variable directly refers to internal iteration index (R2) // basic for loop: variable directly refers to internal iteration index (R2)
@ -350,8 +349,6 @@ RETURN R0 0
TEST_CASE("ForBytecodeBuiltin") TEST_CASE("ForBytecodeBuiltin")
{ {
ScopedFastFlag sff("LuauCompileIter", true);
// we generally recognize builtins like pairs/ipairs and emit special opcodes // we generally recognize builtins like pairs/ipairs and emit special opcodes
CHECK_EQ("\n" + compileFunction0("for k,v in ipairs({}) do end"), R"( CHECK_EQ("\n" + compileFunction0("for k,v in ipairs({}) do end"), R"(
GETIMPORT R0 1 GETIMPORT R0 1
@ -2323,8 +2320,6 @@ return result
TEST_CASE("DebugLineInfoFor") TEST_CASE("DebugLineInfoFor")
{ {
ScopedFastFlag sff("LuauCompileIter", true);
Luau::BytecodeBuilder bcb; Luau::BytecodeBuilder bcb;
bcb.setDumpFlags(Luau::BytecodeBuilder::Dump_Code | Luau::BytecodeBuilder::Dump_Lines); bcb.setDumpFlags(Luau::BytecodeBuilder::Dump_Code | Luau::BytecodeBuilder::Dump_Lines);
Luau::compileOrThrow(bcb, R"( Luau::compileOrThrow(bcb, R"(
@ -4355,8 +4350,6 @@ L1: RETURN R0 0
TEST_CASE("LoopUnrollControlFlow") TEST_CASE("LoopUnrollControlFlow")
{ {
ScopedFastFlag sff("LuauCompileNestedClosureO2", true);
ScopedFastInt sfis[] = { ScopedFastInt sfis[] = {
{"LuauCompileLoopUnrollThreshold", 50}, {"LuauCompileLoopUnrollThreshold", 50},
{"LuauCompileLoopUnrollThresholdMaxBoost", 300}, {"LuauCompileLoopUnrollThresholdMaxBoost", 300},
@ -4475,8 +4468,6 @@ RETURN R0 0
TEST_CASE("LoopUnrollNestedClosure") TEST_CASE("LoopUnrollNestedClosure")
{ {
ScopedFastFlag sff("LuauCompileNestedClosureO2", true);
// if the body has functions that refer to loop variables, we unroll the loop and use MOVE+CAPTURE for upvalues // if the body has functions that refer to loop variables, we unroll the loop and use MOVE+CAPTURE for upvalues
CHECK_EQ("\n" + compileFunction(R"( CHECK_EQ("\n" + compileFunction(R"(
for i=1,2 do for i=1,2 do
@ -4756,8 +4747,6 @@ RETURN R1 1
TEST_CASE("InlineBasicProhibited") TEST_CASE("InlineBasicProhibited")
{ {
ScopedFastFlag sff("LuauCompileNestedClosureO2", true);
// we can't inline variadic functions // we can't inline variadic functions
CHECK_EQ("\n" + compileFunction(R"( CHECK_EQ("\n" + compileFunction(R"(
local function foo(...) local function foo(...)
@ -4833,8 +4822,6 @@ RETURN R1 1
TEST_CASE("InlineNestedClosures") TEST_CASE("InlineNestedClosures")
{ {
ScopedFastFlag sff("LuauCompileNestedClosureO2", true);
// we can inline functions that contain/return functions // we can inline functions that contain/return functions
CHECK_EQ("\n" + compileFunction(R"( CHECK_EQ("\n" + compileFunction(R"(
local function foo(x) local function foo(x)

59
tests/Conformance.test.cpp
View File

@ -741,7 +741,7 @@ TEST_CASE("ApiTables")
lua_pop(L, 1); lua_pop(L, 1);
} }
TEST_CASE("ApiFunctionCalls") TEST_CASE("ApiCalls")
{ {
StateRef globalState = runConformance("apicalls.lua"); StateRef globalState = runConformance("apicalls.lua");
lua_State* L = globalState.get(); lua_State* L = globalState.get();
@ -790,6 +790,58 @@ TEST_CASE("ApiFunctionCalls")
CHECK(lua_equal(L2, -1, -2) == 1); CHECK(lua_equal(L2, -1, -2) == 1);
lua_pop(L2, 2); lua_pop(L2, 2);
} }
// lua_clonefunction + fenv
{
lua_getfield(L, LUA_GLOBALSINDEX, "getpi");
lua_call(L, 0, 1);
CHECK(lua_tonumber(L, -1) == 3.1415926);
lua_pop(L, 1);
lua_getfield(L, LUA_GLOBALSINDEX, "getpi");
// clone & override env
lua_clonefunction(L, -1);
lua_newtable(L);
lua_pushnumber(L, 42);
lua_setfield(L, -2, "pi");
lua_setfenv(L, -2);
lua_call(L, 0, 1);
CHECK(lua_tonumber(L, -1) == 42);
lua_pop(L, 1);
// this one calls original function again
lua_call(L, 0, 1);
CHECK(lua_tonumber(L, -1) == 3.1415926);
lua_pop(L, 1);
}
// lua_clonefunction + upvalues
{
lua_getfield(L, LUA_GLOBALSINDEX, "incuv");
lua_call(L, 0, 1);
CHECK(lua_tonumber(L, -1) == 1);
lua_pop(L, 1);
lua_getfield(L, LUA_GLOBALSINDEX, "incuv");
// two clones
lua_clonefunction(L, -1);
lua_clonefunction(L, -2);
lua_call(L, 0, 1);
CHECK(lua_tonumber(L, -1) == 2);
lua_pop(L, 1);
lua_call(L, 0, 1);
CHECK(lua_tonumber(L, -1) == 3);
lua_pop(L, 1);
// this one calls original function again
lua_call(L, 0, 1);
CHECK(lua_tonumber(L, -1) == 4);
lua_pop(L, 1);
}
} }
static bool endsWith(const std::string& str, const std::string& suffix) static bool endsWith(const std::string& str, const std::string& suffix)
@ -1113,11 +1165,6 @@ TEST_CASE("UserdataApi")
TEST_CASE("Iter") TEST_CASE("Iter")
{ {
ScopedFastFlag sffs[] = {
{"LuauCompileIter", true},
{"LuauIter", true},
};
runConformance("iter.lua"); runConformance("iter.lua");
} }

20
tests/Module.test.cpp
View File

@ -300,4 +300,24 @@ TEST_CASE_FIXTURE(Fixture, "clone_recursion_limit")
CHECK_THROWS_AS(clone(table, dest, cloneState), RecursionLimitException); CHECK_THROWS_AS(clone(table, dest, cloneState), RecursionLimitException);
} }
TEST_CASE_FIXTURE(Fixture, "any_persistance_does_not_leak")
{
ScopedFastFlag luauNonCopyableTypeVarFields{"LuauNonCopyableTypeVarFields", true};
fileResolver.source["Module/A"] = R"(
export type A = B
type B = A
)";
FrontendOptions opts;
opts.retainFullTypeGraphs = false;
CheckResult result = frontend.check("Module/A", opts);
LUAU_REQUIRE_ERRORS(result);
auto mod = frontend.moduleResolver.getModule("Module/A");
auto it = mod->getModuleScope()->exportedTypeBindings.find("A");
REQUIRE(it != mod->getModuleScope()->exportedTypeBindings.end());
CHECK(toString(it->second.type) == "any");
}
TEST_SUITE_END(); TEST_SUITE_END();

17
tests/Parser.test.cpp
View File

@ -2622,6 +2622,23 @@ type Z<T> = { a: string | T..., b: number }
REQUIRE_EQ(3, result.errors.size()); REQUIRE_EQ(3, result.errors.size());
} }
TEST_CASE_FIXTURE(Fixture, "recover_function_return_type_annotations")
{
ScopedFastFlag sff{"LuauReturnTypeTokenConfusion", true};
ParseResult result = tryParse(R"(
type Custom<A, B, C> = { x: A, y: B, z: C }
type Packed<A...> = { x: (A...) -> () }
type F = (number): Custom<boolean, number, string>
type G = Packed<(number): (string, number, boolean)>
local function f(x: number) -> Custom<string, boolean, number>
end
)");
REQUIRE_EQ(3, result.errors.size());
CHECK_EQ(result.errors[0].getMessage(), "Return types in function type annotations are written after '->' instead of ':'");
CHECK_EQ(result.errors[1].getMessage(), "Return types in function type annotations are written after '->' instead of ':'");
CHECK_EQ(result.errors[2].getMessage(), "Function return type annotations are written after ':' instead of '->'");
}
TEST_CASE_FIXTURE(Fixture, "error_message_for_using_function_as_type_annotation") TEST_CASE_FIXTURE(Fixture, "error_message_for_using_function_as_type_annotation")
{ {
ScopedFastFlag sff{"LuauParserFunctionKeywordAsTypeHelp", true}; ScopedFastFlag sff{"LuauParserFunctionKeywordAsTypeHelp", true};

6
tests/TypeInfer.aliases.test.cpp
View File

@ -615,8 +615,6 @@ TEST_CASE_FIXTURE(Fixture, "generic_typevars_are_not_considered_to_escape_their_
*/ */
TEST_CASE_FIXTURE(Fixture, "forward_declared_alias_is_not_clobbered_by_prior_unification_with_any") TEST_CASE_FIXTURE(Fixture, "forward_declared_alias_is_not_clobbered_by_prior_unification_with_any")
{ {
ScopedFastFlag sff[] = {{"LuauTwoPassAliasDefinitionFix", true}};
CheckResult result = check(R"( CheckResult result = check(R"(
local function x() local function x()
local y: FutureType = {}::any local y: FutureType = {}::any
@ -633,10 +631,6 @@ TEST_CASE_FIXTURE(Fixture, "forward_declared_alias_is_not_clobbered_by_prior_uni
TEST_CASE_FIXTURE(Fixture, "forward_declared_alias_is_not_clobbered_by_prior_unification_with_any_2") TEST_CASE_FIXTURE(Fixture, "forward_declared_alias_is_not_clobbered_by_prior_unification_with_any_2")
{ {
ScopedFastFlag sff[] = {
{"LuauTwoPassAliasDefinitionFix", true},
};
CheckResult result = check(R"( CheckResult result = check(R"(
local B = {} local B = {}
B.bar = 4 B.bar = 4

8
tests/TypeInfer.loops.test.cpp
View File

@ -486,8 +486,6 @@ TEST_CASE_FIXTURE(Fixture, "fuzz_fail_missing_instantitation_follow")
TEST_CASE_FIXTURE(Fixture, "loop_iter_basic") TEST_CASE_FIXTURE(Fixture, "loop_iter_basic")
{ {
ScopedFastFlag sff{"LuauTypecheckIter", true};
CheckResult result = check(R"( CheckResult result = check(R"(
local t: {string} = {} local t: {string} = {}
local key local key
@ -506,8 +504,6 @@ TEST_CASE_FIXTURE(Fixture, "loop_iter_basic")
TEST_CASE_FIXTURE(Fixture, "loop_iter_trailing_nil") TEST_CASE_FIXTURE(Fixture, "loop_iter_trailing_nil")
{ {
ScopedFastFlag sff{"LuauTypecheckIter", true};
CheckResult result = check(R"( CheckResult result = check(R"(
local t: {string} = {} local t: {string} = {}
local extra local extra
@ -522,8 +518,6 @@ TEST_CASE_FIXTURE(Fixture, "loop_iter_trailing_nil")
TEST_CASE_FIXTURE(Fixture, "loop_iter_no_indexer") TEST_CASE_FIXTURE(Fixture, "loop_iter_no_indexer")
{ {
ScopedFastFlag sff{"LuauTypecheckIter", true};
CheckResult result = check(R"( CheckResult result = check(R"(
local t = {} local t = {}
for k, v in t do for k, v in t do
@ -539,8 +533,6 @@ TEST_CASE_FIXTURE(Fixture, "loop_iter_no_indexer")
TEST_CASE_FIXTURE(BuiltinsFixture, "loop_iter_iter_metamethod") TEST_CASE_FIXTURE(BuiltinsFixture, "loop_iter_iter_metamethod")
{ {
ScopedFastFlag sff{"LuauTypecheckIter", true};
CheckResult result = check(R"( CheckResult result = check(R"(
local t = {} local t = {}
setmetatable(t, { __iter = function(o) return next, o.children end }) setmetatable(t, { __iter = function(o) return next, o.children end })

32
tests/TypeInfer.refinements.test.cpp
View File

@ -932,6 +932,8 @@ TEST_CASE_FIXTURE(Fixture, "apply_refinements_on_astexprindexexpr_whose_subscrip
TEST_CASE_FIXTURE(Fixture, "discriminate_from_truthiness_of_x") TEST_CASE_FIXTURE(Fixture, "discriminate_from_truthiness_of_x")
{ {
ScopedFastFlag sff{"LuauFalsyPredicateReturnsNilInstead", true};
CheckResult result = check(R"( CheckResult result = check(R"(
type T = {tag: "missing", x: nil} | {tag: "exists", x: string} type T = {tag: "missing", x: nil} | {tag: "exists", x: string}
@ -947,7 +949,7 @@ TEST_CASE_FIXTURE(Fixture, "discriminate_from_truthiness_of_x")
LUAU_REQUIRE_NO_ERRORS(result); LUAU_REQUIRE_NO_ERRORS(result);
CHECK_EQ(R"({| tag: "exists", x: string |})", toString(requireTypeAtPosition({5, 28}))); CHECK_EQ(R"({| tag: "exists", x: string |})", toString(requireTypeAtPosition({5, 28})));
CHECK_EQ(R"({| tag: "missing", x: nil |})", toString(requireTypeAtPosition({7, 28}))); CHECK_EQ(R"({| tag: "exists", x: string |} | {| tag: "missing", x: nil |})", toString(requireTypeAtPosition({7, 28})));
} }
TEST_CASE_FIXTURE(Fixture, "discriminate_tag") TEST_CASE_FIXTURE(Fixture, "discriminate_tag")
@ -1191,7 +1193,7 @@ TEST_CASE_FIXTURE(RefinementClassFixture, "x_is_not_instance_or_else_not_part")
TEST_CASE_FIXTURE(Fixture, "typeguard_doesnt_leak_to_elseif") TEST_CASE_FIXTURE(Fixture, "typeguard_doesnt_leak_to_elseif")
{ {
const std::string code = R"( CheckResult result = check(R"(
function f(a) function f(a)
if type(a) == "boolean" then if type(a) == "boolean" then
local a1 = a local a1 = a
@ -1201,10 +1203,30 @@ TEST_CASE_FIXTURE(Fixture, "typeguard_doesnt_leak_to_elseif")
local a3 = a local a3 = a
end end
end end
)"; )");
CheckResult result = check(code);
LUAU_REQUIRE_NO_ERRORS(result); LUAU_REQUIRE_NO_ERRORS(result);
dumpErrors(result); }
TEST_CASE_FIXTURE(BuiltinsFixture, "falsiness_of_TruthyPredicate_narrows_into_nil")
{
ScopedFastFlag sff{"LuauFalsyPredicateReturnsNilInstead", true};
CheckResult result = check(R"(
local function f(t: {number})
local x = t[1]
if not x then
local foo = x
else
local bar = x
end
end
)");
LUAU_REQUIRE_NO_ERRORS(result);
CHECK_EQ("nil", toString(requireTypeAtPosition({4, 28})));
CHECK_EQ("number", toString(requireTypeAtPosition({6, 28})));
} }
TEST_SUITE_END(); TEST_SUITE_END();

2
tests/TypeInfer.singletons.test.cpp
View File

@ -139,8 +139,6 @@ TEST_CASE_FIXTURE(Fixture, "enums_using_singletons")
TEST_CASE_FIXTURE(Fixture, "enums_using_singletons_mismatch") TEST_CASE_FIXTURE(Fixture, "enums_using_singletons_mismatch")
{ {
ScopedFastFlag sff{"LuauTwoPassAliasDefinitionFix", true};
CheckResult result = check(R"( CheckResult result = check(R"(
type MyEnum = "foo" | "bar" | "baz" type MyEnum = "foo" | "bar" | "baz"
local a : MyEnum = "bang" local a : MyEnum = "bang"

16
tests/TypePack.test.cpp
View File

@ -197,4 +197,20 @@ TEST_CASE_FIXTURE(TypePackFixture, "std_distance")
CHECK_EQ(4, std::distance(b, e)); CHECK_EQ(4, std::distance(b, e));
} }
TEST_CASE("content_reassignment")
{
ScopedFastFlag luauNonCopyableTypeVarFields{"LuauNonCopyableTypeVarFields", true};
TypePackVar myError{Unifiable::Error{}, /*presistent*/ true};
TypeArena arena;
TypePackId futureError = arena.addTypePack(TypePackVar{FreeTypePack{TypeLevel{}}});
asMutable(futureError)->reassign(myError);
CHECK(get<ErrorTypeVar>(futureError) != nullptr);
CHECK(!futureError->persistent);
CHECK(futureError->owningArena == &arena);
}
TEST_SUITE_END(); TEST_SUITE_END();

20
tests/TypeVar.test.cpp
View File

@ -416,4 +416,24 @@ TEST_CASE("proof_that_isBoolean_uses_all_of")
CHECK(!isBoolean(&union_)); CHECK(!isBoolean(&union_));
} }
TEST_CASE("content_reassignment")
{
ScopedFastFlag luauNonCopyableTypeVarFields{"LuauNonCopyableTypeVarFields", true};
TypeVar myAny{AnyTypeVar{}, /*presistent*/ true};
myAny.normal = true;
myAny.documentationSymbol = "@global/any";
TypeArena arena;
TypeId futureAny = arena.addType(FreeTypeVar{TypeLevel{}});
asMutable(futureAny)->reassign(myAny);
CHECK(get<AnyTypeVar>(futureAny) != nullptr);
CHECK(!futureAny->persistent);
CHECK(futureAny->normal);
CHECK(futureAny->documentationSymbol == "@global/any");
CHECK(futureAny->owningArena == &arena);
}
TEST_SUITE_END(); TEST_SUITE_END();

11
tests/conformance/apicalls.lua
View File

@ -11,4 +11,15 @@ function create_with_tm(x)
return setmetatable({ a = x }, m) return setmetatable({ a = x }, m)
end end
local gen = 0
function incuv()
gen += 1
return gen
end
pi = 3.1415926
function getpi()
return pi
end
return('OK') return('OK')

17
tests/conformance/pcall.lua
View File

@ -144,4 +144,21 @@ coroutine.resume(co)
resumeerror(co, "fail") resumeerror(co, "fail")
checkresults({ true, false, "fail" }, coroutine.resume(co)) checkresults({ true, false, "fail" }, coroutine.resume(co))
-- stack overflow needs to happen at the call limit
local calllimit = 20000
function recurse(n) return n <= 1 and 1 or recurse(n-1) + 1 end
-- we use one frame for top-level function and one frame is the service frame for coroutines
assert(recurse(calllimit - 2) == calllimit - 2)
-- note that when calling through pcall, pcall eats one more frame
checkresults({ true, calllimit - 3 }, pcall(recurse, calllimit - 3))
checkerror(pcall(recurse, calllimit - 2))
-- xpcall handler runs in context of the stack frame, but this works just fine since we allow extra stack consumption past stack overflow
checkresults({ false, "ok" }, xpcall(recurse, function() return string.reverse("ko") end, calllimit - 2))
-- however, if xpcall handler itself runs out of extra stack space, we get "error in error handling"
checkresults({ false, "error in error handling" }, xpcall(recurse, function() return recurse(calllimit) end, calllimit - 2))
return 'OK' return 'OK'