Spicy
module.h
1 // Copyright (c) 2020-2021 by the Zeek Project. See LICENSE for details.
2 
3 #pragma once
4 
5 #include <set>
6 #include <utility>
7 #include <vector>
8 
9 #include <hilti/ast/declaration.h>
10 #include <hilti/ast/declarations/property.h>
11 #include <hilti/ast/id.h>
12 #include <hilti/ast/node.h>
13 #include <hilti/ast/statement.h>
14 #include <hilti/ast/statements/block.h>
15 #include <hilti/ast/statements/expression.h>
16 #include <hilti/base/util.h>
17 
18 namespace hilti {
19 
21 class Module : public NodeBase, public node::WithDocString {
22 public:
23  Module(ID id, Meta m = Meta()) : NodeBase({std::move(id), statement::Block({}, m)}, std::move(m)) {}
24 
25  Module(ID id, std::vector<Declaration> decls, Meta m = Meta())
26  : NodeBase(nodes(std::move(id), statement::Block({}, m), std::move(decls)), std::move(m)) {}
27 
28  Module(ID id, std::vector<Declaration> decls, std::vector<Statement> stmts, const Meta& m = Meta())
29  : NodeBase(nodes(std::move(id), statement::Block(std::move(stmts), m), std::move(decls)), m) {}
30 
31  Module() : NodeBase(nodes(ID(), statement::Block({}, Meta())), Meta()) {}
32 
33  const auto& id() const { return child<ID>(0); }
34  const auto& statements() const { return child<statement::Block>(1); }
35  auto declarations() const { return childrenOfType<Declaration>(); }
36  auto declarationRefs() const { return childRefsOfType<Declaration>(); }
37 
38  bool isEmpty() const {
39  // We always have an ID and a block as children.
40  return children().size() <= 2 && statements().statements().empty();
41  }
42 
47  void clear();
48 
57 
64  hilti::node::Set<declaration::Property> moduleProperties(const std::optional<ID>& id) const;
65 
74  void add(Declaration n) { addChild(std::move(n)); }
75 
86  void add(Statement s) { children()[1].as<statement::Block>()._add(std::move(s)); }
87 
98  void add(Expression e) { add(statement::Expression(std::move(e))); }
99 
110  NodeRef preserve(const Node& n) {
111  _preserved.push_back(n);
112  return NodeRef(_preserved.back());
113  }
114 
116  void destroyPreservedNodes();
117 
119  auto properties() const { return node::Properties{}; }
120 
121 private:
122  std::vector<Node> _preserved;
123 };
124 
126 inline Node to_node(Module i) { return Node(std::move(i)); }
127 
128 } // namespace hilti
Definition: declaration.h:54
Definition: expression.h:13
void add(Expression e)
Definition: module.h:98
const auto & children() const
Definition: node.h:472
void addChild(Node n)
Definition: node.h:461
void clear()
Definition: module.cc:9
auto properties() const
Definition: module.h:119
Definition: meta.h:19
Definition: node.h:491
Definition: optional-ref.h:22
void add(Statement s)
Definition: module.h:86
Definition: node.h:41
void add(Declaration n)
Definition: module.h:74
Definition: block.h:14
NodeRef preserve(const Node &n)
Definition: module.h:110
std::map< std::string, node::detail::PropertyValue > Properties
Definition: node.h:98
hilti::node::Set< declaration::Property > moduleProperties(const std::optional< ID > &id) const
Definition: module.cc:36
Definition: module.h:21
Definition: node.h:112
void destroyPreservedNodes()
Definition: module.cc:47
Definition: node-ref.h:45
hilti::optional_ref< const declaration::Property > moduleProperty(const ID &id) const
Definition: module.cc:23
Definition: id.h:18
Definition: node.h:360