ArkScript
A small, fast, functional and scripting language for video games
ScopeResolver.cpp
Go to the documentation of this file.
2
3#include <ranges>
4#include <algorithm>
5
6namespace Ark::internal
7{
9 {
10 createNewNamespace("", /* with_prefix= */ false, /* is_glob= */ true, /* symbols= */ {});
11 }
12
14 {
15 m_scopes.emplace_back(std::make_unique<StaticScope>());
16 }
17
19 {
20 m_scopes.pop_back();
21 }
22
23 void ScopeResolver::createNewNamespace(const std::string& name, bool with_prefix, bool is_glob, const std::vector<std::string>& symbols)
24 {
25 m_scopes.emplace_back(std::make_unique<NamespaceScope>(name, with_prefix, is_glob, symbols));
26 }
27
28 std::string ScopeResolver::registerInCurrent(const std::string& name, const bool is_mutable)
29 {
30 return m_scopes.back()->add(name, is_mutable);
31 }
32
34 {
35 for (auto& m_scope : std::ranges::reverse_view(m_scopes) | std::ranges::views::drop(1))
36 {
37 if (m_scope->saveNamespace(m_scopes.back()))
38 break;
39 }
40
41 m_scopes.pop_back();
42 }
43
44 std::optional<bool> ScopeResolver::isImmutable(const std::string& name) const
45 {
46 for (const auto& m_scope : std::ranges::reverse_view(m_scopes))
47 {
48 if (auto maybe = m_scope->get(name, true); maybe.has_value())
49 return !maybe.value().is_mutable;
50 }
51 return std::nullopt;
52 }
53
54 bool ScopeResolver::isRegistered(const std::string& name) const
55 {
56 return std::ranges::any_of(std::ranges::reverse_view(m_scopes), [&name](const auto& scope) {
57 return scope->get(name, true).has_value();
58 });
59 }
60
61 bool ScopeResolver::isInScope(const std::string& name) const
62 {
63 return m_scopes.back()->get(name, false).has_value();
64 }
65
66 std::string ScopeResolver::getFullyQualifiedNameInNearestScope(const std::string& name) const
67 {
68 std::optional<std::string> maybe_name;
69 for (const auto& scope : std::ranges::reverse_view(m_scopes))
70 {
71 if (auto maybe_fqn = scope->get(name, true); maybe_fqn.has_value())
72 {
73 // priorize non-hidden symbols
74 if ((maybe_name.has_value() && maybe_name.value().ends_with("#hidden")) || !maybe_name.has_value())
75 maybe_name = maybe_fqn.value().name;
76 }
77 }
78 return maybe_name.value_or(name);
79 }
80
81 std::pair<bool, std::string> ScopeResolver::canFullyQualifyName(const std::string& name)
82 {
83 // a given name can be fully qualified if
84 // old == new
85 // old != new and new has prefix
86 // if the prefix namespace is glob
87 // if the prefix namespace has name in its symbols
88 // if the prefix namespace is with_prefix && it is the top most scope
89 const std::string maybe_fqn = getFullyQualifiedNameInNearestScope(name);
90
91 if (maybe_fqn == name)
92 return std::make_pair(true, maybe_fqn);
93
94 const std::string prefix = maybe_fqn.substr(0, maybe_fqn.find_first_of(':'));
95 const std::string unprefixed_name = name.substr(name.find_first_of(':') + 1);
96 auto namespaces =
97 std::ranges::reverse_view(m_scopes) | std::ranges::views::filter([](const auto& e) {
98 return e->isNamespace();
99 });
100 bool top = true;
101 for (auto& scope : namespaces)
102 {
103 if (top && prefix == scope->prefix())
104 return std::make_pair(true, maybe_fqn);
105 if (!top && prefix == scope->prefix() && (scope->isGlob() || scope->hasSymbol(name)))
106 return std::make_pair(true, maybe_fqn);
107
108 // check for the presence of the symbol in symbol imports and glob imports
109 if (scope->recursiveHasSymbol(unprefixed_name))
110 return std::make_pair(true, maybe_fqn);
111
112 top = false;
113 }
114
115 return std::make_pair(false, maybe_fqn);
116 }
117
119 {
120 if (!m_scopes.empty()) [[likely]]
121 return m_scopes.back().get();
122 return nullptr;
123 }
124}
Handle scope resolution at compile time.
std::string registerInCurrent(const std::string &name, bool is_mutable)
Register a Declaration in the current (last) scope.
ScopeResolver()
Create a ScopeResolver.
void createNewNamespace(const std::string &name, bool with_prefix, bool is_glob, const std::vector< std::string > &symbols)
Create a new namespace scope.
void saveNamespaceAndRemove()
Save the last scope as a namespace, by attaching it to the nearest namespace scope.
std::string getFullyQualifiedNameInNearestScope(const std::string &name) const
Get a FQN from a variable name in the nearest scope it is declared in.
bool isRegistered(const std::string &name) const
Checks if any scope has 'name', in reverse order.
void createNew()
Create a new scope.
std::vector< std::unique_ptr< StaticScope > > m_scopes
StaticScope * currentScope() const
Return a non-owning raw pointer to the current scope.
bool isInScope(const std::string &name) const
Checks if 'name' is in the current scope.
void removeLastScope()
Remove the last scope.
std::optional< bool > isImmutable(const std::string &name) const
Checks the scopes in reverse order for 'name' and returns its mutability status.
std::pair< bool, std::string > canFullyQualifyName(const std::string &name)
Checks if a name can be fully qualified (allows only unprefixed names to be resolved by glob namespac...
virtual std::optional< Declaration > get(const std::string &name, bool extensive_lookup)
Try to return a Declaration from this scope with a given name.