Spicy
unresolved-field.h
1 // Copyright (c) 2020-2021 by the Zeek Project. See LICENSE for details.
2 
3 #pragma once
4 
5 #include <optional>
6 #include <utility>
7 #include <vector>
8 
9 #include <hilti/ast/types/unknown.h>
10 
11 #include <spicy/ast/aliases.h>
12 #include <spicy/ast/engine.h>
13 #include <spicy/ast/types/unit-item.h>
14 
15 namespace spicy::type::unit::item {
16 
22 public:
23  UnresolvedField(const std::optional<ID>& id, Type type, Engine e, const std::vector<Expression>& args,
24  std::optional<Expression> repeat, const std::vector<Expression>& sinks,
25  std::optional<AttributeSet> attrs = {}, std::optional<Expression> cond = {},
26  std::vector<Hook> hooks = {}, Meta m = Meta())
27 
28  : NodeBase(nodes(node::none, std::move(type), id, std::move(repeat), std::move(attrs), std::move(cond), args,
29  sinks, std::move(hooks)),
30  std::move(m)),
31  _engine(e),
32  _args_start(6),
33  _args_end(_args_start + static_cast<int>(args.size())),
34  _sinks_start(_args_end),
35  _sinks_end(_sinks_start + static_cast<int>(sinks.size())) {}
36 
37  UnresolvedField(const std::optional<ID>& id, Ctor ctor, Engine e, const std::vector<Expression>& args,
38  std::optional<Expression> repeat, const std::vector<Expression>& sinks,
39  std::optional<AttributeSet> attrs = {}, std::optional<Expression> cond = {},
40  std::vector<Hook> hooks = {}, Meta m = Meta())
41  : NodeBase(nodes(node::none, std::move(ctor), id, std::move(repeat), std::move(attrs), std::move(cond), args,
42  sinks, std::move(hooks)),
43  std::move(m)),
44  _engine(e),
45  _args_start(6),
46  _args_end(_args_start + static_cast<int>(args.size())),
47  _sinks_start(_args_end),
48  _sinks_end(_sinks_start + static_cast<int>(sinks.size())) {}
49 
50  UnresolvedField(const std::optional<ID>& id, Item item, Engine e, const std::vector<Expression>& args,
51  std::optional<Expression> repeat, const std::vector<Expression>& sinks,
52  std::optional<AttributeSet> attrs = {}, std::optional<Expression> cond = {},
53  std::vector<Hook> hooks = {}, Meta m = Meta())
54  : NodeBase(nodes(node::none, std::move(item), id, std::move(repeat), std::move(attrs), std::move(cond), args,
55  sinks, std::move(hooks)),
56  std::move(m)),
57  _engine(e),
58  _args_start(6),
59  _args_end(_args_start + static_cast<int>(args.size())),
60  _sinks_start(_args_end),
61  _sinks_end(_sinks_start + static_cast<int>(sinks.size())) {}
62 
63  UnresolvedField(std::optional<ID> id, ID unresolved_id, Engine e, const std::vector<Expression>& args,
64  std::optional<Expression> repeat, const std::vector<Expression>& sinks,
65  std::optional<AttributeSet> attrs = {}, std::optional<Expression> cond = {},
66  std::vector<Hook> hooks = {}, Meta m = Meta())
67  : NodeBase(nodes(std::move(unresolved_id), node::none, std::move(id), std::move(repeat), std::move(attrs),
68  std::move(cond), args, sinks, std::move(hooks)),
69  std::move(m)),
70  _engine(e),
71  _args_start(6),
72  _args_end(_args_start + static_cast<int>(args.size())),
73  _sinks_start(_args_end),
74  _sinks_end(_sinks_start + static_cast<int>(sinks.size())) {}
75 
76  auto fieldID() const { return childs()[2].tryReferenceAs<ID>(); }
77 
78  const auto& index() const { return _index; }
79 
80  auto unresolvedID() const { return childs()[0].tryReferenceAs<ID>(); }
81 
82  // Only one of these will have return value.
83  auto type() const { return childs()[1].tryReferenceAs<Type>(); }
84  auto ctor() const { return childs()[1].tryReferenceAs<Ctor>(); }
85  auto item() const { return childs()[1].tryReferenceAs<Item>(); }
86 
87  auto repeatCount() const { return childs()[3].tryReferenceAs<Expression>(); }
88  auto attributes() const { return childs()[4].tryReferenceAs<AttributeSet>(); }
89  auto condition() const { return childs()[5].tryReferenceAs<Expression>(); }
90  auto arguments() const { return childs<Expression>(_args_start, _args_end); }
91  auto sinks() const { return childs<Expression>(_sinks_start, _sinks_end); }
92  auto hooks() const { return childs<Hook>(_sinks_end, -1); }
93  Engine engine() const { return _engine; }
94 
95  bool operator==(const UnresolvedField& other) const {
96  return _engine == other._engine && unresolvedID() == other.unresolvedID() && fieldID() == other.fieldID() &&
97  attributes() == other.attributes() && arguments() == other.arguments() && sinks() == other.sinks() &&
98  condition() == other.condition() && hooks() == other.hooks();
99  }
100 
101  // Unit item interface
102  Type itemType() const { return hilti::type::unknown; }
103  auto isEqual(const Item& other) const { return node::isEqual(this, other); }
104 
105  // Node interface.
106  auto properties() const { return node::Properties{{"engine", to_string(_engine)}}; }
107 
115  static UnresolvedField setIndex(const UnresolvedField& f, uint64_t index) {
116  auto x = Item(f)._clone().as<UnresolvedField>();
117  x._index = index;
118  return x;
119  }
120 
121 private:
122  Engine _engine;
123  std::optional<uint64_t> _index;
124  const int _args_start;
125  const int _args_end;
126  const int _sinks_start;
127  const int _sinks_end;
128 };
129 
130 } // namespace spicy::type::unit::item
static UnresolvedField setIndex(const UnresolvedField &f, uint64_t index)
Definition: unresolved-field.h:115
NodeBase(Meta meta)
Definition: node.h:325
auto & childs() const
Definition: node.h:445
Definition: unresolved-field.h:21
Definition: meta.h:18
Definition: attribute.h:159
Definition: unit-item.h:19
Definition: unit-item.h:39
Definition: id.h:18
Definition: node.h:318