mirror of
https://github.com/luau-lang/luau.git
synced 2024-12-13 21:40:43 +00:00
9c588be16d
# What's changed? * Check interrupt handler inside the pattern match engine to eliminate potential for programs to hang during string library function execution. * Allow iteration over table properties to pass the old type solver. ### Native Code Generation * Use in-place memory operands for math library operations on x64. * Replace opaque bools with separate enum classes in IrDump to improve code maintainability. * Translate operations on inferred vectors to IR. * Enable support for debugging native-compiled functions in Roblox Studio. ### New Type Solver * Rework type inference for boolean and string literals to introduce bounded free types (bounded below by the singleton type, and above by the primitive type) and reworked primitive type constraint to decide which is the appropriate type for the literal. * Introduce `FunctionCheckConstraint` to handle bidirectional typechecking for function calls, pushing the expected parameter types from the function onto the arguments. * Introduce `union` and `intersect` type families to compute deferred simplified unions and intersections to be employed by the constraint generation logic in the new solver. * Implement support for expanding the domain of local types in `Unifier2`. * Rework type inference for iteration variables bound by for in loops to use local types. * Change constraint blocking logic to use a set to prevent accidental re-blocking. * Add logic to detect missing return statements in functions. ### 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: Aviral Goel <agoel@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>
89 lines
2.9 KiB
C++
89 lines
2.9 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};
|
|
|
|
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 TypePack result?
|
|
OccursCheckResult occursCheck(DenseHashSet<TypePackId>& seen, TypePackId needle, TypePackId haystack);
|
|
};
|
|
|
|
} // namespace Luau
|