luau/Analysis/include/Luau/Unifier.h

151 lines
5.9 KiB
C
Raw Normal View History

// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
#pragma once
#include "Luau/Error.h"
#include "Luau/Location.h"
2022-09-08 22:44:50 +01:00
#include "Luau/ParseOptions.h"
2022-08-18 22:04:33 +01:00
#include "Luau/Scope.h"
2022-09-08 22:44:50 +01:00
#include "Luau/Substitution.h"
#include "Luau/TxnLog.h"
2022-05-20 00:46:52 +01:00
#include "Luau/TypeArena.h"
#include "Luau/UnifierSharedState.h"
2022-10-07 00:55:58 +01:00
#include "Normalize.h"
#include <unordered_set>
namespace Luau
{
enum Variance
{
Covariant,
Invariant
};
2022-02-24 23:15:41 +00:00
// A substitution which replaces singleton types by their wider types
struct Widen : Substitution
{
2022-09-08 22:44:50 +01:00
Widen(TypeArena* arena, NotNull<SingletonTypes> singletonTypes)
2022-02-24 23:15:41 +00:00
: Substitution(TxnLog::empty(), arena)
2022-09-08 22:44:50 +01:00
, singletonTypes(singletonTypes)
2022-02-24 23:15:41 +00:00
{
}
2022-09-08 22:44:50 +01:00
NotNull<SingletonTypes> singletonTypes;
2022-02-24 23:15:41 +00:00
bool isDirty(TypeId ty) override;
bool isDirty(TypePackId ty) override;
TypeId clean(TypeId ty) override;
TypePackId clean(TypePackId ty) override;
bool ignoreChildren(TypeId ty) override;
2022-05-26 21:33:48 +01:00
TypeId operator()(TypeId ty);
TypePackId operator()(TypePackId ty);
2022-02-24 23:15:41 +00:00
};
// TODO: Use this more widely.
struct UnifierOptions
{
bool isFunctionCall = false;
};
struct Unifier
{
TypeArena* const types;
2022-09-08 22:44:50 +01:00
NotNull<SingletonTypes> singletonTypes;
2022-10-07 00:55:58 +01:00
NotNull<Normalizer> normalizer;
Mode mode;
2022-08-18 22:04:33 +01:00
NotNull<Scope> scope; // const Scope maybe
TxnLog log;
ErrorVec errors;
Location location;
Variance variance = Covariant;
2022-10-13 23:59:53 +01:00
bool anyIsTop = false; // If true, we consider any to be a top type. If false, it is a familiar but weird mix of top and bottom all at once.
bool normalize; // Normalize unions and intersections if necessary
2022-09-29 23:11:54 +01:00
bool useScopes = false; // If true, we use the scope hierarchy rather than TypeLevels
CountMismatch::Context ctx = CountMismatch::Arg;
UnifierSharedState& sharedState;
2022-10-13 23:59:53 +01:00
Unifier(
NotNull<Normalizer> normalizer, Mode mode, NotNull<Scope> scope, const Location& location, Variance variance, TxnLog* parentLog = nullptr);
// Test whether the two type vars unify. Never commits the result.
2022-01-06 22:10:07 +00:00
ErrorVec canUnify(TypeId subTy, TypeId superTy);
ErrorVec canUnify(TypePackId subTy, TypePackId superTy, bool isFunctionCall = false);
2022-01-06 22:10:07 +00:00
/** Attempt to unify.
* Populate the vector errors with any type errors that may arise.
* Populate the transaction log with the set of TypeIds that need to be reset to undo the unification attempt.
*/
2022-01-06 22:10:07 +00:00
void tryUnify(TypeId subTy, TypeId superTy, bool isFunctionCall = false, bool isIntersection = false);
private:
2022-01-06 22:10:07 +00:00
void tryUnify_(TypeId subTy, TypeId superTy, bool isFunctionCall = false, bool isIntersection = false);
2022-02-03 23:09:37 +00:00
void tryUnifyUnionWithType(TypeId subTy, const UnionTypeVar* uv, TypeId superTy);
void tryUnifyTypeWithUnion(TypeId subTy, TypeId superTy, const UnionTypeVar* uv, bool cacheEnabled, bool isFunctionCall);
void tryUnifyTypeWithIntersection(TypeId subTy, TypeId superTy, const IntersectionTypeVar* uv);
void tryUnifyIntersectionWithType(TypeId subTy, const IntersectionTypeVar* uv, TypeId superTy, bool cacheEnabled, bool isFunctionCall);
2022-10-13 23:59:53 +01:00
void tryUnifyNormalizedTypes(TypeId subTy, TypeId superTy, const NormalizedType& subNorm, const NormalizedType& superNorm, std::string reason,
std::optional<TypeError> error = std::nullopt);
2022-01-06 22:10:07 +00:00
void tryUnifyPrimitives(TypeId subTy, TypeId superTy);
void tryUnifySingletons(TypeId subTy, TypeId superTy);
void tryUnifyFunctions(TypeId subTy, TypeId superTy, bool isFunctionCall = false);
void tryUnifyTables(TypeId subTy, TypeId superTy, bool isIntersection = false);
2022-07-14 23:39:35 +01:00
void tryUnifyScalarShape(TypeId subTy, TypeId superTy, bool reversed);
2022-01-06 22:10:07 +00:00
void tryUnifyWithMetatable(TypeId subTy, TypeId superTy, bool reversed);
void tryUnifyWithClass(TypeId subTy, TypeId superTy, bool reversed);
2022-10-27 23:22:49 +01:00
void tryUnifyTypeWithNegation(TypeId subTy, TypeId superTy);
void tryUnifyNegationWithType(TypeId subTy, TypeId superTy);
2022-02-24 23:15:41 +00:00
2022-10-07 00:55:58 +01:00
TypePackId tryApplyOverloadedFunction(TypeId function, const NormalizedFunctionType& overloads, TypePackId args);
2022-02-24 23:15:41 +00:00
TypeId widen(TypeId ty);
2022-03-18 00:06:25 +00:00
TypePackId widen(TypePackId tp);
TypeId deeplyOptional(TypeId ty, std::unordered_map<TypeId, TypeId> seen = {});
2022-02-24 23:15:41 +00:00
2022-03-24 21:49:08 +00:00
bool canCacheResult(TypeId subTy, TypeId superTy);
void cacheResult(TypeId subTy, TypeId superTy, size_t prevErrorCount);
public:
2022-01-06 22:10:07 +00:00
void tryUnify(TypePackId subTy, TypePackId superTy, bool isFunctionCall = false);
private:
2022-01-06 22:10:07 +00:00
void tryUnify_(TypePackId subTy, TypePackId superTy, bool isFunctionCall = false);
void tryUnifyVariadics(TypePackId subTy, TypePackId superTy, bool reversed, int subOffset = 0);
2022-01-06 22:10:07 +00:00
void tryUnifyWithAny(TypeId subTy, TypeId anyTy);
void tryUnifyWithAny(TypePackId subTy, TypePackId anyTp);
std::optional<TypeId> findTablePropertyRespectingMeta(TypeId lhsType, Name name);
public:
2022-08-11 21:42:54 +01:00
// Returns true if the type "needle" already occurs within "haystack" and reports an "infinite type error"
bool occursCheck(TypeId needle, TypeId haystack);
bool occursCheck(DenseHashSet<TypeId>& seen, TypeId needle, TypeId haystack);
bool occursCheck(TypePackId needle, TypePackId haystack);
bool occursCheck(DenseHashSet<TypePackId>& seen, TypePackId needle, TypePackId haystack);
Unifier makeChildUnifier();
2022-04-14 22:57:15 +01:00
void reportError(TypeError err);
2022-01-27 21:29:34 +00:00
private:
bool isNonstrictMode() const;
void checkChildUnifierTypeMismatch(const ErrorVec& innerErrors, TypeId wantedType, TypeId givenType);
2021-11-12 02:12:39 +00:00
void checkChildUnifierTypeMismatch(const ErrorVec& innerErrors, const std::string& prop, TypeId wantedType, TypeId givenType);
[[noreturn]] void ice(const std::string& message, const Location& location);
[[noreturn]] void ice(const std::string& message);
// Available after regular type pack unification errors
std::optional<int> firstPackErrorPos;
};
2022-09-29 23:11:54 +01:00
void promoteTypeLevels(TxnLog& log, const TypeArena* arena, TypeLevel minLevel, Scope* outerScope, bool useScope, TypePackId tp);
2022-04-14 22:57:15 +01:00
} // namespace Luau