ArkScript
A small, lisp-inspired, functional scripting language
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 // prioritize non-hidden symbols
74 if ((maybe_name.has_value() &&
75 maybe_name.value().ends_with("#hidden") &&
76 !maybe_fqn.value().name.ends_with("#hidden")) ||
77 !maybe_name.has_value())
78 maybe_name = maybe_fqn.value().name;
79 }
80 }
81 return maybe_name.value_or(name);
82 }
83
84 std::pair<bool, std::string> ScopeResolver::canFullyQualifyName(const std::string& name)
85 {
86 // a given name can be fully qualified if
87 // old == new
88 // old != new and new has prefix
89 // if the prefix namespace is glob
90 // if the prefix namespace has name in its symbols
91 // if the prefix namespace is with_prefix && it is the top most scope
92 const std::string maybe_fqn = getFullyQualifiedNameInNearestScope(name);
93
94 if (maybe_fqn == name)
95 return std::make_pair(true, maybe_fqn);
96
97 const std::string prefix = maybe_fqn.substr(0, maybe_fqn.find_first_of(':'));
98 const std::string unprefixed_name = name.substr(name.find_first_of(':') + 1);
99 auto namespaces =
100 std::ranges::reverse_view(m_scopes) | std::ranges::views::filter([](const auto& e) {
101 return e->isNamespace();
102 });
103 bool top = true;
104 for (auto& scope : namespaces)
105 {
106 if (top && prefix == scope->prefix())
107 return std::make_pair(true, maybe_fqn);
108 if (!top && prefix == scope->prefix() && (scope->isGlob() || scope->hasSymbol(name)))
109 return std::make_pair(true, maybe_fqn);
110
111 // check for the presence of the symbol in symbol imports and glob imports
112 if (scope->recursiveHasSymbol(unprefixed_name))
113 return std::make_pair(true, maybe_fqn);
114
115 top = false;
116 }
117
118 return std::make_pair(false, maybe_fqn);
119 }
120
122 {
123 if (!m_scopes.empty()) [[likely]]
124 return m_scopes.back().get();
125 return nullptr;
126 }
127}
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.