mirror of
https://github.com/luau-lang/luau.git
synced 2025-04-06 03:40:55 +01:00
76bea81a7b
* Optimized operations like instantiation and module export for very large types In our new typechecker: * Typechecking of function calls was rewritten to handle more cases correctly * Fixed a crash that can happen after self-referential type is exported from a module * Fixed a false positive error in string comparison * Added handling of `for...in` variable type annotations and fixed issues with the iterator call inside * Self-referential 'hasProp' and 'setProp' constraints are now handled correctly In our native code generation (jit): * Added '--target' argument to luau-compile to test multiple architectures different from host architecture * GC barrier tag check is skipped if type is already known to be GC-collectable * Added GET_TYPE/GET_TYPEOF instructions for type/typeof fast-calls * Improved code size of interrupt handlers on X64
89 lines
2.3 KiB
C++
89 lines
2.3 KiB
C++
// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
|
|
|
|
#include "Luau/Anyification.h"
|
|
|
|
#include "Luau/Common.h"
|
|
#include "Luau/Normalize.h"
|
|
#include "Luau/TxnLog.h"
|
|
|
|
namespace Luau
|
|
{
|
|
|
|
Anyification::Anyification(TypeArena* arena, NotNull<Scope> scope, NotNull<BuiltinTypes> builtinTypes, InternalErrorReporter* iceHandler,
|
|
TypeId anyType, TypePackId anyTypePack)
|
|
: Substitution(TxnLog::empty(), arena)
|
|
, scope(scope)
|
|
, builtinTypes(builtinTypes)
|
|
, iceHandler(iceHandler)
|
|
, anyType(anyType)
|
|
, anyTypePack(anyTypePack)
|
|
{
|
|
}
|
|
|
|
Anyification::Anyification(TypeArena* arena, const ScopePtr& scope, NotNull<BuiltinTypes> builtinTypes, InternalErrorReporter* iceHandler,
|
|
TypeId anyType, TypePackId anyTypePack)
|
|
: Anyification(arena, NotNull{scope.get()}, builtinTypes, iceHandler, anyType, anyTypePack)
|
|
{
|
|
}
|
|
|
|
bool Anyification::isDirty(TypeId ty)
|
|
{
|
|
if (ty->persistent)
|
|
return false;
|
|
|
|
if (const TableType* ttv = log->getMutable<TableType>(ty))
|
|
return (ttv->state == TableState::Free || ttv->state == TableState::Unsealed);
|
|
else if (log->getMutable<FreeType>(ty))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
bool Anyification::isDirty(TypePackId tp)
|
|
{
|
|
if (tp->persistent)
|
|
return false;
|
|
|
|
if (log->getMutable<FreeTypePack>(tp))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
|
|
TypeId Anyification::clean(TypeId ty)
|
|
{
|
|
LUAU_ASSERT(isDirty(ty));
|
|
if (const TableType* ttv = log->getMutable<TableType>(ty))
|
|
{
|
|
TableType clone = TableType{ttv->props, ttv->indexer, ttv->level, TableState::Sealed};
|
|
clone.definitionModuleName = ttv->definitionModuleName;
|
|
clone.definitionLocation = ttv->definitionLocation;
|
|
clone.name = ttv->name;
|
|
clone.syntheticName = ttv->syntheticName;
|
|
clone.tags = ttv->tags;
|
|
TypeId res = addType(std::move(clone));
|
|
return res;
|
|
}
|
|
else
|
|
return anyType;
|
|
}
|
|
|
|
TypePackId Anyification::clean(TypePackId tp)
|
|
{
|
|
LUAU_ASSERT(isDirty(tp));
|
|
return anyTypePack;
|
|
}
|
|
|
|
bool Anyification::ignoreChildren(TypeId ty)
|
|
{
|
|
if (get<ClassType>(ty))
|
|
return true;
|
|
|
|
return ty->persistent;
|
|
}
|
|
bool Anyification::ignoreChildren(TypePackId ty)
|
|
{
|
|
return ty->persistent;
|
|
}
|
|
|
|
} // namespace Luau
|