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 children()[2].tryAs<ID>(); }
77  auto unresolvedID() const { return children()[0].tryAs<ID>(); }
78  const auto& index() const { return _index; }
79 
80  // Only one of these will have return value.
81  auto ctor() const { return children()[1].tryAs<Ctor>(); }
82  auto item() const { return children()[1].tryAs<Item>(); }
83  auto type() const { return children()[1].tryAs<Type>(); }
84 
85  auto repeatCount() const { return children()[3].tryAs<Expression>(); }
86  auto attributes() const { return children()[4].tryAs<AttributeSet>(); }
87  auto condition() const { return children()[5].tryAs<Expression>(); }
88  auto arguments() const { return children<Expression>(_args_start, _args_end); }
89  auto sinks() const { return children<Expression>(_sinks_start, _sinks_end); }
90  auto hooks() const { return children<Hook>(_sinks_end, -1); }
91  Engine engine() const { return _engine; }
92 
93  void setIndex(uint64_t index) { _index = index; }
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  const Type& itemType() const { return hilti::type::auto_; }
103  bool isResolved() const { return false; }
104  auto isEqual(const Item& other) const { return node::isEqual(this, other); }
105 
106  // Node interface.
107  auto properties() const { return node::Properties{{"engine", to_string(_engine)}}; }
108 
109 private:
110  Engine _engine;
111  std::optional<uint64_t> _index;
112  const int _args_start;
113  const int _args_end;
114  const int _sinks_start;
115  const int _sinks_end;
116 };
117 
118 } // namespace spicy::type::unit::item
NodeBase(Meta meta)
Definition: node.h:367
Definition: unresolved-field.h:21
const auto & children() const
Definition: node.h:472
Definition: meta.h:19
Definition: attribute.h:174
Definition: type.h:160
Definition: unit-item.h:19
Definition: hook.h:22
Definition: id.h:18
Definition: node.h:360