mirror of
https://github.com/luau-lang/luau.git
synced 2024-11-15 14:25:44 +08: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>
103 lines
3.3 KiB
C++
103 lines
3.3 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/Ast.h"
|
|
#include "Luau/InsertionOrderedMap.h"
|
|
#include "Luau/NotNull.h"
|
|
#include "Luau/TypeFwd.h"
|
|
#include "Luau/Location.h"
|
|
#include "Luau/Error.h"
|
|
#include "Luau/Subtyping.h"
|
|
|
|
namespace Luau
|
|
{
|
|
|
|
struct BuiltinTypes;
|
|
struct TypeArena;
|
|
struct Scope;
|
|
struct InternalErrorReporter;
|
|
struct TypeCheckLimits;
|
|
struct Subtyping;
|
|
|
|
class Normalizer;
|
|
|
|
struct OverloadResolver
|
|
{
|
|
enum Analysis
|
|
{
|
|
Ok,
|
|
TypeIsNotAFunction,
|
|
ArityMismatch,
|
|
OverloadIsNonviable, // Arguments were incompatible with the overloads parameters but were otherwise compatible by arity
|
|
};
|
|
|
|
OverloadResolver(NotNull<BuiltinTypes> builtinTypes, NotNull<TypeArena> arena, NotNull<Normalizer> normalizer, NotNull<Scope> scope,
|
|
NotNull<InternalErrorReporter> reporter, NotNull<TypeCheckLimits> limits, Location callLocation);
|
|
|
|
NotNull<BuiltinTypes> builtinTypes;
|
|
NotNull<TypeArena> arena;
|
|
NotNull<Normalizer> normalizer;
|
|
NotNull<Scope> scope;
|
|
NotNull<InternalErrorReporter> ice;
|
|
NotNull<TypeCheckLimits> limits;
|
|
Subtyping subtyping;
|
|
Location callLoc;
|
|
|
|
// Resolver results
|
|
std::vector<TypeId> ok;
|
|
std::vector<TypeId> nonFunctions;
|
|
std::vector<std::pair<TypeId, ErrorVec>> arityMismatches;
|
|
std::vector<std::pair<TypeId, ErrorVec>> nonviableOverloads;
|
|
InsertionOrderedMap<TypeId, std::pair<OverloadResolver::Analysis, size_t>> resolution;
|
|
|
|
|
|
std::pair<OverloadResolver::Analysis, TypeId> selectOverload(TypeId ty, TypePackId args);
|
|
void resolve(TypeId fnTy, const TypePack* args, AstExpr* selfExpr, const std::vector<AstExpr*>* argExprs);
|
|
|
|
private:
|
|
std::optional<ErrorVec> testIsSubtype(const Location& location, TypeId subTy, TypeId superTy);
|
|
std::optional<ErrorVec> testIsSubtype(const Location& location, TypePackId subTy, TypePackId superTy);
|
|
std::pair<Analysis, ErrorVec> checkOverload(
|
|
TypeId fnTy, const TypePack* args, AstExpr* fnLoc, const std::vector<AstExpr*>* argExprs, bool callMetamethodOk = true);
|
|
static bool isLiteral(AstExpr* expr);
|
|
LUAU_NOINLINE
|
|
std::pair<Analysis, ErrorVec> checkOverload_(
|
|
TypeId fnTy, const FunctionType* fn, const TypePack* args, AstExpr* fnExpr, const std::vector<AstExpr*>* argExprs);
|
|
size_t indexof(Analysis analysis);
|
|
void add(Analysis analysis, TypeId ty, ErrorVec&& errors);
|
|
};
|
|
|
|
struct SolveResult
|
|
{
|
|
enum OverloadCallResult {
|
|
Ok,
|
|
CodeTooComplex,
|
|
OccursCheckFailed,
|
|
NoMatchingOverload,
|
|
};
|
|
|
|
OverloadCallResult result;
|
|
std::optional<TypePackId> typePackId; // nullopt if result != Ok
|
|
|
|
TypeId overloadToUse = nullptr;
|
|
TypeId inferredTy = nullptr;
|
|
DenseHashMap<TypeId, std::vector<TypeId>> expandedFreeTypes{nullptr};
|
|
};
|
|
|
|
// Helper utility, presently used for binary operator type families.
|
|
//
|
|
// Given a function and a set of arguments, select a suitable overload.
|
|
SolveResult solveFunctionCall(
|
|
NotNull<TypeArena> arena,
|
|
NotNull<BuiltinTypes> builtinTypes,
|
|
NotNull<Normalizer> normalizer,
|
|
NotNull<InternalErrorReporter> iceReporter,
|
|
NotNull<TypeCheckLimits> limits,
|
|
NotNull<Scope> scope,
|
|
const Location& location,
|
|
TypeId fn,
|
|
TypePackId argsPack
|
|
);
|
|
|
|
} // namespace Luau
|