luau/Analysis/include/Luau/Constraint.h

292 lines
7.3 KiB
C
Raw Normal View History

2022-06-17 01:54:42 +01:00
// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
#pragma once
2022-07-01 00:29:02 +01:00
#include "Luau/Ast.h" // Used for some of the enumerations
2022-12-09 18:07:25 +00:00
#include "Luau/DenseHash.h"
2022-06-17 01:54:42 +01:00
#include "Luau/NotNull.h"
2023-01-03 17:33:19 +00:00
#include "Luau/Type.h"
2022-10-21 18:33:43 +01:00
#include "Luau/Variant.h"
2022-06-17 01:54:42 +01:00
2022-06-24 02:44:07 +01:00
#include <string>
2022-06-17 01:54:42 +01:00
#include <memory>
#include <vector>
namespace Luau
{
2022-07-29 04:41:13 +01:00
struct Scope;
2023-01-03 17:33:19 +00:00
struct Type;
using TypeId = const Type*;
2022-06-17 01:54:42 +01:00
struct TypePackVar;
using TypePackId = const TypePackVar*;
// subType <: superType
struct SubtypeConstraint
{
TypeId subType;
TypeId superType;
};
// subPack <: superPack
struct PackSubtypeConstraint
{
TypePackId subPack;
TypePackId superPack;
};
2022-08-25 21:55:08 +01:00
// generalizedType ~ gen sourceType
2022-06-17 01:54:42 +01:00
struct GeneralizationConstraint
{
TypeId generalizedType;
TypeId sourceType;
};
// subType ~ inst superType
struct InstantiationConstraint
{
TypeId subType;
TypeId superType;
};
2022-07-01 00:29:02 +01:00
struct UnaryConstraint
{
AstExprUnary::Op op;
TypeId operandType;
TypeId resultType;
};
2022-09-02 00:00:14 +01:00
// let L : leftType
// let R : rightType
// in
// L op R : resultType
2022-07-01 00:29:02 +01:00
struct BinaryConstraint
{
AstExprBinary::Op op;
TypeId leftType;
TypeId rightType;
TypeId resultType;
2022-12-09 18:07:25 +00:00
// When we dispatch this constraint, we update the key at this map to record
// the overload that we selected.
2023-02-03 12:34:12 +00:00
const AstNode* astFragment;
DenseHashMap<const AstNode*, TypeId>* astOriginalCallTypes;
DenseHashMap<const AstNode*, TypeId>* astOverloadResolvedTypes;
2022-07-01 00:29:02 +01:00
};
2022-09-02 00:00:14 +01:00
// iteratee is iterable
// iterators is the iteration types.
struct IterableConstraint
{
TypePackId iterator;
TypePackId variables;
};
2022-06-24 02:44:07 +01:00
// name(namedType) = name
struct NameConstraint
{
TypeId namedType;
std::string name;
2023-01-27 21:28:45 +00:00
bool synthetic = false;
2023-02-17 14:53:37 +00:00
std::vector<TypeId> typeParameters;
std::vector<TypePackId> typePackParameters;
2022-06-24 02:44:07 +01:00
};
2022-08-04 22:27:28 +01:00
// target ~ inst target
struct TypeAliasExpansionConstraint
{
2023-01-03 17:33:19 +00:00
// Must be a PendingExpansionType.
2022-08-04 22:27:28 +01:00
TypeId target;
};
2022-09-02 00:00:14 +01:00
struct FunctionCallConstraint
{
TypeId fn;
2022-09-29 23:11:54 +01:00
TypePackId argsPack;
2022-09-02 00:00:14 +01:00
TypePackId result;
2022-09-29 23:11:54 +01:00
class AstExprCall* callSite;
2023-02-10 18:50:54 +00:00
std::vector<std::optional<TypeId>> discriminantTypes;
2023-05-05 20:57:12 +01:00
// When we dispatch this constraint, we update the key at this map to record
// the overload that we selected.
DenseHashMap<const AstNode*, TypeId>* astOriginalCallTypes;
DenseHashMap<const AstNode*, TypeId>* astOverloadResolvedTypes;
2022-09-02 00:00:14 +01:00
};
2022-09-23 19:32:10 +01:00
// result ~ prim ExpectedType SomeSingletonType MultitonType
//
// If ExpectedType is potentially a singleton (an actual singleton or a union
// that contains a singleton), then result ~ SomeSingletonType
//
// else result ~ MultitonType
struct PrimitiveTypeConstraint
{
TypeId resultType;
TypeId expectedType;
TypeId singletonType;
TypeId multitonType;
};
// result ~ hasProp type "prop_name"
//
// If the subject is a table, bind the result to the named prop. If the table
// has an indexer, bind it to the index result type. If the subject is a union,
// bind the result to the union of its constituents' properties.
//
// It would be nice to get rid of this constraint and someday replace it with
//
// T <: {p: X}
//
// Where {} describes an inexact shape type.
struct HasPropConstraint
{
TypeId resultType;
TypeId subjectType;
std::string prop;
2023-05-19 19:59:59 +01:00
// HACK: We presently need types like true|false or string|"hello" when
// deciding whether a particular literal expression should have a singleton
// type. This boolean is set to true when extracting the property type of a
// value that may be a union of tables.
//
// For example, in the following code fragment, we want the lookup of the
// success property to yield true|false when extracting an expectedType in
// this expression:
//
// type Result<T, E> = {success:true, result: T} | {success:false, error: E}
//
// local r: Result<number, string> = {success=true, result=9}
//
// If we naively simplify the expectedType to boolean, we will erroneously
// compute the type boolean for the success property of the table literal.
// This causes type checking to fail.
bool suppressSimplification = false;
2022-09-23 19:32:10 +01:00
};
2022-11-18 18:45:14 +00:00
// result ~ setProp subjectType ["prop", "prop2", ...] propType
//
// If the subject is a table or table-like thing that already has the named
// property chain, we unify propType with that existing property type.
//
// If the subject is a free table, we augment it in place.
//
// If the subject is an unsealed table, result is an augmented table that
// includes that new prop.
struct SetPropConstraint
{
TypeId resultType;
TypeId subjectType;
std::vector<std::string> path;
TypeId propType;
};
2023-02-24 18:24:22 +00:00
// result ~ setIndexer subjectType indexType propType
//
// If the subject is a table or table-like thing that already has an indexer,
// unify its indexType and propType with those from this constraint.
//
// If the table is a free or unsealed table, we augment it with a new indexer.
struct SetIndexerConstraint
{
TypeId resultType;
TypeId subjectType;
TypeId indexType;
TypeId propType;
};
2022-12-02 10:46:05 +00:00
// if negation:
// result ~ if isSingleton D then ~D else unknown where D = discriminantType
// if not negation:
// result ~ if isSingleton D then D else unknown where D = discriminantType
2022-11-04 17:02:37 +00:00
struct SingletonOrTopTypeConstraint
2022-10-21 18:33:43 +01:00
{
2022-11-04 17:02:37 +00:00
TypeId resultType;
2022-10-21 18:33:43 +01:00
TypeId discriminantType;
2022-12-02 10:46:05 +00:00
bool negated;
2022-10-21 18:33:43 +01:00
};
2023-02-24 18:24:22 +00:00
// resultType ~ unpack sourceTypePack
//
// Similar to PackSubtypeConstraint, but with one important difference: If the
// sourcePack is blocked, this constraint blocks.
struct UnpackConstraint
{
TypePackId resultPack;
TypePackId sourcePack;
};
2023-05-19 19:59:59 +01:00
// resultType ~ refine type mode discriminant
//
// Compute type & discriminant (or type | discriminant) as soon as possible (but
// no sooner), simplify, and bind resultType to that type.
struct RefineConstraint
{
enum
{
Intersection,
Union
} mode;
TypeId resultType;
TypeId type;
TypeId discriminant;
};
2023-05-12 13:15:01 +01:00
// ty ~ reduce ty
//
// Try to reduce ty, if it is a TypeFamilyInstanceType. Otherwise, do nothing.
struct ReduceConstraint
{
TypeId ty;
};
// tp ~ reduce tp
//
// Analogous to ReduceConstraint, but for type packs.
struct ReducePackConstraint
{
TypePackId tp;
};
2023-05-19 19:59:59 +01:00
using ConstraintV = Variant<SubtypeConstraint, PackSubtypeConstraint, GeneralizationConstraint, InstantiationConstraint, UnaryConstraint,
BinaryConstraint, IterableConstraint, NameConstraint, TypeAliasExpansionConstraint, FunctionCallConstraint, PrimitiveTypeConstraint,
HasPropConstraint, SetPropConstraint, SetIndexerConstraint, SingletonOrTopTypeConstraint, UnpackConstraint, RefineConstraint, ReduceConstraint,
ReducePackConstraint>;
2022-09-02 00:00:14 +01:00
2022-06-17 01:54:42 +01:00
struct Constraint
{
2022-09-02 00:00:14 +01:00
Constraint(NotNull<Scope> scope, const Location& location, ConstraintV&& c);
2022-06-17 01:54:42 +01:00
Constraint(const Constraint&) = delete;
Constraint& operator=(const Constraint&) = delete;
2022-09-02 00:00:14 +01:00
NotNull<Scope> scope;
2023-02-10 18:50:54 +00:00
Location location;
2022-06-17 01:54:42 +01:00
ConstraintV c;
2022-09-02 00:00:14 +01:00
2022-06-17 01:54:42 +01:00
std::vector<NotNull<Constraint>> dependencies;
};
2022-09-23 19:32:10 +01:00
using ConstraintPtr = std::unique_ptr<Constraint>;
2022-06-17 01:54:42 +01:00
inline Constraint& asMutable(const Constraint& c)
{
return const_cast<Constraint&>(c);
}
template<typename T>
T* getMutable(Constraint& c)
{
return ::Luau::get_if<T>(&c.c);
}
template<typename T>
const T* get(const Constraint& c)
{
return getMutable<T>(asMutable(c));
}
} // namespace Luau