Skip to content

Commit ac08541

Browse files
jckingcopybara-github
jcking
authored and
copybara-github
committed
Implement machinery for new unknown attribute and unknown function implementation
PiperOrigin-RevId: 996659108
1 parent 0e0ac39 commit ac08541

9 files changed

Lines changed: 1277 additions & 36 deletions

File tree

‎base/BUILD‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -33,6 +33,7 @@ cc_library(
3333
],
3434
deps = [
3535
":kind",
36+
"//internal:lexis",
3637
"//internal:status_macros",
3738
"//internal:strings",
3839
"@com_google_absl//absl/algorithm:container",

‎base/attribute.cc‎

Lines changed: 96 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -30,6 +30,7 @@
3030
#include "absl/strings/str_cat.h"
3131
#include "absl/strings/string_view.h"
3232
#include "base/kind.h"
33+
#include "internal/lexis.h"
3334
#include "internal/status_macros.h"
3435
#include "internal/strings.h"
3536

@@ -133,14 +134,61 @@ struct AttributeQualifierToString {
133134
}
134135

135136
void operator()(absl::string_view value) const {
136-
absl::StrAppend(&output, internal::FormatStringLiteral(value));
137+
if (internal::LexisIsIdentifier(value)) {
138+
absl::StrAppend(&output, value);
139+
} else {
140+
internal::FormatStringLiteralTo(value, &output);
141+
}
142+
}
143+
144+
void operator()(common_internal::WildcardType) const {
145+
output.push_back('*');
146+
}
147+
148+
std::string& output;
149+
};
150+
151+
struct AttributeQualifierJoinString {
152+
void operator()(std::monostate) const {}
153+
154+
void operator()(bool value) const {
155+
output.push_back('[');
156+
output.append(value ? "true" : "false");
157+
output.push_back(']');
158+
}
159+
160+
void operator()(int64_t value) const {
161+
absl::StrAppend(&output, "[", value, "]");
137162
}
138163

139-
void operator()(common_internal::WildcardType) const { output.append("*"); }
164+
void operator()(uint64_t value) const {
165+
absl::StrAppend(&output, "[", value, "u", "]");
166+
}
167+
168+
void operator()(absl::string_view value) const {
169+
if (internal::LexisIsIdentifier(value)) {
170+
absl::StrAppend(&output, ".", value);
171+
} else {
172+
output.push_back('[');
173+
internal::FormatStringLiteralTo(value, &output);
174+
output.push_back(']');
175+
}
176+
}
177+
178+
void operator()(common_internal::WildcardType) const { output.append(".*"); }
140179

141180
std::string& output;
142181
};
143182

183+
template <typename Q>
184+
void AttributeQualifierAppendJoinString(std::string* out,
185+
absl::Span<const Q> qualifiers) {
186+
for (const auto& qualifier : qualifiers) {
187+
std::visit(AttributeQualifierJoinString{*out},
188+
common_internal::AsVariant(qualifier));
189+
}
190+
}
191+
144192
} // namespace
145193

146194
Kind AttributeQualifier::kind() const {
@@ -218,34 +266,61 @@ absl::StatusOr<std::string> Attribute::AsString() const {
218266
std::string Attribute::ToString() const {
219267
std::string result;
220268
result.append(variable_name());
221-
for (const auto& qualifier : qualifier_path()) {
222-
result.push_back('[');
223-
std::visit(AttributeQualifierToString{result},
224-
common_internal::AsVariant(qualifier));
225-
result.push_back(']');
226-
}
269+
AttributeQualifier::AppendJoinString(&result, qualifier_path());
227270
return result;
228271
}
229272

230273
std::string AttributePattern::ToString() const {
231274
std::string result;
232275
result.append(variable());
233-
for (const auto& qualifier : qualifier_path()) {
234-
result.push_back('[');
235-
std::visit(AttributeQualifierToString{result},
236-
common_internal::AsVariant(qualifier));
237-
result.push_back(']');
238-
}
276+
AttributeQualifierPattern::AppendJoinString(&result, qualifier_path());
239277
return result;
240278
}
241279

242-
std::string AttributeQualifier::ToString() const {
243-
std::string result;
244-
absl::Status status =
245-
std::visit(AttributeQualifierStringPrinter{&result}, value_);
246-
ABSL_DCHECK_OK(status) << "bad attribute qualifier";
247-
status.IgnoreError();
248-
return result;
280+
void AttributeQualifier::AppendToString(std::string* absl_nonnull out) const {
281+
std::visit(AttributeQualifierToString{*out}, value_);
282+
}
283+
284+
void AttributeQualifierView::AppendToString(
285+
std::string* absl_nonnull out) const {
286+
std::visit(AttributeQualifierToString{*out}, value_);
287+
}
288+
289+
void AttributeQualifierPattern::AppendToString(
290+
std::string* absl_nonnull out) const {
291+
std::visit(AttributeQualifierToString{*out}, value_);
292+
}
293+
294+
void AttributeQualifier::AppendJoinString(std::string* absl_nonnull out) const {
295+
std::visit(AttributeQualifierJoinString{*out}, value_);
296+
}
297+
298+
void AttributeQualifierView::AppendJoinString(
299+
std::string* absl_nonnull out) const {
300+
std::visit(AttributeQualifierJoinString{*out}, value_);
301+
}
302+
303+
void AttributeQualifierPattern::AppendJoinString(
304+
std::string* absl_nonnull out) const {
305+
std::visit(AttributeQualifierJoinString{*out}, value_);
306+
}
307+
308+
void AttributeQualifier::AppendJoinString(
309+
std::string* absl_nonnull out,
310+
absl::Span<const AttributeQualifier> qualifiers) {
311+
AttributeQualifierAppendJoinString(out, qualifiers);
312+
}
313+
314+
void AttributeQualifierView::AppendJoinString(
315+
std::string* absl_nonnull out,
316+
absl::Span<const AttributeQualifierView> qualifiers) {
317+
AttributeQualifierAppendJoinString(out, qualifiers);
318+
}
319+
320+
void AttributeQualifierPattern::AppendJoinString(
321+
std::string* absl_nonnull out,
322+
absl::Span<const AttributeQualifierPattern> qualifiers) {
323+
AttributeQualifierAppendJoinString(out, qualifiers);
249324
}
250325

251326
bool AttributeQualifier::IsMatch(const AttributeQualifier& other) const {

‎base/attribute.h‎

Lines changed: 69 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -27,6 +27,7 @@
2727

2828
#include "absl/base/attributes.h"
2929
#include "absl/base/macros.h"
30+
#include "absl/base/nullability.h"
3031
#include "absl/functional/overload.h"
3132
#include "absl/log/absl_check.h"
3233
#include "absl/status/statusor.h"
@@ -38,8 +39,10 @@
3839
namespace cel {
3940

4041
namespace common_internal {
41-
class AttributeMatcherNode;
4242
struct WildcardType {};
43+
// Important. The types in the variants must align with each other and the order
44+
// matters. It must be int < uint < string < bool. If you change it here in the
45+
// header you must change the logic in the source.
4346
using AttributeQualifierVariant =
4447
std::variant<std::monostate, int64_t, uint64_t, std::string, bool>;
4548
using AttributeQualifierPatternVariant =
@@ -115,9 +118,6 @@ class AttributeQualifier {
115118

116119
Kind kind() const;
117120

118-
[[nodiscard]]
119-
std::string ToString() const;
120-
121121
ABSL_DEPRECATE_AND_INLINE()
122122
std::optional<int64_t> GetInt64Key() const { return AsInt(); }
123123

@@ -216,6 +216,27 @@ class AttributeQualifier {
216216
return std::nullopt;
217217
}
218218

219+
void AppendToString(std::string* absl_nonnull out) const;
220+
221+
[[nodiscard]]
222+
std::string ToString() const {
223+
std::string out;
224+
AppendToString(&out);
225+
return out;
226+
}
227+
228+
void AppendJoinString(std::string* absl_nonnull out) const;
229+
230+
[[nodiscard]]
231+
std::string JoinString() const {
232+
std::string out;
233+
AppendJoinString(&out);
234+
return out;
235+
}
236+
237+
static void AppendJoinString(std::string* absl_nonnull out,
238+
absl::Span<const AttributeQualifier> qualifiers);
239+
219240
[[nodiscard]]
220241
bool IsMatch(const AttributeQualifier& other) const;
221242

@@ -392,6 +413,28 @@ class AttributeQualifierView {
392413
return std::nullopt;
393414
}
394415

416+
void AppendToString(std::string* absl_nonnull out) const;
417+
418+
[[nodiscard]]
419+
std::string ToString() const {
420+
std::string out;
421+
AppendToString(&out);
422+
return out;
423+
}
424+
425+
void AppendJoinString(std::string* absl_nonnull out) const;
426+
427+
[[nodiscard]]
428+
std::string JoinString() const {
429+
std::string out;
430+
AppendJoinString(&out);
431+
return out;
432+
}
433+
434+
static void AppendJoinString(
435+
std::string* absl_nonnull out,
436+
absl::Span<const AttributeQualifierView> qualifiers);
437+
395438
private:
396439
friend const common_internal::AttributeQualifierViewVariant&
397440
common_internal::AsVariant(const AttributeQualifierView& qualifier);
@@ -633,6 +676,28 @@ class AttributeQualifierPattern {
633676
value_);
634677
}
635678

679+
void AppendToString(std::string* absl_nonnull out) const;
680+
681+
[[nodiscard]]
682+
std::string ToString() const {
683+
std::string out;
684+
AppendToString(&out);
685+
return out;
686+
}
687+
688+
void AppendJoinString(std::string* absl_nonnull out) const;
689+
690+
[[nodiscard]]
691+
std::string JoinString() const {
692+
std::string out;
693+
AppendJoinString(&out);
694+
return out;
695+
}
696+
697+
static void AppendJoinString(
698+
std::string* absl_nonnull out,
699+
absl::Span<const AttributeQualifierPattern> qualifiers);
700+
636701
[[nodiscard]]
637702
bool IsMatch(const AttributeQualifier& qualifier) const;
638703

‎base/attribute_test.cc‎

Lines changed: 62 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,7 @@
1414

1515
#include "base/attribute.h"
1616

17+
#include <cstdint>
1718
#include <optional>
1819

1920
#include "absl/strings/string_view.h"
@@ -80,19 +81,71 @@ TEST(Attribute, ToString) {
8081
EXPECT_EQ(Attribute("foo", {AttributeQualifier::OfBool(true),
8182
AttributeQualifier::OfInt(2),
8283
AttributeQualifier::OfUint(3),
83-
AttributeQualifier::OfString("bar")})
84+
AttributeQualifier::OfString("bar"),
85+
AttributeQualifier::OfString("baz qux")})
8486
.ToString(),
85-
"foo[true][2][3u][\"bar\"]");
87+
"foo[true][2][3u].bar[\"baz qux\"]");
8688
}
8789

8890
TEST(AttributePattern, ToString) {
89-
EXPECT_EQ(AttributePattern("foo", {AttributeQualifierPattern::OfBool(true),
90-
AttributeQualifierPattern::OfInt(2),
91-
AttributeQualifierPattern::OfUint(3),
92-
AttributeQualifierPattern::OfString("bar"),
93-
AttributeQualifierPattern::Wildcard()})
94-
.ToString(),
95-
"foo[true][2][3u][\"bar\"][*]");
91+
EXPECT_EQ(
92+
AttributePattern("foo", {AttributeQualifierPattern::OfBool(true),
93+
AttributeQualifierPattern::OfInt(2),
94+
AttributeQualifierPattern::OfUint(3),
95+
AttributeQualifierPattern::OfString("bar"),
96+
AttributeQualifierPattern::OfString("baz qux"),
97+
AttributeQualifierPattern::Wildcard()})
98+
.ToString(),
99+
"foo[true][2][3u].bar[\"baz qux\"].*");
100+
}
101+
102+
TEST(AttributeQualifierView, Order) {
103+
// int < uint < string < bool
104+
EXPECT_LT(AttributeQualifierView::OfInt(int64_t{0}),
105+
AttributeQualifierView::OfUint(uint64_t{0}));
106+
EXPECT_LT(AttributeQualifierView::OfInt(int64_t{0}),
107+
AttributeQualifierView::OfString(""));
108+
EXPECT_LT(AttributeQualifierView::OfInt(int64_t{0}),
109+
AttributeQualifierView::OfBool(false));
110+
EXPECT_LT(AttributeQualifierView::OfUint(uint64_t{0}),
111+
AttributeQualifierView::OfString(""));
112+
EXPECT_LT(AttributeQualifierView::OfUint(uint64_t{0}),
113+
AttributeQualifierView::OfBool(false));
114+
}
115+
116+
TEST(AttributeQualifierView, TransparentOrder) {
117+
EXPECT_EQ(AttributeQualifierView::OfInt(int64_t{0}),
118+
AttributeQualifier::OfInt(0));
119+
EXPECT_EQ(AttributeQualifierView::OfUint(uint64_t{0}),
120+
AttributeQualifier::OfUint(0));
121+
EXPECT_EQ(AttributeQualifierView::OfString("0"),
122+
AttributeQualifier::OfString("0"));
123+
EXPECT_EQ(AttributeQualifierView::OfBool(false),
124+
AttributeQualifier::OfBool(false));
125+
EXPECT_EQ(AttributeQualifier::OfInt(0),
126+
AttributeQualifierView::OfInt(int64_t{0}));
127+
EXPECT_EQ(AttributeQualifier::OfUint(0),
128+
AttributeQualifierView::OfUint(uint64_t{0}));
129+
EXPECT_EQ(AttributeQualifier::OfString("0"),
130+
AttributeQualifierView::OfString("0"));
131+
EXPECT_EQ(AttributeQualifier::OfBool(false),
132+
AttributeQualifierView::OfBool(false));
133+
EXPECT_LT(AttributeQualifierView::OfInt(int64_t{0}),
134+
AttributeQualifier::OfInt(1));
135+
EXPECT_LT(AttributeQualifierView::OfUint(uint64_t{0}),
136+
AttributeQualifier::OfUint(1));
137+
EXPECT_LT(AttributeQualifierView::OfString("0"),
138+
AttributeQualifier::OfString("1"));
139+
EXPECT_LT(AttributeQualifierView::OfBool(false),
140+
AttributeQualifier::OfBool(true));
141+
EXPECT_LT(AttributeQualifier::OfInt(0),
142+
AttributeQualifierView::OfInt(int64_t{1}));
143+
EXPECT_LT(AttributeQualifier::OfUint(0),
144+
AttributeQualifierView::OfUint(uint64_t{1}));
145+
EXPECT_LT(AttributeQualifier::OfString("0"),
146+
AttributeQualifierView::OfString("1"));
147+
EXPECT_LT(AttributeQualifier::OfBool(false),
148+
AttributeQualifierView::OfBool(true));
96149
}
97150

98151
} // namespace

0 commit comments

Comments
 (0)