mirror of
https://github.com/luau-lang/luau.git
synced 2024-12-13 13:30:40 +00:00
89 lines
3 KiB
C++
89 lines
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/Constraint.h"
|
|
#include "Luau/Location.h"
|
|
#include "Luau/NotNull.h"
|
|
#include "Luau/TypeVar.h"
|
|
|
|
#include <unordered_map>
|
|
#include <optional>
|
|
#include <memory>
|
|
|
|
namespace Luau
|
|
{
|
|
|
|
struct Scope;
|
|
|
|
using ScopePtr = std::shared_ptr<Scope>;
|
|
|
|
struct Binding
|
|
{
|
|
TypeId typeId;
|
|
Location location;
|
|
bool deprecated = false;
|
|
std::string deprecatedSuggestion;
|
|
std::optional<std::string> documentationSymbol;
|
|
};
|
|
|
|
struct Scope
|
|
{
|
|
explicit Scope(TypePackId returnType); // root scope
|
|
explicit Scope(const ScopePtr& parent, int subLevel = 0); // child scope. Parent must not be nullptr.
|
|
|
|
const ScopePtr parent; // null for the root
|
|
std::unordered_map<Symbol, Binding> bindings;
|
|
TypePackId returnType;
|
|
bool breakOk = false;
|
|
std::optional<TypePackId> varargPack;
|
|
|
|
TypeLevel level;
|
|
|
|
std::unordered_map<Name, TypeFun> exportedTypeBindings;
|
|
std::unordered_map<Name, TypeFun> privateTypeBindings;
|
|
std::unordered_map<Name, Location> typeAliasLocations;
|
|
|
|
std::unordered_map<Name, std::unordered_map<Name, TypeFun>> importedTypeBindings;
|
|
|
|
std::optional<TypeId> lookup(const Symbol& name);
|
|
|
|
std::optional<TypeFun> lookupType(const Name& name);
|
|
std::optional<TypeFun> lookupImportedType(const Name& moduleAlias, const Name& name);
|
|
|
|
std::unordered_map<Name, TypePackId> privateTypePackBindings;
|
|
std::optional<TypePackId> lookupPack(const Name& name);
|
|
|
|
// WARNING: This function linearly scans for a string key of equal value! It is thus O(n**2)
|
|
std::optional<Binding> linearSearchForBinding(const std::string& name, bool traverseScopeChain = true);
|
|
|
|
RefinementMap refinements;
|
|
|
|
// For mutually recursive type aliases, it's important that
|
|
// they use the same types for the same names.
|
|
// For instance, in `type Tree<T> { data: T, children: Forest<T> } type Forest<T> = {Tree<T>}`
|
|
// we need that the generic type `T` in both cases is the same, so we use a cache.
|
|
std::unordered_map<Name, TypeId> typeAliasTypeParameters;
|
|
std::unordered_map<Name, TypePackId> typeAliasTypePackParameters;
|
|
};
|
|
|
|
struct Scope2
|
|
{
|
|
// The parent scope of this scope. Null if there is no parent (i.e. this
|
|
// is the module-level scope).
|
|
Scope2* parent = nullptr;
|
|
// All the children of this scope.
|
|
std::vector<NotNull<Scope2>> children;
|
|
std::unordered_map<Symbol, TypeId> bindings; // TODO: I think this can be a DenseHashMap
|
|
std::unordered_map<Name, TypeId> typeBindings;
|
|
std::unordered_map<Name, TypePackId> typePackBindings;
|
|
TypePackId returnType;
|
|
std::optional<TypePackId> varargPack;
|
|
// All constraints belonging to this scope.
|
|
std::vector<ConstraintPtr> constraints;
|
|
|
|
std::optional<TypeId> lookup(Symbol sym);
|
|
std::optional<TypeId> lookupTypeBinding(const Name& name);
|
|
std::optional<TypePackId> lookupTypePackBinding(const Name& name);
|
|
};
|
|
|
|
} // namespace Luau
|