mirror of
https://github.com/luau-lang/luau.git
synced 2024-12-13 21:40:43 +00:00
ae459a0197
# What's Changed * Add a compiler hint to improve Luau memory allocation inlining ### New Type Solver * Added a system for recommending explicit type annotations to users in cases where we've inferred complex generic types with type families. * Marked string library functions as `@checked` for use in new non-strict mode. * Fixed a bug with new non-strict mode where we would incorrectly report arity mismatches when missing optional arguments. * Implement an occurs check for unifications that would produce self-recursive types. * Fix bug where overload resolution would fail when applied to non-overloaded functions. * Fix bug that caused the subtyping to report an error whenever a generic was instantiated in an invariant context. * Fix crash caused by `SetPropConstraint` not blocking properly. ### Native Code Generation * Implement optimization to eliminate dead stores * Optimize vector ops for X64 when the source is computed (thanks, @zeux!) * Use more efficient lowering for UNM_* (thanks, @zeux!) --- ### Internal Contributors Co-authored-by: Aaron Weiss <aaronweiss@roblox.com> Co-authored-by: Alexander McCord <amccord@roblox.com> Co-authored-by: Andy Friesen <afriesen@roblox.com> Co-authored-by: David Cope <dcope@roblox.com> Co-authored-by: Lily Brown <lbrown@roblox.com> Co-authored-by: Vyacheslav Egorov <vegorov@roblox.com> --------- Co-authored-by: Alexander McCord <amccord@roblox.com> Co-authored-by: Andy Friesen <afriesen@roblox.com> Co-authored-by: Vighnesh <vvijay@roblox.com> Co-authored-by: Aviral Goel <agoel@roblox.com> Co-authored-by: David Cope <dcope@roblox.com> Co-authored-by: Lily Brown <lbrown@roblox.com> Co-authored-by: Vyacheslav Egorov <vegorov@roblox.com>
98 lines
3.4 KiB
C++
98 lines
3.4 KiB
C++
// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
|
|
|
|
#pragma once
|
|
|
|
#include "Luau/DenseHash.h"
|
|
#include "Luau/NotNull.h"
|
|
#include "Luau/TypePairHash.h"
|
|
#include "Luau/TypeCheckLimits.h"
|
|
#include "Luau/TypeFwd.h"
|
|
|
|
#include <optional>
|
|
#include <vector>
|
|
#include <utility>
|
|
|
|
namespace Luau
|
|
{
|
|
|
|
struct InternalErrorReporter;
|
|
struct Scope;
|
|
struct TypeArena;
|
|
|
|
enum class OccursCheckResult
|
|
{
|
|
Pass,
|
|
Fail
|
|
};
|
|
|
|
struct Unifier2
|
|
{
|
|
NotNull<TypeArena> arena;
|
|
NotNull<BuiltinTypes> builtinTypes;
|
|
NotNull<Scope> scope;
|
|
NotNull<InternalErrorReporter> ice;
|
|
TypeCheckLimits limits;
|
|
|
|
DenseHashSet<std::pair<TypeId, TypeId>, TypePairHash> seenTypePairings{{nullptr, nullptr}};
|
|
DenseHashSet<std::pair<TypePackId, TypePackId>, TypePairHash> seenTypePackPairings{{nullptr, nullptr}};
|
|
|
|
DenseHashMap<TypeId, std::vector<TypeId>> expandedFreeTypes{nullptr};
|
|
|
|
// Mapping from generic types to free types to be used in instantiation.
|
|
DenseHashMap<TypeId, TypeId> genericSubstitutions{nullptr};
|
|
// Mapping from generic type packs to `TypePack`s of free types to be used in instantiation.
|
|
DenseHashMap<TypePackId, TypePackId> genericPackSubstitutions{nullptr};
|
|
|
|
int recursionCount = 0;
|
|
int recursionLimit = 0;
|
|
|
|
Unifier2(NotNull<TypeArena> arena, NotNull<BuiltinTypes> builtinTypes, NotNull<Scope> scope, NotNull<InternalErrorReporter> ice);
|
|
|
|
/** Attempt to commit the subtype relation subTy <: superTy to the type
|
|
* graph.
|
|
*
|
|
* @returns true if successful.
|
|
*
|
|
* Note that incoherent types can and will successfully be unified. We stop
|
|
* when we *cannot know* how to relate the provided types, not when doing so
|
|
* would narrow something down to never or broaden it to unknown.
|
|
*
|
|
* Presently, the only way unification can fail is if we attempt to bind one
|
|
* free TypePack to another and encounter an occurs check violation.
|
|
*/
|
|
bool unify(TypeId subTy, TypeId superTy);
|
|
bool unify(const LocalType* subTy, TypeId superFn);
|
|
bool unify(TypeId subTy, const FunctionType* superFn);
|
|
bool unify(const UnionType* subUnion, TypeId superTy);
|
|
bool unify(TypeId subTy, const UnionType* superUnion);
|
|
bool unify(const IntersectionType* subIntersection, TypeId superTy);
|
|
bool unify(TypeId subTy, const IntersectionType* superIntersection);
|
|
bool unify(TableType* subTable, const TableType* superTable);
|
|
bool unify(const MetatableType* subMetatable, const MetatableType* superMetatable);
|
|
|
|
// TODO think about this one carefully. We don't do unions or intersections of type packs
|
|
bool unify(TypePackId subTp, TypePackId superTp);
|
|
|
|
std::optional<TypeId> generalize(TypeId ty);
|
|
|
|
private:
|
|
/**
|
|
* @returns simplify(left | right)
|
|
*/
|
|
TypeId mkUnion(TypeId left, TypeId right);
|
|
|
|
/**
|
|
* @returns simplify(left & right)
|
|
*/
|
|
TypeId mkIntersection(TypeId left, TypeId right);
|
|
|
|
// Returns true if needle occurs within haystack already. ie if we bound
|
|
// needle to haystack, would a cyclic type result?
|
|
OccursCheckResult occursCheck(DenseHashSet<TypeId>& seen, TypeId needle, TypeId haystack);
|
|
|
|
// Returns true if needle occurs within haystack already. ie if we bound
|
|
// needle to haystack, would a cyclic TypePack result?
|
|
OccursCheckResult occursCheck(DenseHashSet<TypePackId>& seen, TypePackId needle, TypePackId haystack);
|
|
};
|
|
|
|
} // namespace Luau
|