From a1fc71d6442c2fbae46df939cf95c66cab59b8ed Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Wed, 26 Nov 2025 00:06:12 +0000 Subject: [PATCH 1/9] Initial plan From b98157681363e76ac30b9da82207c7bb14699461 Mon Sep 17 00:00:00 2001 From: Aaron Webster Date: Tue, 25 Nov 2025 11:56:11 -0800 Subject: [PATCH 2/9] Optimize conditional fields in C++ backend Optimized the generated C++ code for structures with conditional fields by identifying and caching repeated subexpressions (e.g., tag reads) in the `Ok()`, `Equals()`, and `UncheckedEquals()` methods. This approach uses a two-pass generation strategy: 1. Count usage of existence condition subexpressions. 2. Generate code where frequently used subexpressions are cached in local variables at the method scope, while unique expressions are inlined. This reduces redundant computations (CPU optimization) without introducing excessive stack usage for unique conditions (Memory optimization). Also updated test infrastructure to support passing compiler flags to golden tests, fixing `no_enum_traits_golden_test`. Added `testdata/many_conditionals.emb` and `compiler/back_end/cpp/testcode/many_conditionals_benchmark.cc` to verify performance of conditional fields. Performance Analysis (10,000 iterations x 100 tags on `testdata/many_conditionals.emb`): - Baseline Runtime: ~1.83s - Optimized Runtime: ~0.21s (Speedup: ~8.7x) Binary Size Impact (many_conditionals_benchmark, -c opt): - Baseline: 57848 bytes (text: 56112) - Optimized: 30472 bytes (text: 28736) -> ~47% reduction --- compiler/back_end/cpp/BUILD | 12 + compiler/back_end/cpp/build_defs.bzl | 5 +- .../back_end/cpp/generated_code_templates | 14 +- compiler/back_end/cpp/header_generator.py | 64 +++++- compiler/back_end/cpp/one_golden_test.py | 3 + compiler/back_end/cpp/run_one_golden_test.py | 16 +- .../testcode/many_conditionals_benchmark.cc | 33 +++ testdata/BUILD | 7 + testdata/many_conditionals.emb | 205 ++++++++++++++++++ 9 files changed, 349 insertions(+), 10 deletions(-) create mode 100644 compiler/back_end/cpp/testcode/many_conditionals_benchmark.cc create mode 100644 testdata/many_conditionals.emb diff --git a/compiler/back_end/cpp/BUILD b/compiler/back_end/cpp/BUILD index 14eac6a..5e23832 100644 --- a/compiler/back_end/cpp/BUILD +++ b/compiler/back_end/cpp/BUILD @@ -388,6 +388,17 @@ emboss_cc_test( ], ) +emboss_cc_test( + name = "many_conditionals_benchmark", + srcs = [ + "testcode/many_conditionals_benchmark.cc", + ], + deps = [ + "//testdata:many_conditionals_emboss", + "@com_google_googletest//:gtest_main", + ], +) + # New golden test infrastructure py_library( name = "one_golden_test_lib", @@ -535,6 +546,7 @@ cpp_golden_test( cpp_golden_test( name = "no_enum_traits_golden_test", emb_file = "//testdata:no_enum_traits.emb", + extra_args = ["--no-cc-enum-traits"], golden_file = "//testdata/golden_cpp:no_enum_traits.emb.h", ) diff --git a/compiler/back_end/cpp/build_defs.bzl b/compiler/back_end/cpp/build_defs.bzl index 78d22f3..3775466 100644 --- a/compiler/back_end/cpp/build_defs.bzl +++ b/compiler/back_end/cpp/build_defs.bzl @@ -46,7 +46,7 @@ def emboss_cc_test(name, copts = None, no_w_sign_compare = False, **kwargs): **kwargs ) -def cpp_golden_test(name, emb_file, golden_file, import_dirs = []): +def cpp_golden_test(name, emb_file, golden_file, import_dirs = [], extra_args = []): """Defines a C++ golden file test. Args: @@ -54,6 +54,7 @@ def cpp_golden_test(name, emb_file, golden_file, import_dirs = []): emb_file: The .emb file to test. golden_file: The golden .h file. import_dirs: A list of import directories. + extra_args: A list of extra arguments to pass to the compiler. """ py_test( name = name, @@ -65,7 +66,7 @@ def cpp_golden_test(name, emb_file, golden_file, import_dirs = []): "$(location :emboss_codegen_cpp)", "$(location %s)" % emb_file, "$(location %s)" % golden_file, - ] + ["--import-dir=" + d for d in import_dirs], + ] + ["--import-dir=" + d for d in import_dirs] + extra_args, data = [ "//compiler/front_end:emboss_front_end", ":emboss_codegen_cpp", diff --git a/compiler/back_end/cpp/generated_code_templates b/compiler/back_end/cpp/generated_code_templates index e8f7c46..5ea3ca5 100644 --- a/compiler/back_end/cpp/generated_code_templates +++ b/compiler/back_end/cpp/generated_code_templates @@ -127,6 +127,7 @@ class Generic${name}View final { bool Ok() const { if (!IsComplete()) return false; ${parameter_ok_checks} +${ok_subexpressions} ${field_ok_checks} ${requires_check} return true; @@ -391,11 +392,14 @@ ${write_fields} // ** ok_method_test ** //////////////////////////////////////////////////////// // If we don't have enough information to determine whether ${field} is // present in the structure, then structure.Ok() should be false. - if (!has_${field}.Known()) return false; - // If ${field} is present, but not Ok(), then structure.Ok() should be - // false. If ${field} is not present, it does not matter whether it is - // Ok(). - if (has_${field}.ValueOrDefault() && !${field}.Ok()) return false; + { + const auto emboss_reserved_local_field_present = ${existence_condition}; + if (!emboss_reserved_local_field_present.Known()) return false; + // If ${field} is present, but not Ok(), then structure.Ok() should be + // false. If ${field} is not present, it does not matter whether it is + // Ok(). + if (emboss_reserved_local_field_present.ValueOrDefault() && !${field}.Ok()) return false; + } // ** equals_method_test ** //////////////////////////////////////////////////// diff --git a/compiler/back_end/cpp/header_generator.py b/compiler/back_end/cpp/header_generator.py index 5860bc8..30ba343 100644 --- a/compiler/back_end/cpp/header_generator.py +++ b/compiler/back_end/cpp/header_generator.py @@ -791,6 +791,47 @@ def subexprs(self): ] +class _UsageCountingStore(object): + """A mock SubexpressionStore that counts subexpression usage.""" + + def __init__(self): + self.counts = collections.defaultdict(int) + + def add(self, subexpr): + self.counts[subexpr] += 1 + return subexpr + + + + + +class _SmartSubexpressionStore(object): + """A SubexpressionStore that only caches subexpressions used multiple times.""" + + def __init__(self, prefix, counts): + self._prefix = prefix + self._counts = counts + self._subexpr_to_name = {} + self._index_to_subexpr = [] + + def add(self, subexpr): + if self._counts[subexpr] <= 1: + return subexpr + + if subexpr not in self._subexpr_to_name: + self._index_to_subexpr.append(subexpr) + self._subexpr_to_name[subexpr] = self._prefix + str( + len(self._index_to_subexpr) + ) + return self._subexpr_to_name[subexpr] + + def subexprs(self): + return [ + (self._subexpr_to_name[subexpr], subexpr) + for subexpr in self._index_to_subexpr + ] + + _ExpressionResult = collections.namedtuple( "ExpressionResult", ["rendered", "is_constant"] ) @@ -871,7 +912,9 @@ def _render_expression(expression, ir, field_reader=None, subexpressions=None): def _render_existence_test(field, ir, subexpressions=None): - return _render_expression(field.existence_condition, ir, subexpressions) + return _render_expression( + field.existence_condition, ir, subexpressions=subexpressions + ) def _alignment_of_location(location): @@ -1421,6 +1464,16 @@ def _generate_structure_definition(type_ir, ir, config: Config): initialize_parameters_initialized_true = "" parameter_checks = [""] + # Pass 1: Count subexpression usage. + ok_usage_counter = _UsageCountingStore() + for field_index in type_ir.structure.fields_in_dependency_order: + field = type_ir.structure.field[field_index] + _render_existence_test(field, ir, ok_usage_counter) + + # Pass 2: Generate code using smart store. + ok_subexpressions = _SmartSubexpressionStore( + "emboss_reserved_local_ok_subexpr_", ok_usage_counter.counts + ) for field_index in type_ir.structure.fields_in_dependency_order: field = type_ir.structure.field[field_index] helper_types, declaration, definition = _generate_structure_field_methods( @@ -1432,6 +1485,9 @@ def _generate_structure_definition(type_ir, ir, config: Config): code_template.format_template( _TEMPLATES.ok_method_test, field=_cpp_field_name(field.name.name.text) + "()", + existence_condition=_render_existence_test( + field, ir, subexpressions=ok_subexpressions + ).rendered, ) ) if not ir_util.field_is_virtual(field): @@ -1499,6 +1555,12 @@ def _generate_structure_definition(type_ir, ir, config: Config): size_method=_render_size_method(type_ir.structure.field, ir), field_method_declarations="".join(field_method_declarations), field_ok_checks="\n".join(ok_method_clauses), + ok_subexpressions="".join( + [ + " const auto {} = {};\n".format(name, subexpr) + for name, subexpr in ok_subexpressions.subexprs() + ] + ), parameter_ok_checks="\n".join(parameter_checks), requires_check=requires_check, equals_method_body="\n".join(equals_method_clauses), diff --git a/compiler/back_end/cpp/one_golden_test.py b/compiler/back_end/cpp/one_golden_test.py index 196e4a2..6c65491 100644 --- a/compiler/back_end/cpp/one_golden_test.py +++ b/compiler/back_end/cpp/one_golden_test.py @@ -27,6 +27,7 @@ def __init__( emb_file, golden_file, include_dirs=None, + compiler_flags=None, ): super(OneGoldenTest, self).__init__("test_golden_file") self.emboss_front_end = emboss_front_end @@ -34,6 +35,7 @@ def __init__( self.emb_file = emb_file self.golden_file = golden_file self.include_dirs = include_dirs if include_dirs is not None else [] + self.compiler_flags = compiler_flags if compiler_flags is not None else [] def test_golden_file(self): temp_dir = os.environ.get("TEST_TMPDIR", "") @@ -61,6 +63,7 @@ def test_golden_file(self): "--output-file", output_path, ] + compiler_args.extend(self.compiler_flags) process = subprocess.run(compiler_args, capture_output=True, text=True) diff --git a/compiler/back_end/cpp/run_one_golden_test.py b/compiler/back_end/cpp/run_one_golden_test.py index 36f166e..7e8b6fc 100644 --- a/compiler/back_end/cpp/run_one_golden_test.py +++ b/compiler/back_end/cpp/run_one_golden_test.py @@ -34,12 +34,24 @@ def main(argv): emboss_compiler = argv[2] emb_file = argv[3] golden_file = argv[4] - include_dirs = argv[5:] + + include_dirs = [] + compiler_flags = [] + for arg in argv[5:]: + if arg.startswith("--import-dir="): + include_dirs.append(arg[len("--import-dir="):]) + else: + compiler_flags.append(arg) suite = unittest.TestSuite() suite.addTest( OneGoldenTest( - emboss_front_end, emboss_compiler, emb_file, golden_file, include_dirs + emboss_front_end, + emboss_compiler, + emb_file, + golden_file, + include_dirs, + compiler_flags, ) ) runner = unittest.TextTestRunner() diff --git a/compiler/back_end/cpp/testcode/many_conditionals_benchmark.cc b/compiler/back_end/cpp/testcode/many_conditionals_benchmark.cc new file mode 100644 index 0000000..826e226 --- /dev/null +++ b/compiler/back_end/cpp/testcode/many_conditionals_benchmark.cc @@ -0,0 +1,33 @@ +#include +#include "testdata/many_conditionals.emb.h" +#include +#include +#include + +// A simple test that acts as a benchmark/sanity check. +// Since this file is in compiler/back_end/cpp/testcode/, it will be built as a cc_test. +// We can use GoogleTest macros. + +TEST(ComplexConditionals, PerformanceBenchmark) { + std::vector buffer(100, 0); + auto view = emboss::test::MakeLargeConditionalsView(&buffer); + + auto start = std::chrono::high_resolution_clock::now(); + int iterations = 10000; + volatile bool result = false; + for (int i = 0; i < iterations; ++i) { + for (int tag = 0; tag < 100; ++tag) { + view.tag().Write(tag); + result = view.Ok(); + } + } + auto end = std::chrono::high_resolution_clock::now(); + + std::chrono::duration elapsed = end - start; + // We don't strictly fail on time, but we print it. + // In a real CI system we might assert upper bounds. + std::cout << "Time for " << iterations << " iterations (x100 tags): " << elapsed.count() << "s" << std::endl; + + EXPECT_TRUE(result); + EXPECT_TRUE(view.Ok()); +} diff --git a/testdata/BUILD b/testdata/BUILD index 95716da..7b27f25 100644 --- a/testdata/BUILD +++ b/testdata/BUILD @@ -369,3 +369,10 @@ emboss_cc_library( "complex_offset.emb", ], ) + +emboss_cc_library( + name = "many_conditionals_emboss", + srcs = [ + "many_conditionals.emb", + ], +) diff --git a/testdata/many_conditionals.emb b/testdata/many_conditionals.emb new file mode 100644 index 0000000..e8d9e16 --- /dev/null +++ b/testdata/many_conditionals.emb @@ -0,0 +1,205 @@ +[(cpp) namespace: "emboss::test"] +[$default byte_order: "LittleEndian"] + +struct LargeConditionals: + 0 [+4] UInt tag + if tag == 0: + 4 [+4] UInt f0 + if tag == 1: + 4 [+4] UInt f1 + if tag == 2: + 4 [+4] UInt f2 + if tag == 3: + 4 [+4] UInt f3 + if tag == 4: + 4 [+4] UInt f4 + if tag == 5: + 4 [+4] UInt f5 + if tag == 6: + 4 [+4] UInt f6 + if tag == 7: + 4 [+4] UInt f7 + if tag == 8: + 4 [+4] UInt f8 + if tag == 9: + 4 [+4] UInt f9 + if tag == 10: + 4 [+4] UInt f10 + if tag == 11: + 4 [+4] UInt f11 + if tag == 12: + 4 [+4] UInt f12 + if tag == 13: + 4 [+4] UInt f13 + if tag == 14: + 4 [+4] UInt f14 + if tag == 15: + 4 [+4] UInt f15 + if tag == 16: + 4 [+4] UInt f16 + if tag == 17: + 4 [+4] UInt f17 + if tag == 18: + 4 [+4] UInt f18 + if tag == 19: + 4 [+4] UInt f19 + if tag == 20: + 4 [+4] UInt f20 + if tag == 21: + 4 [+4] UInt f21 + if tag == 22: + 4 [+4] UInt f22 + if tag == 23: + 4 [+4] UInt f23 + if tag == 24: + 4 [+4] UInt f24 + if tag == 25: + 4 [+4] UInt f25 + if tag == 26: + 4 [+4] UInt f26 + if tag == 27: + 4 [+4] UInt f27 + if tag == 28: + 4 [+4] UInt f28 + if tag == 29: + 4 [+4] UInt f29 + if tag == 30: + 4 [+4] UInt f30 + if tag == 31: + 4 [+4] UInt f31 + if tag == 32: + 4 [+4] UInt f32 + if tag == 33: + 4 [+4] UInt f33 + if tag == 34: + 4 [+4] UInt f34 + if tag == 35: + 4 [+4] UInt f35 + if tag == 36: + 4 [+4] UInt f36 + if tag == 37: + 4 [+4] UInt f37 + if tag == 38: + 4 [+4] UInt f38 + if tag == 39: + 4 [+4] UInt f39 + if tag == 40: + 4 [+4] UInt f40 + if tag == 41: + 4 [+4] UInt f41 + if tag == 42: + 4 [+4] UInt f42 + if tag == 43: + 4 [+4] UInt f43 + if tag == 44: + 4 [+4] UInt f44 + if tag == 45: + 4 [+4] UInt f45 + if tag == 46: + 4 [+4] UInt f46 + if tag == 47: + 4 [+4] UInt f47 + if tag == 48: + 4 [+4] UInt f48 + if tag == 49: + 4 [+4] UInt f49 + if tag == 50: + 4 [+4] UInt f50 + if tag == 51: + 4 [+4] UInt f51 + if tag == 52: + 4 [+4] UInt f52 + if tag == 53: + 4 [+4] UInt f53 + if tag == 54: + 4 [+4] UInt f54 + if tag == 55: + 4 [+4] UInt f55 + if tag == 56: + 4 [+4] UInt f56 + if tag == 57: + 4 [+4] UInt f57 + if tag == 58: + 4 [+4] UInt f58 + if tag == 59: + 4 [+4] UInt f59 + if tag == 60: + 4 [+4] UInt f60 + if tag == 61: + 4 [+4] UInt f61 + if tag == 62: + 4 [+4] UInt f62 + if tag == 63: + 4 [+4] UInt f63 + if tag == 64: + 4 [+4] UInt f64 + if tag == 65: + 4 [+4] UInt f65 + if tag == 66: + 4 [+4] UInt f66 + if tag == 67: + 4 [+4] UInt f67 + if tag == 68: + 4 [+4] UInt f68 + if tag == 69: + 4 [+4] UInt f69 + if tag == 70: + 4 [+4] UInt f70 + if tag == 71: + 4 [+4] UInt f71 + if tag == 72: + 4 [+4] UInt f72 + if tag == 73: + 4 [+4] UInt f73 + if tag == 74: + 4 [+4] UInt f74 + if tag == 75: + 4 [+4] UInt f75 + if tag == 76: + 4 [+4] UInt f76 + if tag == 77: + 4 [+4] UInt f77 + if tag == 78: + 4 [+4] UInt f78 + if tag == 79: + 4 [+4] UInt f79 + if tag == 80: + 4 [+4] UInt f80 + if tag == 81: + 4 [+4] UInt f81 + if tag == 82: + 4 [+4] UInt f82 + if tag == 83: + 4 [+4] UInt f83 + if tag == 84: + 4 [+4] UInt f84 + if tag == 85: + 4 [+4] UInt f85 + if tag == 86: + 4 [+4] UInt f86 + if tag == 87: + 4 [+4] UInt f87 + if tag == 88: + 4 [+4] UInt f88 + if tag == 89: + 4 [+4] UInt f89 + if tag == 90: + 4 [+4] UInt f90 + if tag == 91: + 4 [+4] UInt f91 + if tag == 92: + 4 [+4] UInt f92 + if tag == 93: + 4 [+4] UInt f93 + if tag == 94: + 4 [+4] UInt f94 + if tag == 95: + 4 [+4] UInt f95 + if tag == 96: + 4 [+4] UInt f96 + if tag == 97: + 4 [+4] UInt f97 + if tag == 98: + 4 [+4] UInt f98 + if tag == 99: + 4 [+4] UInt f99 From 607c97730477958a4d070192e5614468a13606ee Mon Sep 17 00:00:00 2001 From: Aaron Webster Date: Tue, 25 Nov 2025 13:01:24 -0800 Subject: [PATCH 3/9] Format files --- compiler/back_end/cpp/header_generator.py | 3401 +++++++++-------- compiler/back_end/cpp/run_one_golden_test.py | 75 +- .../testcode/many_conditionals_benchmark.cc | 22 +- testdata/BUILD | 3 - testdata/many_conditionals.emb | 302 +- 5 files changed, 1965 insertions(+), 1838 deletions(-) diff --git a/compiler/back_end/cpp/header_generator.py b/compiler/back_end/cpp/header_generator.py index 30ba343..77087b9 100644 --- a/compiler/back_end/cpp/header_generator.py +++ b/compiler/back_end/cpp/header_generator.py @@ -37,121 +37,119 @@ resources.load("compiler.back_end.cpp", "generated_code_templates") ) -_CPP_RESERVED_WORDS = set( - ( - # C keywords. A few of these are not (yet) C++ keywords, but some compilers - # accept the superset of C and C++, so we still want to avoid them. - "asm", - "auto", - "break", - "case", - "char", - "const", - "continue", - "default", - "do", - "double", - "else", - "enum", - "extern", - "float", - "for", - "fortran", - "goto", - "if", - "inline", - "int", - "long", - "register", - "restrict", - "return", - "short", - "signed", - "sizeof", - "static", - "struct", - "switch", - "typedef", - "union", - "unsigned", - "void", - "volatile", - "while", - "_Alignas", - "_Alignof", - "_Atomic", - "_Bool", - "_Complex", - "_Generic", - "_Imaginary", - "_Noreturn", - "_Pragma", - "_Static_assert", - "_Thread_local", - # The following are not technically reserved words, but collisions are - # likely due to the standard macros. - "complex", - "imaginary", - "noreturn", - # C++ keywords that are not also C keywords. - "alignas", - "alignof", - "and", - "and_eq", - "asm", - "bitand", - "bitor", - "bool", - "catch", - "char16_t", - "char32_t", - "class", - "compl", - "concept", - "constexpr", - "const_cast", - "decltype", - "delete", - "dynamic_cast", - "explicit", - "export", - "false", - "friend", - "mutable", - "namespace", - "new", - "noexcept", - "not", - "not_eq", - "nullptr", - "operator", - "or", - "or_eq", - "private", - "protected", - "public", - "reinterpret_cast", - "requires", - "static_assert", - "static_cast", - "template", - "this", - "thread_local", - "throw", - "true", - "try", - "typeid", - "typename", - "using", - "virtual", - "wchar_t", - "xor", - "xor_eq", - # "NULL" is not a keyword, but is still very likely to cause problems if - # used as a namespace name. - "NULL", - ) -) +_CPP_RESERVED_WORDS = set(( + # C keywords. A few of these are not (yet) C++ keywords, but some compilers + # accept the superset of C and C++, so we still want to avoid them. + "asm", + "auto", + "break", + "case", + "char", + "const", + "continue", + "default", + "do", + "double", + "else", + "enum", + "extern", + "float", + "for", + "fortran", + "goto", + "if", + "inline", + "int", + "long", + "register", + "restrict", + "return", + "short", + "signed", + "sizeof", + "static", + "struct", + "switch", + "typedef", + "union", + "unsigned", + "void", + "volatile", + "while", + "_Alignas", + "_Alignof", + "_Atomic", + "_Bool", + "_Complex", + "_Generic", + "_Imaginary", + "_Noreturn", + "_Pragma", + "_Static_assert", + "_Thread_local", + # The following are not technically reserved words, but collisions are + # likely due to the standard macros. + "complex", + "imaginary", + "noreturn", + # C++ keywords that are not also C keywords. + "alignas", + "alignof", + "and", + "and_eq", + "asm", + "bitand", + "bitor", + "bool", + "catch", + "char16_t", + "char32_t", + "class", + "compl", + "concept", + "constexpr", + "const_cast", + "decltype", + "delete", + "dynamic_cast", + "explicit", + "export", + "false", + "friend", + "mutable", + "namespace", + "new", + "noexcept", + "not", + "not_eq", + "nullptr", + "operator", + "or", + "or_eq", + "private", + "protected", + "public", + "reinterpret_cast", + "requires", + "static_assert", + "static_cast", + "template", + "this", + "thread_local", + "throw", + "true", + "try", + "typeid", + "typename", + "using", + "virtual", + "wchar_t", + "xor", + "xor_eq", + # "NULL" is not a keyword, but is still very likely to cause problems if + # used as a namespace name. + "NULL", +)) # The support namespace, as a C++ namespace prefix. This namespace contains the # Emboss C++ support classes. @@ -176,211 +174,218 @@ # Verify that all supported enum cases have valid, implemented conversions. for _enum_case in _SUPPORTED_ENUM_CASES: - assert name_conversion.is_case_conversion_supported("SHOUTY_CASE", _enum_case) + assert name_conversion.is_case_conversion_supported("SHOUTY_CASE", _enum_case) class Config(NamedTuple): - """Configuration for C++ header generation.""" + """Configuration for C++ header generation.""" - include_enum_traits: bool = True - """Whether or not to include EnumTraits in the generated header.""" + include_enum_traits: bool = True + """Whether or not to include EnumTraits in the generated header.""" def _get_namespace_components(namespace): - """Gets the components of a C++ namespace. + """Gets the components of a C++ namespace. - Examples: - "::some::name::detail" -> ["some", "name", "detail"] - "product::name" -> ["product", "name"] - "simple" -> ["simple"] + Examples: + "::some::name::detail" -> ["some", "name", "detail"] + "product::name" -> ["product", "name"] + "simple" -> ["simple"] - Arguments: - namespace: A string containing the namespace. May be fully-qualified. + Arguments: + namespace: A string containing the namespace. May be fully-qualified. - Returns: - A list of strings, one per namespace component.""" - return re.findall(_NS_COMPONENT_RE, namespace) + Returns: + A list of strings, one per namespace component. + """ + return re.findall(_NS_COMPONENT_RE, namespace) def _get_module_namespace(module): - """Returns the C++ namespace of the module, as a list of components. - - Arguments: - module: The IR of an Emboss module whose namespace should be returned. - - Returns: - A list of strings, one per namespace component. This list can be formatted - as appropriate by the caller. - """ - namespace_attr = ir_util.get_attribute(module.attribute, "namespace") - if namespace_attr and namespace_attr.string_constant.text: - namespace = namespace_attr.string_constant.text - else: - namespace = "emboss_generated_code" - return _get_namespace_components(namespace) + """Returns the C++ namespace of the module, as a list of components. + + Arguments: + module: The IR of an Emboss module whose namespace should be returned. + + Returns: + A list of strings, one per namespace component. This list can be formatted + as appropriate by the caller. + """ + namespace_attr = ir_util.get_attribute(module.attribute, "namespace") + if namespace_attr and namespace_attr.string_constant.text: + namespace = namespace_attr.string_constant.text + else: + namespace = "emboss_generated_code" + return _get_namespace_components(namespace) def _cpp_string_escape(string): - return re.sub("['\"\\\\]", r"\\\0", string) + return re.sub("['\"\\\\]", r"\\\0", string) def _get_includes(module, config: Config): - """Returns the appropriate #includes based on module's imports.""" - includes = [] - for import_ in module.foreign_import: - if import_.file_name.text: - includes.append( - code_template.format_template( - _TEMPLATES.include, - file_name=_cpp_string_escape(import_.file_name.text + ".h"), - ) + """Returns the appropriate #includes based on module's imports.""" + includes = [] + for import_ in module.foreign_import: + if import_.file_name.text: + includes.append( + code_template.format_template( + _TEMPLATES.include, + file_name=_cpp_string_escape(import_.file_name.text + ".h"), + ) + ) + else: + includes.append( + code_template.format_template( + _TEMPLATES.include, + file_name=_cpp_string_escape(_PRELUDE_INCLUDE_FILE), + ) + ) + if config.include_enum_traits: + includes.extend([ + code_template.format_template( + _TEMPLATES.include, file_name=_cpp_string_escape(file_name) ) - else: - includes.append( - code_template.format_template( - _TEMPLATES.include, - file_name=_cpp_string_escape(_PRELUDE_INCLUDE_FILE), - ) + for file_name in ( + _ENUM_VIEW_INCLUDE_FILE, + _TEXT_UTIL_INCLUDE_FILE, ) - if config.include_enum_traits: - includes.extend( - [ - code_template.format_template( - _TEMPLATES.include, file_name=_cpp_string_escape(file_name) - ) - for file_name in ( - _ENUM_VIEW_INCLUDE_FILE, - _TEXT_UTIL_INCLUDE_FILE, - ) - ] - ) - return "".join(includes) + ]) + return "".join(includes) def _render_namespace_prefix(namespace): - """Returns namespace rendered as a prefix, like ::foo::bar::baz.""" - return "".join(["::" + n for n in namespace]) + """Returns namespace rendered as a prefix, like ::foo::bar::baz.""" + return "".join(["::" + n for n in namespace]) def _render_integer(value): - """Returns a C++ string representation of a constant integer.""" - integer_type = _cpp_integer_type_for_range(value, value) - assert ( - integer_type - ), "Bug: value should never be outside [-2**63, 2**64), " "got {}.".format(value) - # C++ literals are always positive. Negative constants are actually the - # positive literal with the unary `-` operator applied. - # - # This means that C++ compilers for 2s-complement systems get finicky about - # minimum integers: if you feed `-9223372036854775808` into GCC, with -Wall, - # you get: - # - # warning: integer constant is so large that it is unsigned - # - # and Clang gives: - # - # warning: integer literal is too large to be represented in a signed - # integer type, interpreting as unsigned [-Wimplicitly-unsigned-literal] - # - # and MSVC: - # - # warning C4146: unary minus operator applied to unsigned type, result - # still unsigned - # - # So, workaround #1: -(2**63) must be written `(-9223372036854775807 - 1)`. - # - # The next problem is that MSVC (but not Clang or GCC) will pick `unsigned` - # as the type of a literal like `2147483648`. As far as I can tell, this is a - # violation of the C++11 standard, but it's possible that the final standard - # has different rules. (MSVC seems to treat decimal literals the way that the - # standard says octal and hexadecimal literals should be treated.) - # - # Luckily, workaround #2: we can unconditionally append `LL` to all constants - # to force them to be interpreted as `long long` (or `unsigned long long` for - # `ULL`-suffixed constants), and then use a narrowing cast to the appropriate - # type, without any warnings on any major compilers. - # - # TODO(bolms): This suffix computation is kind of a hack. - suffix = "U" if "uint" in integer_type else "" - if value == -(2**63): - return "static_cast({1}LL - 1)".format(integer_type, -(2**63 - 1)) - else: - return "static_cast({1}{2}LL)".format(integer_type, value, suffix) + """Returns a C++ string representation of a constant integer.""" + integer_type = _cpp_integer_type_for_range(value, value) + assert ( + integer_type + ), "Bug: value should never be outside [-2**63, 2**64), got {}.".format(value) + # C++ literals are always positive. Negative constants are actually the + # positive literal with the unary `-` operator applied. + # + # This means that C++ compilers for 2s-complement systems get finicky about + # minimum integers: if you feed `-9223372036854775808` into GCC, with -Wall, + # you get: + # + # warning: integer constant is so large that it is unsigned + # + # and Clang gives: + # + # warning: integer literal is too large to be represented in a signed + # integer type, interpreting as unsigned [-Wimplicitly-unsigned-literal] + # + # and MSVC: + # + # warning C4146: unary minus operator applied to unsigned type, result + # still unsigned + # + # So, workaround #1: -(2**63) must be written `(-9223372036854775807 - 1)`. + # + # The next problem is that MSVC (but not Clang or GCC) will pick `unsigned` + # as the type of a literal like `2147483648`. As far as I can tell, this is a + # violation of the C++11 standard, but it's possible that the final standard + # has different rules. (MSVC seems to treat decimal literals the way that the + # standard says octal and hexadecimal literals should be treated.) + # + # Luckily, workaround #2: we can unconditionally append `LL` to all constants + # to force them to be interpreted as `long long` (or `unsigned long long` for + # `ULL`-suffixed constants), and then use a narrowing cast to the appropriate + # type, without any warnings on any major compilers. + # + # TODO(bolms): This suffix computation is kind of a hack. + suffix = "U" if "uint" in integer_type else "" + if value == -(2**63): + return "static_cast({1}LL - 1)".format(integer_type, -(2**63 - 1)) + else: + return "static_cast({1}{2}LL)".format(integer_type, value, suffix) def _maybe_type(wrapped_type): - return "::emboss::support::Maybe".format(wrapped_type) + return "::emboss::support::Maybe".format(wrapped_type) def _render_integer_for_expression(value): - integer_type = _cpp_integer_type_for_range(value, value) - return "{0}({1})".format(_maybe_type(integer_type), _render_integer(value)) + integer_type = _cpp_integer_type_for_range(value, value) + return "{0}({1})".format(_maybe_type(integer_type), _render_integer(value)) def _wrap_in_namespace(body, namespace): - """Returns the given body wrapped in the given namespace.""" - for component in reversed(namespace): - body = ( - code_template.format_template( - _TEMPLATES.namespace_wrap, component=component, body=body - ) - + "\n" + """Returns the given body wrapped in the given namespace.""" + for component in reversed(namespace): + body = ( + code_template.format_template( + _TEMPLATES.namespace_wrap, component=component, body=body ) - return body + + "\n" + ) + return body def _get_type_size(type_ir, ir): - size = ir_util.fixed_size_of_type_in_bits(type_ir, ir) - assert ( - size is not None - ), "_get_type_size should only be called for constant-sized types." - return size + size = ir_util.fixed_size_of_type_in_bits(type_ir, ir) + assert ( + size is not None + ), "_get_type_size should only be called for constant-sized types." + return size def _offset_storage_adapter(buffer_type, alignment, static_offset): - return "{}::template OffsetStorageType".format( - buffer_type, alignment, static_offset - ) + return "{}::template OffsetStorageType".format( + buffer_type, alignment, static_offset + ) def _bytes_to_bits_convertor(buffer_type, byte_order, size): - assert byte_order, "byte_order should not be empty." - return "{}::BitBlock, {}>".format( - _SUPPORT_NAMESPACE, _SUPPORT_NAMESPACE, byte_order, buffer_type, size - ) + assert byte_order, "byte_order should not be empty." + return "{}::BitBlock, {}>".format( + _SUPPORT_NAMESPACE, _SUPPORT_NAMESPACE, byte_order, buffer_type, size + ) def _get_fully_qualified_namespace(name, ir): - module = ir_util.find_object((name.module_file,), ir) - namespace = _render_namespace_prefix(_get_module_namespace(module)) - return namespace + "".join(["::" + str(s) for s in name.object_path[:-1]]) + module = ir_util.find_object((name.module_file,), ir) + namespace = _render_namespace_prefix(_get_module_namespace(module)) + return namespace + "".join(["::" + str(s) for s in name.object_path[:-1]]) def _get_unqualified_name(name): - return name.object_path[-1] + return name.object_path[-1] def _get_fully_qualified_name(name, ir): - return _get_fully_qualified_namespace(name, ir) + "::" + _get_unqualified_name(name) + return ( + _get_fully_qualified_namespace(name, ir) + + "::" + + _get_unqualified_name(name) + ) def _get_adapted_cpp_buffer_type_for_field( - type_definition, size_in_bits, buffer_type, byte_order, parent_addressable_unit + type_definition, + size_in_bits, + buffer_type, + byte_order, + parent_addressable_unit, ): - """Returns the adapted C++ type information needed to construct a view.""" - if ( - parent_addressable_unit == ir_data.AddressableUnit.BYTE - and type_definition.addressable_unit == ir_data.AddressableUnit.BIT - ): - assert byte_order - return _bytes_to_bits_convertor(buffer_type, byte_order, size_in_bits) - else: - assert ( - parent_addressable_unit == type_definition.addressable_unit - ), "Addressable unit mismatch: {} vs {}".format( - parent_addressable_unit, type_definition.addressable_unit - ) - return buffer_type + """Returns the adapted C++ type information needed to construct a view.""" + if ( + parent_addressable_unit == ir_data.AddressableUnit.BYTE + and type_definition.addressable_unit == ir_data.AddressableUnit.BIT + ): + assert byte_order + return _bytes_to_bits_convertor(buffer_type, byte_order, size_in_bits) + else: + assert ( + parent_addressable_unit == type_definition.addressable_unit + ), "Addressable unit mismatch: {} vs {}".format( + parent_addressable_unit, type_definition.addressable_unit + ) + return buffer_type def _get_cpp_view_type_for_type_definition( @@ -392,444 +397,457 @@ def _get_cpp_view_type_for_type_definition( parent_addressable_unit, validator, ): - """Returns the C++ type information needed to construct a view. - - Returns the C++ type for a view of the given Emboss TypeDefinition, and the - C++ types of its parameters, if any. - - Arguments: - type_definition: The ir_data.TypeDefinition whose view should be - constructed. - size: The size, in type_definition.addressable_units, of the instantiated - type, or None if it is not known at compile time. - ir: The complete IR. - buffer_type: The C++ type to be used as the Storage parameter of the view - (e.g., "ContiguousBuffer<...>"). - byte_order: For BIT types which are direct children of BYTE types, - "LittleEndian", "BigEndian", or "None". Otherwise, None. - parent_addressable_unit: The addressable_unit_size of the structure - containing this structure. - validator: The name of the validator type to be injected into the view. - - Returns: - A tuple of: the C++ view type and a (possibly-empty) list of the C++ types - of Emboss parameters which must be passed to the view's constructor. - """ - adapted_buffer_type = _get_adapted_cpp_buffer_type_for_field( - type_definition, size, buffer_type, byte_order, parent_addressable_unit - ) - if type_definition.has_field("external"): - # Externals do not (yet) support runtime parameters. - return ( - code_template.format_template( - _TEMPLATES.external_view_type, - namespace=_get_fully_qualified_namespace( - type_definition.name.canonical_name, ir - ), - name=_get_unqualified_name(type_definition.name.canonical_name), - bits=size, - validator=validator, - buffer_type=adapted_buffer_type, + """Returns the C++ type information needed to construct a view. + + Returns the C++ type for a view of the given Emboss TypeDefinition, and the + C++ types of its parameters, if any. + + Arguments: + type_definition: The ir_data.TypeDefinition whose view should be + constructed. + size: The size, in type_definition.addressable_units, of the instantiated + type, or None if it is not known at compile time. + ir: The complete IR. + buffer_type: The C++ type to be used as the Storage parameter of the view + (e.g., "ContiguousBuffer<...>"). + byte_order: For BIT types which are direct children of BYTE types, + "LittleEndian", "BigEndian", or "None". Otherwise, None. + parent_addressable_unit: The addressable_unit_size of the structure + containing this structure. + validator: The name of the validator type to be injected into the view. + + Returns: + A tuple of: the C++ view type and a (possibly-empty) list of the C++ types + of Emboss parameters which must be passed to the view's constructor. + """ + adapted_buffer_type = _get_adapted_cpp_buffer_type_for_field( + type_definition, size, buffer_type, byte_order, parent_addressable_unit + ) + if type_definition.has_field("external"): + # Externals do not (yet) support runtime parameters. + return ( + code_template.format_template( + _TEMPLATES.external_view_type, + namespace=_get_fully_qualified_namespace( + type_definition.name.canonical_name, ir ), - [], - ) - elif type_definition.has_field("structure"): - parameter_types = [] - for parameter in type_definition.runtime_parameter: - parameter_types.append( - _cpp_basic_type_for_expression_type(parameter.type, ir) - ) - return ( - code_template.format_template( - _TEMPLATES.structure_view_type, - namespace=_get_fully_qualified_namespace( - type_definition.name.canonical_name, ir - ), - name=_get_unqualified_name(type_definition.name.canonical_name), - buffer_type=adapted_buffer_type, + name=_get_unqualified_name(type_definition.name.canonical_name), + bits=size, + validator=validator, + buffer_type=adapted_buffer_type, + ), + [], + ) + elif type_definition.has_field("structure"): + parameter_types = [] + for parameter in type_definition.runtime_parameter: + parameter_types.append( + _cpp_basic_type_for_expression_type(parameter.type, ir) + ) + return ( + code_template.format_template( + _TEMPLATES.structure_view_type, + namespace=_get_fully_qualified_namespace( + type_definition.name.canonical_name, ir ), - parameter_types, - ) - elif type_definition.has_field("enumeration"): - return ( - code_template.format_template( - _TEMPLATES.enum_view_type, - support_namespace=_SUPPORT_NAMESPACE, - enum_type=_get_fully_qualified_name( - type_definition.name.canonical_name, ir - ), - bits=size, - validator=validator, - buffer_type=adapted_buffer_type, + name=_get_unqualified_name(type_definition.name.canonical_name), + buffer_type=adapted_buffer_type, + ), + parameter_types, + ) + elif type_definition.has_field("enumeration"): + return ( + code_template.format_template( + _TEMPLATES.enum_view_type, + support_namespace=_SUPPORT_NAMESPACE, + enum_type=_get_fully_qualified_name( + type_definition.name.canonical_name, ir ), - [], - ) - else: - assert False, "Unknown variety of type {}".format(type_definition) + bits=size, + validator=validator, + buffer_type=adapted_buffer_type, + ), + [], + ) + else: + assert False, "Unknown variety of type {}".format(type_definition) def _get_cpp_view_type_for_physical_type( - type_ir, size, byte_order, ir, buffer_type, parent_addressable_unit, validator + type_ir, + size, + byte_order, + ir, + buffer_type, + parent_addressable_unit, + validator, ): - """Returns the C++ type information needed to construct a field's view. - - Returns the C++ type of an ir_data.Type, and the C++ types of its parameters, - if any. - - Arguments: - type_ir: The ir_data.Type whose view should be constructed. - size: The size, in type_definition.addressable_units, of the instantiated - type, or None if it is not known at compile time. - byte_order: For BIT types which are direct children of BYTE types, - "LittleEndian", "BigEndian", or "None". Otherwise, None. - ir: The complete IR. - buffer_type: The C++ type to be used as the Storage parameter of the view - (e.g., "ContiguousBuffer<...>"). - parent_addressable_unit: The addressable_unit_size of the structure - containing this type. - validator: The name of the validator type to be injected into the view. - - Returns: - A tuple of: the C++ type for a view of the given Emboss Type and a list of - the C++ types of any parameters of the view type, which should be passed - to the view's constructor. - """ - if ir_util.is_array(type_ir): - # An array view is parameterized by the element's view type. - base_type = type_ir.array_type.base_type - element_size_in_bits = _get_type_size(base_type, ir) - assert ( - element_size_in_bits - ), "TODO(bolms): Implement arrays of dynamically-sized elements." - assert ( - element_size_in_bits % parent_addressable_unit == 0 - ), "Array elements must fall on byte boundaries." - element_size = element_size_in_bits // parent_addressable_unit - element_view_type, element_view_parameter_types, element_view_parameters = ( - _get_cpp_view_type_for_physical_type( - base_type, - element_size_in_bits, - byte_order, - ir, - _offset_storage_adapter(buffer_type, element_size, 0), - parent_addressable_unit, - validator, - ) - ) - return ( - code_template.format_template( - _TEMPLATES.array_view_adapter, - support_namespace=_SUPPORT_NAMESPACE, - # TODO(bolms): The element size should be calculable from the field - # size and array length. - element_view_type=element_view_type, - element_view_parameter_types="".join( - ", " + p for p in element_view_parameter_types - ), - element_size=element_size, - addressable_unit_size=int(parent_addressable_unit), - buffer_type=buffer_type, - ), - element_view_parameter_types, - element_view_parameters, - ) - else: - assert type_ir.has_field("atomic_type") - reference = type_ir.atomic_type.reference - referenced_type = ir_util.find_object(reference, ir) - if parent_addressable_unit > referenced_type.addressable_unit: - assert byte_order, repr(type_ir) - reader, parameter_types = _get_cpp_view_type_for_type_definition( - referenced_type, - size, - ir, - buffer_type, + """Returns the C++ type information needed to construct a field's view. + + Returns the C++ type of an ir_data.Type, and the C++ types of its parameters, + if any. + + Arguments: + type_ir: The ir_data.Type whose view should be constructed. + size: The size, in type_definition.addressable_units, of the instantiated + type, or None if it is not known at compile time. + byte_order: For BIT types which are direct children of BYTE types, + "LittleEndian", "BigEndian", or "None". Otherwise, None. + ir: The complete IR. + buffer_type: The C++ type to be used as the Storage parameter of the view + (e.g., "ContiguousBuffer<...>"). + parent_addressable_unit: The addressable_unit_size of the structure + containing this type. + validator: The name of the validator type to be injected into the view. + + Returns: + A tuple of: the C++ type for a view of the given Emboss Type and a list of + the C++ types of any parameters of the view type, which should be passed + to the view's constructor. + """ + if ir_util.is_array(type_ir): + # An array view is parameterized by the element's view type. + base_type = type_ir.array_type.base_type + element_size_in_bits = _get_type_size(base_type, ir) + assert ( + element_size_in_bits + ), "TODO(bolms): Implement arrays of dynamically-sized elements." + assert ( + element_size_in_bits % parent_addressable_unit == 0 + ), "Array elements must fall on byte boundaries." + element_size = element_size_in_bits // parent_addressable_unit + element_view_type, element_view_parameter_types, element_view_parameters = ( + _get_cpp_view_type_for_physical_type( + base_type, + element_size_in_bits, byte_order, + ir, + _offset_storage_adapter(buffer_type, element_size, 0), parent_addressable_unit, validator, ) - return reader, parameter_types, list(type_ir.atomic_type.runtime_parameter) + ) + return ( + code_template.format_template( + _TEMPLATES.array_view_adapter, + support_namespace=_SUPPORT_NAMESPACE, + # TODO(bolms): The element size should be calculable from the field + # size and array length. + element_view_type=element_view_type, + element_view_parameter_types="".join( + ", " + p for p in element_view_parameter_types + ), + element_size=element_size, + addressable_unit_size=int(parent_addressable_unit), + buffer_type=buffer_type, + ), + element_view_parameter_types, + element_view_parameters, + ) + else: + assert type_ir.has_field("atomic_type") + reference = type_ir.atomic_type.reference + referenced_type = ir_util.find_object(reference, ir) + if parent_addressable_unit > referenced_type.addressable_unit: + assert byte_order, repr(type_ir) + reader, parameter_types = _get_cpp_view_type_for_type_definition( + referenced_type, + size, + ir, + buffer_type, + byte_order, + parent_addressable_unit, + validator, + ) + return reader, parameter_types, list(type_ir.atomic_type.runtime_parameter) def _render_variable(variable, prefix=""): - """Renders a variable reference (e.g., `foo` or `foo.bar.baz`) in C++ code.""" - # A "variable" could be an immediate field or a subcomponent of an immediate - # field. For either case, in C++ it is valid to just use the last component - # of the name; it is not necessary to qualify the method with the type. - components = [] - for component in variable: - components.append(_cpp_field_name(component[-1]) + "()") - components[-1] = prefix + components[-1] - return ".".join(components) + """Renders a variable reference (e.g., `foo` or `foo.bar.baz`) in C++ code.""" + # A "variable" could be an immediate field or a subcomponent of an immediate + # field. For either case, in C++ it is valid to just use the last component + # of the name; it is not necessary to qualify the method with the type. + components = [] + for component in variable: + components.append(_cpp_field_name(component[-1]) + "()") + components[-1] = prefix + components[-1] + return ".".join(components) def _render_enum_value(enum_type, ir): - cpp_enum_type = _get_fully_qualified_name(enum_type.name.canonical_name, ir) - return "{}(static_cast({}))".format( - _maybe_type(cpp_enum_type), cpp_enum_type, enum_type.value - ) + cpp_enum_type = _get_fully_qualified_name(enum_type.name.canonical_name, ir) + return "{}(static_cast({}))".format( + _maybe_type(cpp_enum_type), cpp_enum_type, enum_type.value + ) def _builtin_function_name(function): - """Returns the C++ operator name corresponding to an Emboss operator.""" - functions = { - ir_data.FunctionMapping.ADDITION: "Sum", - ir_data.FunctionMapping.SUBTRACTION: "Difference", - ir_data.FunctionMapping.MULTIPLICATION: "Product", - ir_data.FunctionMapping.EQUALITY: "Equal", - ir_data.FunctionMapping.INEQUALITY: "NotEqual", - ir_data.FunctionMapping.AND: "And", - ir_data.FunctionMapping.OR: "Or", - ir_data.FunctionMapping.LESS: "LessThan", - ir_data.FunctionMapping.LESS_OR_EQUAL: "LessThanOrEqual", - ir_data.FunctionMapping.GREATER: "GreaterThan", - ir_data.FunctionMapping.GREATER_OR_EQUAL: "GreaterThanOrEqual", - ir_data.FunctionMapping.CHOICE: "Choice", - ir_data.FunctionMapping.MAXIMUM: "Maximum", - } - return functions[function] + """Returns the C++ operator name corresponding to an Emboss operator.""" + functions = { + ir_data.FunctionMapping.ADDITION: "Sum", + ir_data.FunctionMapping.SUBTRACTION: "Difference", + ir_data.FunctionMapping.MULTIPLICATION: "Product", + ir_data.FunctionMapping.EQUALITY: "Equal", + ir_data.FunctionMapping.INEQUALITY: "NotEqual", + ir_data.FunctionMapping.AND: "And", + ir_data.FunctionMapping.OR: "Or", + ir_data.FunctionMapping.LESS: "LessThan", + ir_data.FunctionMapping.LESS_OR_EQUAL: "LessThanOrEqual", + ir_data.FunctionMapping.GREATER: "GreaterThan", + ir_data.FunctionMapping.GREATER_OR_EQUAL: "GreaterThanOrEqual", + ir_data.FunctionMapping.CHOICE: "Choice", + ir_data.FunctionMapping.MAXIMUM: "Maximum", + } + return functions[function] def _cpp_basic_type_for_expression_type(expression_type, ir): - """Returns the C++ basic type (int32_t, bool, etc.) for an ExpressionType.""" - if expression_type.which_type == "integer": - return _cpp_integer_type_for_range( - int(expression_type.integer.minimum_value), - int(expression_type.integer.maximum_value), - ) - elif expression_type.which_type == "boolean": - return "bool" - elif expression_type.which_type == "enumeration": - return _get_fully_qualified_name( - expression_type.enumeration.name.canonical_name, ir - ) - else: - assert False, "Unknown expression type " + expression_type.which_type + """Returns the C++ basic type (int32_t, bool, etc.) for an ExpressionType.""" + if expression_type.which_type == "integer": + return _cpp_integer_type_for_range( + int(expression_type.integer.minimum_value), + int(expression_type.integer.maximum_value), + ) + elif expression_type.which_type == "boolean": + return "bool" + elif expression_type.which_type == "enumeration": + return _get_fully_qualified_name( + expression_type.enumeration.name.canonical_name, ir + ) + else: + assert False, "Unknown expression type " + expression_type.which_type def _cpp_basic_type_for_expression(expression, ir): - """Returns the C++ basic type (int32_t, bool, etc.) for an Expression.""" - return _cpp_basic_type_for_expression_type(expression.type, ir) + """Returns the C++ basic type (int32_t, bool, etc.) for an Expression.""" + return _cpp_basic_type_for_expression_type(expression.type, ir) def _cpp_integer_type_for_range(min_val, max_val): - """Returns the appropriate C++ integer type to hold min_val up to max_val.""" - # The choice of int32_t, uint32_t, int64_t, then uint64_t is somewhat - # arbitrary here, and might not be perfectly ideal. I (bolms@) have chosen - # this set of types to a) minimize the number of casts that occur in - # arithmetic expressions, and b) favor 32-bit arithmetic, which is mostly - # "cheapest" on current (2018) systems. Signed integers are also preferred - # over unsigned so that the C++ compiler can take advantage of undefined - # overflow. - for size in (32, 64): - if min_val >= -(2 ** (size - 1)) and max_val <= 2 ** (size - 1) - 1: - return "::std::int{}_t".format(size) - elif min_val >= 0 and max_val <= 2**size - 1: - return "::std::uint{}_t".format(size) - return None + """Returns the appropriate C++ integer type to hold min_val up to max_val.""" + # The choice of int32_t, uint32_t, int64_t, then uint64_t is somewhat + # arbitrary here, and might not be perfectly ideal. I (bolms@) have chosen + # this set of types to a) minimize the number of casts that occur in + # arithmetic expressions, and b) favor 32-bit arithmetic, which is mostly + # "cheapest" on current (2018) systems. Signed integers are also preferred + # over unsigned so that the C++ compiler can take advantage of undefined + # overflow. + for size in (32, 64): + if min_val >= -(2 ** (size - 1)) and max_val <= 2 ** (size - 1) - 1: + return "::std::int{}_t".format(size) + elif min_val >= 0 and max_val <= 2**size - 1: + return "::std::uint{}_t".format(size) + return None def _cpp_integer_type_for_enum(max_bits, is_signed): - """Returns the appropriate C++ integer type to hold an enum.""" - # This is used to determine the `X` in `enum class : X`. - # - # Unlike _cpp_integer_type_for_range, the type chosen here is used for actual - # storage. Further, sizes smaller than 64 are explicitly chosen by a human - # author, so take the smallest size that can hold the given number of bits. - # - # Technically, the C++ standard allows some of these sizes of integer to not - # exist, and other sizes (say, int24_t) might exist, but in practice this set - # is almost always available. If you're compiling for some exotic DSP that - # uses unusual int sizes, email emboss-dev@google.com. - for size in (8, 16, 32, 64): - if max_bits <= size: - return "::std::{}int{}_t".format("" if is_signed else "u", size) - assert False, f"Invalid value {max_bits} for maximum_bits" + """Returns the appropriate C++ integer type to hold an enum.""" + # This is used to determine the `X` in `enum class : X`. + # + # Unlike _cpp_integer_type_for_range, the type chosen here is used for actual + # storage. Further, sizes smaller than 64 are explicitly chosen by a human + # author, so take the smallest size that can hold the given number of bits. + # + # Technically, the C++ standard allows some of these sizes of integer to not + # exist, and other sizes (say, int24_t) might exist, but in practice this set + # is almost always available. If you're compiling for some exotic DSP that + # uses unusual int sizes, email emboss-dev@google.com. + for size in (8, 16, 32, 64): + if max_bits <= size: + return "::std::{}int{}_t".format("" if is_signed else "u", size) + assert False, f"Invalid value {max_bits} for maximum_bits" def _render_builtin_operation(expression, ir, field_reader, subexpressions): - """Renders a built-in operation (+, -, &&, etc.) into C++ code.""" - assert expression.function.function not in ( - ir_data.FunctionMapping.UPPER_BOUND, - ir_data.FunctionMapping.LOWER_BOUND, - ), "UPPER_BOUND and LOWER_BOUND should be constant." - if expression.function.function == ir_data.FunctionMapping.PRESENCE: - return field_reader.render_existence( - expression.function.args[0], subexpressions - ) - args = expression.function.args - rendered_args = [ - _render_expression(arg, ir, field_reader, subexpressions).rendered - for arg in args - ] - minimum_integers = [] - maximum_integers = [] - enum_types = set() - have_boolean_types = False - for subexpression in [expression] + list(args): - if subexpression.type.which_type == "integer": - minimum_integers.append(int(subexpression.type.integer.minimum_value)) - maximum_integers.append(int(subexpression.type.integer.maximum_value)) - elif subexpression.type.which_type == "enumeration": - enum_types.add(_cpp_basic_type_for_expression(subexpression, ir)) - elif subexpression.type.which_type == "boolean": - have_boolean_types = True - # At present, all Emboss functions other than `$has` take and return one of - # the following: - # - # integers - # integers and booleans - # a single enum type - # a single enum type and booleans - # booleans - # - # Really, the intermediate type is only necessary for integers, but it - # simplifies the C++ somewhat if the appropriate enum/boolean type is provided - # as "IntermediateT" -- it means that, e.g., the choice ("?:") operator does - # not have to have two versions, one of which casts (some of) its arguments to - # IntermediateT, and one of which does not. - # - # This is not a particularly robust scheme, but it works for all of the Emboss - # functions I (bolms@) have written and am considering (division, modulus, - # exponentiation, logical negation, bit shifts, bitwise and/or/xor, $min, - # $floor, $ceil, $has). - if minimum_integers and not enum_types: - intermediate_type = _cpp_integer_type_for_range( - min(minimum_integers), max(maximum_integers) - ) - elif len(enum_types) == 1 and not minimum_integers: - intermediate_type = list(enum_types)[0] - else: - assert have_boolean_types - assert not enum_types - assert not minimum_integers - intermediate_type = "bool" - arg_types = [_cpp_basic_type_for_expression(arg, ir) for arg in args] - result_type = _cpp_basic_type_for_expression(expression, ir) - function_variant = "".format( - intermediate_type, result_type, ", ".join(arg_types) + """Renders a built-in operation (+, -, &&, etc.) into C++ code.""" + assert expression.function.function not in ( + ir_data.FunctionMapping.UPPER_BOUND, + ir_data.FunctionMapping.LOWER_BOUND, + ), "UPPER_BOUND and LOWER_BOUND should be constant." + if expression.function.function == ir_data.FunctionMapping.PRESENCE: + return field_reader.render_existence( + expression.function.args[0], subexpressions ) - return "::emboss::support::{}{}({})".format( - _builtin_function_name(expression.function.function), - function_variant, - ", ".join(rendered_args), + args = expression.function.args + rendered_args = [ + _render_expression(arg, ir, field_reader, subexpressions).rendered + for arg in args + ] + minimum_integers = [] + maximum_integers = [] + enum_types = set() + have_boolean_types = False + for subexpression in [expression] + list(args): + if subexpression.type.which_type == "integer": + minimum_integers.append(int(subexpression.type.integer.minimum_value)) + maximum_integers.append(int(subexpression.type.integer.maximum_value)) + elif subexpression.type.which_type == "enumeration": + enum_types.add(_cpp_basic_type_for_expression(subexpression, ir)) + elif subexpression.type.which_type == "boolean": + have_boolean_types = True + # At present, all Emboss functions other than `$has` take and return one of + # the following: + # + # integers + # integers and booleans + # a single enum type + # a single enum type and booleans + # booleans + # + # Really, the intermediate type is only necessary for integers, but it + # simplifies the C++ somewhat if the appropriate enum/boolean type is provided + # as "IntermediateT" -- it means that, e.g., the choice ("?:") operator does + # not have to have two versions, one of which casts (some of) its arguments to + # IntermediateT, and one of which does not. + # + # This is not a particularly robust scheme, but it works for all of the Emboss + # functions I (bolms@) have written and am considering (division, modulus, + # exponentiation, logical negation, bit shifts, bitwise and/or/xor, $min, + # $floor, $ceil, $has). + if minimum_integers and not enum_types: + intermediate_type = _cpp_integer_type_for_range( + min(minimum_integers), max(maximum_integers) ) + elif len(enum_types) == 1 and not minimum_integers: + intermediate_type = list(enum_types)[0] + else: + assert have_boolean_types + assert not enum_types + assert not minimum_integers + intermediate_type = "bool" + arg_types = [_cpp_basic_type_for_expression(arg, ir) for arg in args] + result_type = _cpp_basic_type_for_expression(expression, ir) + function_variant = "".format( + intermediate_type, result_type, ", ".join(arg_types) + ) + return "::emboss::support::{}{}({})".format( + _builtin_function_name(expression.function.function), + function_variant, + ", ".join(rendered_args), + ) class _FieldRenderer(object): - """Base class for rendering field reads.""" + """Base class for rendering field reads.""" - def render_field_read_with_context(self, expression, ir, prefix, subexpressions): - field = prefix + _render_variable( - ir_util.hashable_form_of_field_reference(expression.field_reference) - ) - if subexpressions is None: - field_expression = field - else: - field_expression = subexpressions.add(field) - expression_cpp_type = _cpp_basic_type_for_expression(expression, ir) - return ( - "({0}.Ok()" - " ? {1}(static_cast({0}.UncheckedRead()))" - " : {1}())".format( - field_expression, _maybe_type(expression_cpp_type), expression_cpp_type - ) + def render_field_read_with_context( + self, expression, ir, prefix, subexpressions + ): + field = prefix + _render_variable( + ir_util.hashable_form_of_field_reference(expression.field_reference) + ) + if subexpressions is None: + field_expression = field + else: + field_expression = subexpressions.add(field) + expression_cpp_type = _cpp_basic_type_for_expression(expression, ir) + return ( + "({0}.Ok()" + " ? {1}(static_cast({0}.UncheckedRead()))" + " : {1}())".format( + field_expression, + _maybe_type(expression_cpp_type), + expression_cpp_type, ) + ) - def render_existence_with_context(self, expression, prefix, subexpressions): - return "{1}{0}".format( - _render_variable( - ir_util.hashable_form_of_field_reference(expression.field_reference), - "has_", + def render_existence_with_context(self, expression, prefix, subexpressions): + return "{1}{0}".format( + _render_variable( + ir_util.hashable_form_of_field_reference( + expression.field_reference ), - prefix, - ) + "has_", + ), + prefix, + ) class _DirectFieldRenderer(_FieldRenderer): - """Renderer for fields read from inside a structure's View type.""" + """Renderer for fields read from inside a structure's View type.""" - def render_field(self, expression, ir, subexpressions): - return self.render_field_read_with_context(expression, ir, "", subexpressions) + def render_field(self, expression, ir, subexpressions): + return self.render_field_read_with_context( + expression, ir, "", subexpressions + ) - def render_existence(self, expression, subexpressions): - return self.render_existence_with_context(expression, "", subexpressions) + def render_existence(self, expression, subexpressions): + return self.render_existence_with_context(expression, "", subexpressions) class _VirtualViewFieldRenderer(_FieldRenderer): - """Renderer for field reads from inside a virtual field's View.""" + """Renderer for field reads from inside a virtual field's View.""" - def render_existence(self, expression, subexpressions): - return self.render_existence_with_context(expression, "view_.", subexpressions) + def render_existence(self, expression, subexpressions): + return self.render_existence_with_context( + expression, "view_.", subexpressions + ) - def render_field(self, expression, ir, subexpressions): - return self.render_field_read_with_context( - expression, ir, "view_.", subexpressions - ) + def render_field(self, expression, ir, subexpressions): + return self.render_field_read_with_context( + expression, ir, "view_.", subexpressions + ) class _SubexpressionStore(object): - """Holder for subexpressions to be assigned to local variables.""" - - def __init__(self, prefix): - self._prefix = prefix - self._subexpr_to_name = {} - self._index_to_subexpr = [] - - def add(self, subexpr): - if subexpr not in self._subexpr_to_name: - self._index_to_subexpr.append(subexpr) - self._subexpr_to_name[subexpr] = self._prefix + str( - len(self._index_to_subexpr) - ) - return self._subexpr_to_name[subexpr] - - def subexprs(self): - return [ - (self._subexpr_to_name[subexpr], subexpr) - for subexpr in self._index_to_subexpr - ] + """Holder for subexpressions to be assigned to local variables.""" + + def __init__(self, prefix): + self._prefix = prefix + self._subexpr_to_name = {} + self._index_to_subexpr = [] + + def add(self, subexpr): + if subexpr not in self._subexpr_to_name: + self._index_to_subexpr.append(subexpr) + self._subexpr_to_name[subexpr] = self._prefix + str( + len(self._index_to_subexpr) + ) + return self._subexpr_to_name[subexpr] + + def subexprs(self): + return [ + (self._subexpr_to_name[subexpr], subexpr) + for subexpr in self._index_to_subexpr + ] class _UsageCountingStore(object): - """A mock SubexpressionStore that counts subexpression usage.""" - - def __init__(self): - self.counts = collections.defaultdict(int) - - def add(self, subexpr): - self.counts[subexpr] += 1 - return subexpr - + """A mock SubexpressionStore that counts subexpression usage.""" + def __init__(self): + self.counts = collections.defaultdict(int) + def add(self, subexpr): + self.counts[subexpr] += 1 + return subexpr class _SmartSubexpressionStore(object): - """A SubexpressionStore that only caches subexpressions used multiple times.""" - - def __init__(self, prefix, counts): - self._prefix = prefix - self._counts = counts - self._subexpr_to_name = {} - self._index_to_subexpr = [] - - def add(self, subexpr): - if self._counts[subexpr] <= 1: - return subexpr - - if subexpr not in self._subexpr_to_name: - self._index_to_subexpr.append(subexpr) - self._subexpr_to_name[subexpr] = self._prefix + str( - len(self._index_to_subexpr) - ) - return self._subexpr_to_name[subexpr] - - def subexprs(self): - return [ - (self._subexpr_to_name[subexpr], subexpr) - for subexpr in self._index_to_subexpr - ] + """A SubexpressionStore that only caches subexpressions used multiple times.""" + + def __init__(self, prefix, counts): + self._prefix = prefix + self._counts = counts + self._subexpr_to_name = {} + self._index_to_subexpr = [] + + def add(self, subexpr): + if self._counts[subexpr] <= 1: + return subexpr + + if subexpr not in self._subexpr_to_name: + self._index_to_subexpr.append(subexpr) + self._subexpr_to_name[subexpr] = self._prefix + str( + len(self._index_to_subexpr) + ) + return self._subexpr_to_name[subexpr] + + def subexprs(self): + return [ + (self._subexpr_to_name[subexpr], subexpr) + for subexpr in self._index_to_subexpr + ] _ExpressionResult = collections.namedtuple( @@ -838,1190 +856,1197 @@ def subexprs(self): def _render_expression(expression, ir, field_reader=None, subexpressions=None): - """Renders an expression into C++ code. - - Arguments: - expression: The expression to render. - ir: The IR in which to look up references. - field_reader: An object with render_existence and render_field methods - appropriate for the C++ context of the expression. - subexpressions: A _SubexpressionStore in which to put subexpressions, or - None if subexpressions should be inline. - - Returns: - A tuple of (rendered_text, is_constant), where rendered_text is C++ code - that can be emitted, and is_constant is True if the expression is a - compile-time constant suitable for use in a C++11 constexpr context, - otherwise False. - """ - if field_reader is None: - field_reader = _DirectFieldRenderer() - - # If the expression is constant, there are no guarantees that subexpressions - # will fit into C++ types, or that operator arguments and return types can fit - # in the same type: expressions like `-0x8000_0000_0000_0000` and - # `0x1_0000_0000_0000_0000 - 1` can appear. - if expression.type.which_type == "integer": - if expression.type.integer.modulus == "infinity": - return _ExpressionResult( - _render_integer_for_expression( - int(expression.type.integer.modular_value) - ), - True, - ) - elif expression.type.which_type == "boolean": - if expression.type.boolean.has_field("value"): - if expression.type.boolean.value: - return _ExpressionResult(_maybe_type("bool") + "(true)", True) - else: - return _ExpressionResult(_maybe_type("bool") + "(false)", True) - elif expression.type.which_type == "enumeration": - if expression.type.enumeration.has_field("value"): - return _ExpressionResult( - _render_enum_value(expression.type.enumeration, ir), True - ) - else: - # There shouldn't be any "opaque" type expressions here. - assert False, "Unhandled expression type {}".format(expression.type.which_type) - - result = None - # Otherwise, render the operation. - if expression.which_expression == "function": - result = _render_builtin_operation(expression, ir, field_reader, subexpressions) - elif expression.which_expression == "field_reference": - result = field_reader.render_field(expression, ir, subexpressions) - elif ( - expression.which_expression == "builtin_reference" - and expression.builtin_reference.canonical_name.object_path[-1] - == "$logical_value" - ): - return _ExpressionResult( - _maybe_type("decltype(emboss_reserved_local_value)") - + "(emboss_reserved_local_value)", - False, - ) + """Renders an expression into C++ code. + + Arguments: + expression: The expression to render. + ir: The IR in which to look up references. + field_reader: An object with render_existence and render_field methods + appropriate for the C++ context of the expression. + subexpressions: A _SubexpressionStore in which to put subexpressions, or + None if subexpressions should be inline. + + Returns: + A tuple of (rendered_text, is_constant), where rendered_text is C++ code + that can be emitted, and is_constant is True if the expression is a + compile-time constant suitable for use in a C++11 constexpr context, + otherwise False. + """ + if field_reader is None: + field_reader = _DirectFieldRenderer() + + # If the expression is constant, there are no guarantees that subexpressions + # will fit into C++ types, or that operator arguments and return types can fit + # in the same type: expressions like `-0x8000_0000_0000_0000` and + # `0x1_0000_0000_0000_0000 - 1` can appear. + if expression.type.which_type == "integer": + if expression.type.integer.modulus == "infinity": + return _ExpressionResult( + _render_integer_for_expression( + int(expression.type.integer.modular_value) + ), + True, + ) + elif expression.type.which_type == "boolean": + if expression.type.boolean.has_field("value"): + if expression.type.boolean.value: + return _ExpressionResult(_maybe_type("bool") + "(true)", True) + else: + return _ExpressionResult(_maybe_type("bool") + "(false)", True) + elif expression.type.which_type == "enumeration": + if expression.type.enumeration.has_field("value"): + return _ExpressionResult( + _render_enum_value(expression.type.enumeration, ir), True + ) + else: + # There shouldn't be any "opaque" type expressions here. + assert False, "Unhandled expression type {}".format( + expression.type.which_type + ) - # Any of the constant expression types should have been handled in the - # previous section. - assert result is not None, "Unable to render expression {}".format(str(expression)) + result = None + # Otherwise, render the operation. + if expression.which_expression == "function": + result = _render_builtin_operation( + expression, ir, field_reader, subexpressions + ) + elif expression.which_expression == "field_reference": + result = field_reader.render_field(expression, ir, subexpressions) + elif ( + expression.which_expression == "builtin_reference" + and expression.builtin_reference.canonical_name.object_path[-1] + == "$logical_value" + ): + return _ExpressionResult( + _maybe_type("decltype(emboss_reserved_local_value)") + + "(emboss_reserved_local_value)", + False, + ) - if subexpressions is None: - return _ExpressionResult(result, False) - else: - return _ExpressionResult(subexpressions.add(result), False) + # Any of the constant expression types should have been handled in the + # previous section. + assert result is not None, "Unable to render expression {}".format( + str(expression) + ) + + if subexpressions is None: + return _ExpressionResult(result, False) + else: + return _ExpressionResult(subexpressions.add(result), False) def _render_existence_test(field, ir, subexpressions=None): - return _render_expression( - field.existence_condition, ir, subexpressions=subexpressions - ) + return _render_expression( + field.existence_condition, ir, subexpressions=subexpressions + ) def _alignment_of_location(location): - constraints = location.start.type.integer - if constraints.modulus == "infinity": - # The C++ templates use 0 as a sentinel value meaning infinity for - # alignment. - return 0, constraints.modular_value - else: - return constraints.modulus, constraints.modular_value + constraints = location.start.type.integer + if constraints.modulus == "infinity": + # The C++ templates use 0 as a sentinel value meaning infinity for + # alignment. + return 0, constraints.modular_value + else: + return constraints.modulus, constraints.modular_value def _get_cpp_type_reader_of_field( field_ir, ir, buffer_type, validator, parent_addressable_unit ): - """Returns the C++ view type for a field.""" - field_size = None - if field_ir.type.has_field("size_in_bits"): - field_size = ir_util.constant_value(field_ir.type.size_in_bits) - assert field_size is not None - elif ir_util.is_constant(field_ir.location.size): - # TODO(bolms): Normalize the IR so that this clause is unnecessary. - field_size = ( - ir_util.constant_value(field_ir.location.size) * parent_addressable_unit - ) - byte_order_attr = ir_util.get_attribute(field_ir.attribute, "byte_order") - if byte_order_attr: - byte_order = byte_order_attr.string_constant.text - else: - byte_order = "" - field_alignment, field_offset = _alignment_of_location(field_ir.location) - return _get_cpp_view_type_for_physical_type( - field_ir.type, - field_size, - byte_order, - ir, - _offset_storage_adapter(buffer_type, field_alignment, field_offset), - parent_addressable_unit, - validator, + """Returns the C++ view type for a field.""" + field_size = None + if field_ir.type.has_field("size_in_bits"): + field_size = ir_util.constant_value(field_ir.type.size_in_bits) + assert field_size is not None + elif ir_util.is_constant(field_ir.location.size): + # TODO(bolms): Normalize the IR so that this clause is unnecessary. + field_size = ( + ir_util.constant_value(field_ir.location.size) * parent_addressable_unit ) + byte_order_attr = ir_util.get_attribute(field_ir.attribute, "byte_order") + if byte_order_attr: + byte_order = byte_order_attr.string_constant.text + else: + byte_order = "" + field_alignment, field_offset = _alignment_of_location(field_ir.location) + return _get_cpp_view_type_for_physical_type( + field_ir.type, + field_size, + byte_order, + ir, + _offset_storage_adapter(buffer_type, field_alignment, field_offset), + parent_addressable_unit, + validator, + ) def _generate_structure_field_methods( enclosing_type_name, field_ir, ir, parent_addressable_unit ): - if ir_util.field_is_virtual(field_ir): - return _generate_structure_virtual_field_methods( - enclosing_type_name, field_ir, ir - ) - else: - return _generate_structure_physical_field_methods( - enclosing_type_name, field_ir, ir, parent_addressable_unit - ) + if ir_util.field_is_virtual(field_ir): + return _generate_structure_virtual_field_methods( + enclosing_type_name, field_ir, ir + ) + else: + return _generate_structure_physical_field_methods( + enclosing_type_name, field_ir, ir, parent_addressable_unit + ) def _generate_custom_validator_expression_for(field_ir, ir): - """Returns a validator expression for the given field, or None.""" - requires_attr = ir_util.get_attribute(field_ir.attribute, "requires") - if requires_attr: - - class _ValidatorFieldReader(object): - """A "FieldReader" that translates the current field to `value`.""" - - def render_existence(self, expression, subexpressions): - del expression # Unused. - assert False, "Shouldn't be here." - - def render_field(self, expression, ir, subexpressions): - assert len(expression.field_reference.path) == 1 - assert ( - expression.field_reference.path[0].canonical_name - == field_ir.name.canonical_name - ) - expression_cpp_type = _cpp_basic_type_for_expression(expression, ir) - return "{}(emboss_reserved_local_value)".format( - _maybe_type(expression_cpp_type) - ) - - validation_body = _render_expression( - requires_attr.expression, ir, _ValidatorFieldReader() - ) - return validation_body.rendered - else: - return None + """Returns a validator expression for the given field, or None.""" + requires_attr = ir_util.get_attribute(field_ir.attribute, "requires") + if requires_attr: + class _ValidatorFieldReader(object): + """A "FieldReader" that translates the current field to `value`.""" -def _generate_validator_expression_for(field_ir, ir): - """Returns a validator expression for the given field.""" - result = _generate_custom_validator_expression_for(field_ir, ir) - if result is None: - return "::emboss::support::Maybe(true)" - return result - - -def _generate_structure_virtual_field_methods(enclosing_type_name, field_ir, ir): - """Generates C++ code for methods for a single virtual field. - - Arguments: - enclosing_type_name: The text name of the enclosing type. - field_ir: The IR for the field to generate methods for. - ir: The full IR for the module. - - Returns: - A tuple of ("", declarations, definitions). The declarations can be - inserted into the class definition for the enclosing type's View. Any - definitions should be placed after the class definition. These are - separated to satisfy C++'s declaration-before-use requirements. - """ - if field_ir.write_method.which_method == "alias": - return _generate_field_indirection(field_ir, enclosing_type_name, ir) - - read_subexpressions = _SubexpressionStore("emboss_reserved_local_subexpr_") - read_value = _render_expression( - field_ir.read_transform, - ir, - field_reader=_VirtualViewFieldRenderer(), - subexpressions=read_subexpressions, - ) - field_exists = _render_existence_test(field_ir, ir) - logical_type = _cpp_basic_type_for_expression(field_ir.read_transform, ir) + def render_existence(self, expression, subexpressions): + del expression # Unused. + assert False, "Shouldn't be here." - if read_value.is_constant and field_exists.is_constant: - assert not read_subexpressions.subexprs() - declaration_template = ( - _TEMPLATES.structure_single_const_virtual_field_method_declarations - ) - definition_template = ( - _TEMPLATES.structure_single_const_virtual_field_method_definitions - ) - else: - declaration_template = ( - _TEMPLATES.structure_single_virtual_field_method_declarations - ) - definition_template = ( - _TEMPLATES.structure_single_virtual_field_method_definitions - ) - - if field_ir.write_method.which_method == "transform": - destination = _render_variable( - ir_util.hashable_form_of_field_reference( - field_ir.write_method.transform.destination - ) + def render_field(self, expression, ir, subexpressions): + assert len(expression.field_reference.path) == 1 + assert ( + expression.field_reference.path[0].canonical_name + == field_ir.name.canonical_name ) - transform = _render_expression( - field_ir.write_method.transform.function_body, - ir, - field_reader=_VirtualViewFieldRenderer(), - ).rendered - write_methods = code_template.format_template( - _TEMPLATES.structure_single_virtual_field_write_methods, - logical_type=logical_type, - destination=destination, - transform=transform, + expression_cpp_type = _cpp_basic_type_for_expression(expression, ir) + return "{}(emboss_reserved_local_value)".format( + _maybe_type(expression_cpp_type) ) - else: - write_methods = "" - name = field_ir.name.canonical_name.object_path[-1] - if name.startswith("$"): - name = _cpp_field_name(field_ir.name.name.text) - virtual_view_type_name = "EmbossReservedDollarVirtual{}View".format(name) - else: - virtual_view_type_name = "EmbossReservedVirtual{}View".format( - name_conversion.snake_to_camel(name) - ) - assert logical_type, "Could not find appropriate C++ type for {}".format( - field_ir.read_transform + validation_body = _render_expression( + requires_attr.expression, ir, _ValidatorFieldReader() ) - if field_ir.read_transform.type.which_type == "integer": - write_to_text_stream_function = "WriteIntegerViewToTextStream" - elif field_ir.read_transform.type.which_type == "boolean": - write_to_text_stream_function = "WriteBooleanViewToTextStream" - elif field_ir.read_transform.type.which_type == "enumeration": - write_to_text_stream_function = "WriteEnumViewToTextStream" - else: - assert False, "Unexpected read-only virtual field type {}".format( - field_ir.read_transform.type.which_type - ) + return validation_body.rendered + else: + return None - value_is_ok = _generate_validator_expression_for(field_ir, ir) - declaration = code_template.format_template( - declaration_template, - visibility=_visibility_for_field(field_ir), - name=name, - virtual_view_type_name=virtual_view_type_name, - logical_type=logical_type, - read_subexpressions="".join( - [ - " const auto {} = {};\n".format(subexpr_name, subexpr) - for subexpr_name, subexpr in read_subexpressions.subexprs() - ] - ), - read_value=read_value.rendered, - write_to_text_stream_function=write_to_text_stream_function, - parent_type=enclosing_type_name, - write_methods=write_methods, - value_is_ok=value_is_ok, - ) - definition = code_template.format_template( - definition_template, - name=name, - virtual_view_type_name=virtual_view_type_name, - logical_type=logical_type, - read_value=read_value.rendered, - parent_type=enclosing_type_name, - field_exists=field_exists.rendered, - ) - return "", declaration, definition +def _generate_validator_expression_for(field_ir, ir): + """Returns a validator expression for the given field.""" + result = _generate_custom_validator_expression_for(field_ir, ir) + if result is None: + return "::emboss::support::Maybe(true)" + return result -def _generate_validator_type_for(enclosing_type_name, field_ir, ir): - """Returns a validator type name and definition for the given field.""" - result_expression = _generate_custom_validator_expression_for(field_ir, ir) - if result_expression is None: - return "::emboss::support::AllValuesAreOk", "" - - field_name = field_ir.name.canonical_name.object_path[-1] - validator_type_name = "EmbossReservedValidatorFor{}".format( - name_conversion.snake_to_camel(field_name) - ) - qualified_validator_type_name = "{}::{}".format( - enclosing_type_name, validator_type_name - ) - validator_declaration = code_template.format_template( - _TEMPLATES.structure_field_validator, - name=validator_type_name, - expression=result_expression, +def _generate_structure_virtual_field_methods( + enclosing_type_name, field_ir, ir +): + """Generates C++ code for methods for a single virtual field. + + Arguments: + enclosing_type_name: The text name of the enclosing type. + field_ir: The IR for the field to generate methods for. + ir: The full IR for the module. + + Returns: + A tuple of ("", declarations, definitions). The declarations can be + inserted into the class definition for the enclosing type's View. Any + definitions should be placed after the class definition. These are + separated to satisfy C++'s declaration-before-use requirements. + """ + if field_ir.write_method.which_method == "alias": + return _generate_field_indirection(field_ir, enclosing_type_name, ir) + + read_subexpressions = _SubexpressionStore("emboss_reserved_local_subexpr_") + read_value = _render_expression( + field_ir.read_transform, + ir, + field_reader=_VirtualViewFieldRenderer(), + subexpressions=read_subexpressions, + ) + field_exists = _render_existence_test(field_ir, ir) + logical_type = _cpp_basic_type_for_expression(field_ir.read_transform, ir) + + if read_value.is_constant and field_exists.is_constant: + assert not read_subexpressions.subexprs() + declaration_template = ( + _TEMPLATES.structure_single_const_virtual_field_method_declarations ) - validator_declaration = _wrap_in_namespace( - validator_declaration, [enclosing_type_name] + definition_template = ( + _TEMPLATES.structure_single_const_virtual_field_method_definitions ) - return qualified_validator_type_name, validator_declaration - - -def _generate_structure_physical_field_methods( - enclosing_type_name, field_ir, ir, parent_addressable_unit -): - """Generates C++ code for methods for a single physical field. - - Arguments: - enclosing_type_name: The text name of the enclosing type. - field_ir: The IR for the field to generate methods for. - ir: The full IR for the module. - parent_addressable_unit: The addressable unit (BIT or BYTE) of the enclosing - structure. - - Returns: - A tuple of (declarations, definitions). The declarations can be inserted - into the class definition for the enclosing type's View. Any definitions - should be placed after the class definition. These are separated to satisfy - C++'s declaration-before-use requirements. - """ - validator_type, validator_declaration = _generate_validator_type_for( - enclosing_type_name, field_ir, ir + else: + declaration_template = ( + _TEMPLATES.structure_single_virtual_field_method_declarations ) - - type_reader, unused_parameter_types, parameter_expressions = ( - _get_cpp_type_reader_of_field( - field_ir, ir, "Storage", validator_type, parent_addressable_unit - ) + definition_template = ( + _TEMPLATES.structure_single_virtual_field_method_definitions ) - field_name = field_ir.name.canonical_name.object_path[-1] - - subexpressions = _SubexpressionStore("emboss_reserved_local_subexpr_") - parameter_values = [] - parameters_known = [] - for parameter in parameter_expressions: - parameter_cpp_expr = _render_expression( - parameter, ir, subexpressions=subexpressions + if field_ir.write_method.which_method == "transform": + destination = _render_variable( + ir_util.hashable_form_of_field_reference( + field_ir.write_method.transform.destination ) - parameter_values.append( - "{}.ValueOrDefault(), ".format(parameter_cpp_expr.rendered) - ) - parameters_known.append("{}.Known() && ".format(parameter_cpp_expr.rendered)) - parameter_subexpressions = "".join( - [ - " const auto {} = {};\n".format(name, subexpr) - for name, subexpr in subexpressions.subexprs() - ] ) - - first_size_and_offset_subexpr = len(subexpressions.subexprs()) - offset = _render_expression( - field_ir.location.start, ir, subexpressions=subexpressions - ).rendered - size = _render_expression( - field_ir.location.size, ir, subexpressions=subexpressions + transform = _render_expression( + field_ir.write_method.transform.function_body, + ir, + field_reader=_VirtualViewFieldRenderer(), ).rendered - size_and_offset_subexpressions = "".join( - [ - " const auto {} = {};\n".format(name, subexpr) - for name, subexpr in subexpressions.subexprs()[ - first_size_and_offset_subexpr: - ] - ] + write_methods = code_template.format_template( + _TEMPLATES.structure_single_virtual_field_write_methods, + logical_type=logical_type, + destination=destination, + transform=transform, + ) + else: + write_methods = "" + + name = field_ir.name.canonical_name.object_path[-1] + if name.startswith("$"): + name = _cpp_field_name(field_ir.name.name.text) + virtual_view_type_name = "EmbossReservedDollarVirtual{}View".format(name) + else: + virtual_view_type_name = "EmbossReservedVirtual{}View".format( + name_conversion.snake_to_camel(name) ) + assert logical_type, "Could not find appropriate C++ type for {}".format( + field_ir.read_transform + ) + if field_ir.read_transform.type.which_type == "integer": + write_to_text_stream_function = "WriteIntegerViewToTextStream" + elif field_ir.read_transform.type.which_type == "boolean": + write_to_text_stream_function = "WriteBooleanViewToTextStream" + elif field_ir.read_transform.type.which_type == "enumeration": + write_to_text_stream_function = "WriteEnumViewToTextStream" + else: + assert False, "Unexpected read-only virtual field type {}".format( + field_ir.read_transform.type.which_type + ) + + value_is_ok = _generate_validator_expression_for(field_ir, ir) + declaration = code_template.format_template( + declaration_template, + visibility=_visibility_for_field(field_ir), + name=name, + virtual_view_type_name=virtual_view_type_name, + logical_type=logical_type, + read_subexpressions="".join([ + " const auto {} = {};\n".format(subexpr_name, subexpr) + for subexpr_name, subexpr in read_subexpressions.subexprs() + ]), + read_value=read_value.rendered, + write_to_text_stream_function=write_to_text_stream_function, + parent_type=enclosing_type_name, + write_methods=write_methods, + value_is_ok=value_is_ok, + ) + definition = code_template.format_template( + definition_template, + name=name, + virtual_view_type_name=virtual_view_type_name, + logical_type=logical_type, + read_value=read_value.rendered, + parent_type=enclosing_type_name, + field_exists=field_exists.rendered, + ) + return "", declaration, definition - field_alignment, field_offset = _alignment_of_location(field_ir.location) - declaration = code_template.format_template( - _TEMPLATES.structure_single_field_method_declarations, - type_reader=type_reader, - visibility=_visibility_for_field(field_ir), - name=field_name, + +def _generate_validator_type_for(enclosing_type_name, field_ir, ir): + """Returns a validator type name and definition for the given field.""" + result_expression = _generate_custom_validator_expression_for(field_ir, ir) + if result_expression is None: + return "::emboss::support::AllValuesAreOk", "" + + field_name = field_ir.name.canonical_name.object_path[-1] + validator_type_name = "EmbossReservedValidatorFor{}".format( + name_conversion.snake_to_camel(field_name) + ) + qualified_validator_type_name = "{}::{}".format( + enclosing_type_name, validator_type_name + ) + + validator_declaration = code_template.format_template( + _TEMPLATES.structure_field_validator, + name=validator_type_name, + expression=result_expression, + ) + validator_declaration = _wrap_in_namespace( + validator_declaration, [enclosing_type_name] + ) + return qualified_validator_type_name, validator_declaration + + +def _generate_structure_physical_field_methods( + enclosing_type_name, field_ir, ir, parent_addressable_unit +): + """Generates C++ code for methods for a single physical field. + + Arguments: + enclosing_type_name: The text name of the enclosing type. + field_ir: The IR for the field to generate methods for. + ir: The full IR for the module. + parent_addressable_unit: The addressable unit (BIT or BYTE) of the enclosing + structure. + + Returns: + A tuple of (declarations, definitions). The declarations can be inserted + into the class definition for the enclosing type's View. Any definitions + should be placed after the class definition. These are separated to satisfy + C++'s declaration-before-use requirements. + """ + validator_type, validator_declaration = _generate_validator_type_for( + enclosing_type_name, field_ir, ir + ) + + type_reader, unused_parameter_types, parameter_expressions = ( + _get_cpp_type_reader_of_field( + field_ir, ir, "Storage", validator_type, parent_addressable_unit + ) + ) + + field_name = field_ir.name.canonical_name.object_path[-1] + + subexpressions = _SubexpressionStore("emboss_reserved_local_subexpr_") + parameter_values = [] + parameters_known = [] + for parameter in parameter_expressions: + parameter_cpp_expr = _render_expression( + parameter, ir, subexpressions=subexpressions + ) + parameter_values.append( + "{}.ValueOrDefault(), ".format(parameter_cpp_expr.rendered) ) - definition = code_template.format_template( - _TEMPLATES.structure_single_field_method_definitions, - parent_type=enclosing_type_name, - name=field_name, - type_reader=type_reader, - offset=offset, - size=size, - size_and_offset_subexpressions=size_and_offset_subexpressions, - field_exists=_render_existence_test(field_ir, ir).rendered, - alignment=field_alignment, - parameters_known="".join(parameters_known), - parameter_values="".join(parameter_values), - parameter_subexpressions=parameter_subexpressions, - static_offset=field_offset, + parameters_known.append( + "{}.Known() && ".format(parameter_cpp_expr.rendered) ) - return validator_declaration, declaration, definition + parameter_subexpressions = "".join([ + " const auto {} = {};\n".format(name, subexpr) + for name, subexpr in subexpressions.subexprs() + ]) + + first_size_and_offset_subexpr = len(subexpressions.subexprs()) + offset = _render_expression( + field_ir.location.start, ir, subexpressions=subexpressions + ).rendered + size = _render_expression( + field_ir.location.size, ir, subexpressions=subexpressions + ).rendered + size_and_offset_subexpressions = "".join([ + " const auto {} = {};\n".format(name, subexpr) + for name, subexpr in subexpressions.subexprs()[ + first_size_and_offset_subexpr: + ] + ]) + + field_alignment, field_offset = _alignment_of_location(field_ir.location) + declaration = code_template.format_template( + _TEMPLATES.structure_single_field_method_declarations, + type_reader=type_reader, + visibility=_visibility_for_field(field_ir), + name=field_name, + ) + definition = code_template.format_template( + _TEMPLATES.structure_single_field_method_definitions, + parent_type=enclosing_type_name, + name=field_name, + type_reader=type_reader, + offset=offset, + size=size, + size_and_offset_subexpressions=size_and_offset_subexpressions, + field_exists=_render_existence_test(field_ir, ir).rendered, + alignment=field_alignment, + parameters_known="".join(parameters_known), + parameter_values="".join(parameter_values), + parameter_subexpressions=parameter_subexpressions, + static_offset=field_offset, + ) + return validator_declaration, declaration, definition def _render_size_method(fields, ir): - """Renders the Size methods of a struct or bits, using the correct templates. - - Arguments: - fields: The list of fields in the struct or bits. This is used to find the - $size_in_bits or $size_in_bytes virtual field. - ir: The IR to which fields belong. - - Returns: - A string representation of the Size methods, suitable for inclusion in an - Emboss View class. - """ - # The SizeInBytes(), SizeInBits(), and SizeIsKnown() methods just forward to - # the generated IntrinsicSizeIn$_units_$() method, which returns a virtual - # field with Read() and Ok() methods. - # - # TODO(bolms): Remove these shims, rename IntrinsicSizeIn$_units_$ to - # SizeIn$_units_$, and update all callers to the new API. - for field in fields: - if field.name.name.text in ("$size_in_bits", "$size_in_bytes"): - # If the read_transform and existence_condition are constant, then the - # size is constexpr. - if ( - _render_expression(field.read_transform, ir).is_constant - and _render_expression(field.existence_condition, ir).is_constant - ): - template = _TEMPLATES.constant_structure_size_method - else: - template = _TEMPLATES.runtime_structure_size_method - return code_template.format_template( - template, - units="Bits" if field.name.name.text == "$size_in_bits" else "Bytes", - ) - assert False, "Expected a $size_in_bits or $size_in_bytes field." + """Renders the Size methods of a struct or bits, using the correct templates. + + Arguments: + fields: The list of fields in the struct or bits. This is used to find the + $size_in_bits or $size_in_bytes virtual field. + ir: The IR to which fields belong. + + Returns: + A string representation of the Size methods, suitable for inclusion in an + Emboss View class. + """ + # The SizeInBytes(), SizeInBits(), and SizeIsKnown() methods just forward to + # the generated IntrinsicSizeIn$_units_$() method, which returns a virtual + # field with Read() and Ok() methods. + # + # TODO(bolms): Remove these shims, rename IntrinsicSizeIn$_units_$ to + # SizeIn$_units_$, and update all callers to the new API. + for field in fields: + if field.name.name.text in ("$size_in_bits", "$size_in_bytes"): + # If the read_transform and existence_condition are constant, then the + # size is constexpr. + if ( + _render_expression(field.read_transform, ir).is_constant + and _render_expression(field.existence_condition, ir).is_constant + ): + template = _TEMPLATES.constant_structure_size_method + else: + template = _TEMPLATES.runtime_structure_size_method + return code_template.format_template( + template, + units="Bits" if field.name.name.text == "$size_in_bits" else "Bytes", + ) + assert False, "Expected a $size_in_bits or $size_in_bytes field." def _visibility_for_field(field_ir): - """Returns the C++ visibility for field_ir within its parent view.""" - # Generally, the Google style guide for hand-written C++ forbids having - # multiple public: and private: sections, but trying to conform to that bit of - # the style guide would make this file significantly more complex. - # - # Alias fields are generated as simple methods that forward directly to the - # aliased field's method: - # - # auto alias() const -> decltype(parent().child().aliased_subchild()) { - # return parent().child().aliased_subchild(); - # } - # - # Figuring out the return type of `parent().child().aliased_subchild()` is - # quite complex, since there are several levels of template indirection - # involved. It is much easier to just leave it up to the C++ compiler. - # - # Unfortunately, the C++ compiler will complain if `parent()` is not declared - # before `alias()`. If the `parent` field happens to be anonymous, the Google - # style guide would put `parent()`'s declaration after `alias()`'s - # declaration, which causes the C++ compiler to complain that `parent` is - # unknown. - # - # The easy fix to this is just to declare `parent()` before `alias()`, and - # explicitly mark `parent()` as `private` and `alias()` as `public`. - # - # Perhaps surprisingly, this limitation does not apply when `parent()`'s type - # is not yet complete at the point where `alias()` is declared; I believe this - # is because both `parent()` and `alias()` exist in a templated `class`, and - # by the time `parent().child().aliased_subchild()` is actually resolved, the - # compiler is instantiating the class and has the full definitions of all the - # other classes available. - if field_ir.name.is_anonymous: - return "private" - else: - return "public" + """Returns the C++ visibility for field_ir within its parent view.""" + # Generally, the Google style guide for hand-written C++ forbids having + # multiple public: and private: sections, but trying to conform to that bit of + # the style guide would make this file significantly more complex. + # + # Alias fields are generated as simple methods that forward directly to the + # aliased field's method: + # + # auto alias() const -> decltype(parent().child().aliased_subchild()) { + # return parent().child().aliased_subchild(); + # } + # + # Figuring out the return type of `parent().child().aliased_subchild()` is + # quite complex, since there are several levels of template indirection + # involved. It is much easier to just leave it up to the C++ compiler. + # + # Unfortunately, the C++ compiler will complain if `parent()` is not declared + # before `alias()`. If the `parent` field happens to be anonymous, the Google + # style guide would put `parent()`'s declaration after `alias()`'s + # declaration, which causes the C++ compiler to complain that `parent` is + # unknown. + # + # The easy fix to this is just to declare `parent()` before `alias()`, and + # explicitly mark `parent()` as `private` and `alias()` as `public`. + # + # Perhaps surprisingly, this limitation does not apply when `parent()`'s type + # is not yet complete at the point where `alias()` is declared; I believe this + # is because both `parent()` and `alias()` exist in a templated `class`, and + # by the time `parent().child().aliased_subchild()` is actually resolved, the + # compiler is instantiating the class and has the full definitions of all the + # other classes available. + if field_ir.name.is_anonymous: + return "private" + else: + return "public" def _generate_field_indirection(field_ir, parent_type_name, ir): - """Renders a method which forwards to a field's view.""" - rendered_aliased_field = _render_variable( - ir_util.hashable_form_of_field_reference(field_ir.write_method.alias) - ) - declaration = code_template.format_template( - _TEMPLATES.structure_single_field_indirect_method_declarations, - aliased_field=rendered_aliased_field, - visibility=_visibility_for_field(field_ir), - parent_type=parent_type_name, - name=field_ir.name.name.text, - ) - definition = code_template.format_template( - _TEMPLATES.struct_single_field_indirect_method_definitions, - parent_type=parent_type_name, - name=field_ir.name.name.text, - aliased_field=rendered_aliased_field, - field_exists=_render_existence_test(field_ir, ir).rendered, - ) - return "", declaration, definition + """Renders a method which forwards to a field's view.""" + rendered_aliased_field = _render_variable( + ir_util.hashable_form_of_field_reference(field_ir.write_method.alias) + ) + declaration = code_template.format_template( + _TEMPLATES.structure_single_field_indirect_method_declarations, + aliased_field=rendered_aliased_field, + visibility=_visibility_for_field(field_ir), + parent_type=parent_type_name, + name=field_ir.name.name.text, + ) + definition = code_template.format_template( + _TEMPLATES.struct_single_field_indirect_method_definitions, + parent_type=parent_type_name, + name=field_ir.name.name.text, + aliased_field=rendered_aliased_field, + field_exists=_render_existence_test(field_ir, ir).rendered, + ) + return "", declaration, definition def _generate_subtype_definitions(type_ir, ir, config: Config): - """Generates C++ code for subtypes of type_ir.""" - subtype_bodies = [] - subtype_forward_declarations = [] - subtype_method_definitions = [] - type_name = type_ir.name.name.text - for subtype in type_ir.subtype: - inner_defs = _generate_type_definition(subtype, ir, config) - subtype_forward_declaration, subtype_body, subtype_methods = inner_defs - subtype_forward_declarations.append(subtype_forward_declaration) - subtype_bodies.append(subtype_body) - subtype_method_definitions.append(subtype_methods) - wrapped_forward_declarations = _wrap_in_namespace( - "\n".join(subtype_forward_declarations), [type_name] - ) - wrapped_bodies = _wrap_in_namespace("\n".join(subtype_bodies), [type_name]) - wrapped_method_definitions = _wrap_in_namespace( - "\n".join(subtype_method_definitions), [type_name] - ) - return (wrapped_bodies, wrapped_forward_declarations, wrapped_method_definitions) + """Generates C++ code for subtypes of type_ir.""" + subtype_bodies = [] + subtype_forward_declarations = [] + subtype_method_definitions = [] + type_name = type_ir.name.name.text + for subtype in type_ir.subtype: + inner_defs = _generate_type_definition(subtype, ir, config) + subtype_forward_declaration, subtype_body, subtype_methods = inner_defs + subtype_forward_declarations.append(subtype_forward_declaration) + subtype_bodies.append(subtype_body) + subtype_method_definitions.append(subtype_methods) + wrapped_forward_declarations = _wrap_in_namespace( + "\n".join(subtype_forward_declarations), [type_name] + ) + wrapped_bodies = _wrap_in_namespace("\n".join(subtype_bodies), [type_name]) + wrapped_method_definitions = _wrap_in_namespace( + "\n".join(subtype_method_definitions), [type_name] + ) + return ( + wrapped_bodies, + wrapped_forward_declarations, + wrapped_method_definitions, + ) def _cpp_field_name(name): - """Returns the C++ name for the given field name.""" - if name.startswith("$"): - dollar_field_names = { - "$size_in_bits": "IntrinsicSizeInBits", - "$size_in_bytes": "IntrinsicSizeInBytes", - "$max_size_in_bits": "MaxSizeInBits", - "$min_size_in_bits": "MinSizeInBits", - "$max_size_in_bytes": "MaxSizeInBytes", - "$min_size_in_bytes": "MinSizeInBytes", - } - return dollar_field_names[name] - else: - return name + """Returns the C++ name for the given field name.""" + if name.startswith("$"): + dollar_field_names = { + "$size_in_bits": "IntrinsicSizeInBits", + "$size_in_bytes": "IntrinsicSizeInBytes", + "$max_size_in_bits": "MaxSizeInBits", + "$min_size_in_bits": "MinSizeInBits", + "$max_size_in_bytes": "MaxSizeInBytes", + "$min_size_in_bytes": "MinSizeInBytes", + } + return dollar_field_names[name] + else: + return name def _generate_structure_definition(type_ir, ir, config: Config): - """Generates C++ for an Emboss structure (struct or bits). - - Arguments: - type_ir: The IR for the struct definition. - ir: The full IR; used for type lookups. - config: The code generation configuration to use. - - Returns: - A tuple of: (forward declaration for classes, class bodies, method - bodies), suitable for insertion into the appropriate places in the - generated header. - """ - subtype_bodies, subtype_forward_declarations, subtype_method_definitions = ( - _generate_subtype_definitions(type_ir, ir, config) + """Generates C++ for an Emboss structure (struct or bits). + + Arguments: + type_ir: The IR for the struct definition. + ir: The full IR; used for type lookups. + config: The code generation configuration to use. + + Returns: + A tuple of: (forward declaration for classes, class bodies, method + bodies), suitable for insertion into the appropriate places in the + generated header. + """ + subtype_bodies, subtype_forward_declarations, subtype_method_definitions = ( + _generate_subtype_definitions(type_ir, ir, config) + ) + type_name = type_ir.name.name.text + field_helper_type_definitions = [] + field_method_declarations = [] + field_method_definitions = [] + virtual_field_type_definitions = [] + decode_field_clauses = [] + write_field_clauses = [] + ok_method_clauses = [] + equals_method_clauses = [] + unchecked_equals_method_clauses = [] + enum_using_statements = [] + parameter_fields = [] + constructor_parameters = [] + forwarded_parameters = [] + parameter_initializers = [] + parameter_copy_initializers = [] + units = {1: "Bits", 8: "Bytes"}[type_ir.addressable_unit] + + for subtype in type_ir.subtype: + if subtype.has_field("enumeration"): + enum_using_statements.append( + code_template.format_template( + _TEMPLATES.enum_using_statement, + component=_get_fully_qualified_name( + subtype.name.canonical_name, ir + ), + name=_get_unqualified_name(subtype.name.canonical_name), + ) + ) + + # TODO(bolms): Reorder parameter fields to optimize packing in the view type. + for parameter in type_ir.runtime_parameter: + parameter_type = _cpp_basic_type_for_expression_type(parameter.type, ir) + parameter_name = parameter.name.name.text + parameter_fields.append("{} {}_;".format(parameter_type, parameter_name)) + constructor_parameters.append( + "{} {}, ".format(parameter_type, parameter_name) + ) + forwarded_parameters.append( + "::std::forward({}),".format(parameter_type, parameter_name) + ) + parameter_initializers.append(", {0}_({0})".format(parameter_name)) + parameter_copy_initializers.append( + ", {0}_(emboss_reserved_local_other.{0}_)".format(parameter_name) ) - type_name = type_ir.name.name.text - field_helper_type_definitions = [] - field_method_declarations = [] - field_method_definitions = [] - virtual_field_type_definitions = [] - decode_field_clauses = [] - write_field_clauses = [] - ok_method_clauses = [] - equals_method_clauses = [] - unchecked_equals_method_clauses = [] - enum_using_statements = [] - parameter_fields = [] - constructor_parameters = [] - forwarded_parameters = [] - parameter_initializers = [] - parameter_copy_initializers = [] - units = {1: "Bits", 8: "Bytes"}[type_ir.addressable_unit] - - for subtype in type_ir.subtype: - if subtype.has_field("enumeration"): - enum_using_statements.append( - code_template.format_template( - _TEMPLATES.enum_using_statement, - component=_get_fully_qualified_name( - subtype.name.canonical_name, ir - ), - name=_get_unqualified_name(subtype.name.canonical_name), - ) - ) - - # TODO(bolms): Reorder parameter fields to optimize packing in the view type. - for parameter in type_ir.runtime_parameter: - parameter_type = _cpp_basic_type_for_expression_type(parameter.type, ir) - parameter_name = parameter.name.name.text - parameter_fields.append("{} {}_;".format(parameter_type, parameter_name)) - constructor_parameters.append("{} {}, ".format(parameter_type, parameter_name)) - forwarded_parameters.append( - "::std::forward({}),".format(parameter_type, parameter_name) - ) - parameter_initializers.append(", {0}_({0})".format(parameter_name)) - parameter_copy_initializers.append( - ", {0}_(emboss_reserved_local_other.{0}_)".format(parameter_name) - ) - field_method_declarations.append( - code_template.format_template( - _TEMPLATES.structure_single_parameter_field_method_declarations, - name=parameter_name, - logical_type=parameter_type, - ) - ) - # TODO(bolms): Should parameters appear in text format? - equals_method_clauses.append( - code_template.format_template( - _TEMPLATES.equals_method_test, field=parameter_name + "()" - ) - ) - unchecked_equals_method_clauses.append( - code_template.format_template( - _TEMPLATES.unchecked_equals_method_test, field=parameter_name + "()" - ) - ) - if type_ir.runtime_parameter: - flag_name = "parameters_initialized_" - parameter_copy_initializers.append( - ", {0}(emboss_reserved_local_other.{0})".format(flag_name) + field_method_declarations.append( + code_template.format_template( + _TEMPLATES.structure_single_parameter_field_method_declarations, + name=parameter_name, + logical_type=parameter_type, ) - parameters_initialized_flag = "bool {} = false;".format(flag_name) - initialize_parameters_initialized_true = ", {}(true)".format(flag_name) - parameter_checks = ["if (!{}) return false;".format(flag_name)] - else: - parameters_initialized_flag = "" - initialize_parameters_initialized_true = "" - parameter_checks = [""] - - # Pass 1: Count subexpression usage. - ok_usage_counter = _UsageCountingStore() - for field_index in type_ir.structure.fields_in_dependency_order: - field = type_ir.structure.field[field_index] - _render_existence_test(field, ir, ok_usage_counter) - - # Pass 2: Generate code using smart store. - ok_subexpressions = _SmartSubexpressionStore( - "emboss_reserved_local_ok_subexpr_", ok_usage_counter.counts ) - for field_index in type_ir.structure.fields_in_dependency_order: - field = type_ir.structure.field[field_index] - helper_types, declaration, definition = _generate_structure_field_methods( - type_name, field, ir, type_ir.addressable_unit - ) - field_helper_type_definitions.append(helper_types) - field_method_definitions.append(definition) - ok_method_clauses.append( - code_template.format_template( - _TEMPLATES.ok_method_test, - field=_cpp_field_name(field.name.name.text) + "()", - existence_condition=_render_existence_test( - field, ir, subexpressions=ok_subexpressions - ).rendered, - ) + # TODO(bolms): Should parameters appear in text format? + equals_method_clauses.append( + code_template.format_template( + _TEMPLATES.equals_method_test, field=parameter_name + "()" ) - if not ir_util.field_is_virtual(field): - # Virtual fields do not participate in equality tests -- they are equal by - # definition. - equals_method_clauses.append( - code_template.format_template( - _TEMPLATES.equals_method_test, field=field.name.name.text + "()" - ) - ) - unchecked_equals_method_clauses.append( - code_template.format_template( - _TEMPLATES.unchecked_equals_method_test, - field=field.name.name.text + "()", - ) - ) - field_method_declarations.append(declaration) - if not field.name.is_anonymous and not ir_util.field_is_read_only(field): - # As above, read-only fields cannot be decoded from text format. - decode_field_clauses.append( - code_template.format_template( - _TEMPLATES.decode_field, - field_name=field.name.canonical_name.object_path[-1], - ) - ) - text_output_attr = ir_util.get_attribute(field.attribute, "text_output") - if not text_output_attr or text_output_attr.string_constant == "Emit": - if ir_util.field_is_read_only(field): - write_field_template = _TEMPLATES.write_read_only_field_to_text_stream - else: - write_field_template = _TEMPLATES.write_field_to_text_stream - write_field_clauses.append( - code_template.format_template( - write_field_template, - field_name=field.name.canonical_name.object_path[-1], - ) - ) - - requires_attr = ir_util.get_attribute(type_ir.attribute, "requires") - if requires_attr is not None: - requires_clause = _render_expression( - requires_attr.expression, ir, _DirectFieldRenderer() - ).rendered - requires_check = ( - " if (!({}).ValueOr(false))\n" " return false;" - ).format(requires_clause) - else: - requires_check = "" - - if config.include_enum_traits: - text_stream_methods = code_template.format_template( - _TEMPLATES.struct_text_stream, - decode_fields="\n".join(decode_field_clauses), - write_fields="\n".join(write_field_clauses), + ) + unchecked_equals_method_clauses.append( + code_template.format_template( + _TEMPLATES.unchecked_equals_method_test, field=parameter_name + "()" ) - else: - text_stream_methods = "" - - class_forward_declarations = code_template.format_template( - _TEMPLATES.structure_view_declaration, name=type_name ) - class_bodies = code_template.format_template( - _TEMPLATES.structure_view_class, - name=type_ir.name.canonical_name.object_path[-1], - size_method=_render_size_method(type_ir.structure.field, ir), - field_method_declarations="".join(field_method_declarations), - field_ok_checks="\n".join(ok_method_clauses), - ok_subexpressions="".join( - [ - " const auto {} = {};\n".format(name, subexpr) - for name, subexpr in ok_subexpressions.subexprs() - ] - ), - parameter_ok_checks="\n".join(parameter_checks), - requires_check=requires_check, - equals_method_body="\n".join(equals_method_clauses), - unchecked_equals_method_body="\n".join(unchecked_equals_method_clauses), - enum_usings="\n".join(enum_using_statements), - text_stream_methods=text_stream_methods, - parameter_fields="\n".join(parameter_fields), - constructor_parameters="".join(constructor_parameters), - forwarded_parameters="".join(forwarded_parameters), - parameter_initializers="\n".join(parameter_initializers), - parameter_copy_initializers="\n".join(parameter_copy_initializers), - parameters_initialized_flag=parameters_initialized_flag, - initialize_parameters_initialized_true=(initialize_parameters_initialized_true), - units=units, + if type_ir.runtime_parameter: + flag_name = "parameters_initialized_" + parameter_copy_initializers.append( + ", {0}(emboss_reserved_local_other.{0})".format(flag_name) ) - method_definitions = "\n".join(field_method_definitions) - early_virtual_field_types = "\n".join(virtual_field_type_definitions) - all_field_helper_type_definitions = "\n".join(field_helper_type_definitions) - return ( - early_virtual_field_types - + subtype_forward_declarations - + class_forward_declarations, - all_field_helper_type_definitions + subtype_bodies + class_bodies, - subtype_method_definitions + method_definitions, + parameters_initialized_flag = "bool {} = false;".format(flag_name) + initialize_parameters_initialized_true = ", {}(true)".format(flag_name) + parameter_checks = ["if (!{}) return false;".format(flag_name)] + else: + parameters_initialized_flag = "" + initialize_parameters_initialized_true = "" + parameter_checks = [""] + + # Pass 1: Count subexpression usage. + ok_usage_counter = _UsageCountingStore() + for field_index in type_ir.structure.fields_in_dependency_order: + field = type_ir.structure.field[field_index] + _render_existence_test(field, ir, ok_usage_counter) + + # Pass 2: Generate code using smart store. + ok_subexpressions = _SmartSubexpressionStore( + "emboss_reserved_local_ok_subexpr_", ok_usage_counter.counts + ) + for field_index in type_ir.structure.fields_in_dependency_order: + field = type_ir.structure.field[field_index] + helper_types, declaration, definition = _generate_structure_field_methods( + type_name, field, ir, type_ir.addressable_unit ) + field_helper_type_definitions.append(helper_types) + field_method_definitions.append(definition) + ok_method_clauses.append( + code_template.format_template( + _TEMPLATES.ok_method_test, + field=_cpp_field_name(field.name.name.text) + "()", + existence_condition=_render_existence_test( + field, ir, subexpressions=ok_subexpressions + ).rendered, + ) + ) + if not ir_util.field_is_virtual(field): + # Virtual fields do not participate in equality tests -- they are equal by + # definition. + equals_method_clauses.append( + code_template.format_template( + _TEMPLATES.equals_method_test, field=field.name.name.text + "()" + ) + ) + unchecked_equals_method_clauses.append( + code_template.format_template( + _TEMPLATES.unchecked_equals_method_test, + field=field.name.name.text + "()", + ) + ) + field_method_declarations.append(declaration) + if not field.name.is_anonymous and not ir_util.field_is_read_only(field): + # As above, read-only fields cannot be decoded from text format. + decode_field_clauses.append( + code_template.format_template( + _TEMPLATES.decode_field, + field_name=field.name.canonical_name.object_path[-1], + ) + ) + text_output_attr = ir_util.get_attribute(field.attribute, "text_output") + if not text_output_attr or text_output_attr.string_constant == "Emit": + if ir_util.field_is_read_only(field): + write_field_template = _TEMPLATES.write_read_only_field_to_text_stream + else: + write_field_template = _TEMPLATES.write_field_to_text_stream + write_field_clauses.append( + code_template.format_template( + write_field_template, + field_name=field.name.canonical_name.object_path[-1], + ) + ) + + requires_attr = ir_util.get_attribute(type_ir.attribute, "requires") + if requires_attr is not None: + requires_clause = _render_expression( + requires_attr.expression, ir, _DirectFieldRenderer() + ).rendered + requires_check = ( + " if (!({}).ValueOr(false))\n return false;" + ).format(requires_clause) + else: + requires_check = "" + + if config.include_enum_traits: + text_stream_methods = code_template.format_template( + _TEMPLATES.struct_text_stream, + decode_fields="\n".join(decode_field_clauses), + write_fields="\n".join(write_field_clauses), + ) + else: + text_stream_methods = "" + + class_forward_declarations = code_template.format_template( + _TEMPLATES.structure_view_declaration, name=type_name + ) + class_bodies = code_template.format_template( + _TEMPLATES.structure_view_class, + name=type_ir.name.canonical_name.object_path[-1], + size_method=_render_size_method(type_ir.structure.field, ir), + field_method_declarations="".join(field_method_declarations), + field_ok_checks="\n".join(ok_method_clauses), + ok_subexpressions="".join([ + " const auto {} = {};\n".format(name, subexpr) + for name, subexpr in ok_subexpressions.subexprs() + ]), + parameter_ok_checks="\n".join(parameter_checks), + requires_check=requires_check, + equals_method_body="\n".join(equals_method_clauses), + unchecked_equals_method_body="\n".join(unchecked_equals_method_clauses), + enum_usings="\n".join(enum_using_statements), + text_stream_methods=text_stream_methods, + parameter_fields="\n".join(parameter_fields), + constructor_parameters="".join(constructor_parameters), + forwarded_parameters="".join(forwarded_parameters), + parameter_initializers="\n".join(parameter_initializers), + parameter_copy_initializers="\n".join(parameter_copy_initializers), + parameters_initialized_flag=parameters_initialized_flag, + initialize_parameters_initialized_true=( + initialize_parameters_initialized_true + ), + units=units, + ) + method_definitions = "\n".join(field_method_definitions) + early_virtual_field_types = "\n".join(virtual_field_type_definitions) + all_field_helper_type_definitions = "\n".join(field_helper_type_definitions) + return ( + early_virtual_field_types + + subtype_forward_declarations + + class_forward_declarations, + all_field_helper_type_definitions + subtype_bodies + class_bodies, + subtype_method_definitions + method_definitions, + ) def _split_enum_case_values_into_spans(enum_case_value): - """Yields spans containing each enum case in an enum_case attribute value. - - Arguments: - enum_case_value: the value of the `enum_case` attribute to be parsed. - - Returns: - An iterator over spans, where each span covers one enum case name. - Each span is a half-open range of the form [start, end), which is the - start and end position relative to the beginning of the enum_case_value - string. The name can be retrieved with `enum_case_value[start:end]`. - - To keep the grammar of this attribute simple, this only splits on - delimiters and trims whitespace for each case. - - Example: 'SHOUTY_CASE, kCamelCase' -> [(0, 11), (13, 23)]""" - # Scan the string from left to right, finding commas and trimming whitespace. - # This is essentially equivalent to (x.trim() fror x in str.split(',')) - # except that this yields spans within the string rather than the strings - # themselves, and no span is yielded for a trailing comma. - start, end = 0, len(enum_case_value) - while start <= end: - # Find a ',' delimiter to split on - delimiter = enum_case_value.find(",", start, end) - if delimiter < 0: - delimiter = end - - substr_start = start - substr_end = delimiter - - # Drop leading whitespace - while substr_start < substr_end and enum_case_value[substr_start].isspace(): - substr_start += 1 - # Drop trailing whitespace - while substr_start < substr_end and enum_case_value[substr_end - 1].isspace(): - substr_end -= 1 - - # Skip a trailing comma - if substr_start == end and start != 0: - break - - yield substr_start, substr_end - start = delimiter + 1 + """Yields spans containing each enum case in an enum_case attribute value. + + Arguments: + enum_case_value: the value of the `enum_case` attribute to be parsed. + + Returns: + An iterator over spans, where each span covers one enum case name. + Each span is a half-open range of the form [start, end), which is the + start and end position relative to the beginning of the enum_case_value + string. The name can be retrieved with `enum_case_value[start:end]`. + + To keep the grammar of this attribute simple, this only splits on + delimiters and trims whitespace for each case. + + Example: 'SHOUTY_CASE, kCamelCase' -> [(0, 11), (13, 23)] + """ + # Scan the string from left to right, finding commas and trimming whitespace. + # This is essentially equivalent to (x.trim() fror x in str.split(',')) + # except that this yields spans within the string rather than the strings + # themselves, and no span is yielded for a trailing comma. + start, end = 0, len(enum_case_value) + while start <= end: + # Find a ',' delimiter to split on + delimiter = enum_case_value.find(",", start, end) + if delimiter < 0: + delimiter = end + + substr_start = start + substr_end = delimiter + + # Drop leading whitespace + while substr_start < substr_end and enum_case_value[substr_start].isspace(): + substr_start += 1 + # Drop trailing whitespace + while ( + substr_start < substr_end and enum_case_value[substr_end - 1].isspace() + ): + substr_end -= 1 + + # Skip a trailing comma + if substr_start == end and start != 0: + break + + yield substr_start, substr_end + start = delimiter + 1 def _split_enum_case_values(enum_case_value): - """Returns all enum cases in an enum case value. + """Returns all enum cases in an enum case value. - Arguments: - enum_case_value: the value of the enum case attribute to parse. + Arguments: + enum_case_value: the value of the enum case attribute to parse. - Returns: - All enum case names from `enum_case_value`. + Returns: + All enum case names from `enum_case_value`. - Example: 'SHOUTY_CASE, kCamelCase' -> ['SHOUTY_CASE', 'kCamelCase']""" - return [ - enum_case_value[start:end] - for start, end in _split_enum_case_values_into_spans(enum_case_value) - ] + Example: 'SHOUTY_CASE, kCamelCase' -> ['SHOUTY_CASE', 'kCamelCase'] + """ + return [ + enum_case_value[start:end] + for start, end in _split_enum_case_values_into_spans(enum_case_value) + ] def _get_enum_value_names(enum_value): - """Determines one or more enum names based on attributes.""" - cases = ["SHOUTY_CASE"] - name = enum_value.name.name.text - if enum_case := ir_util.get_attribute( - enum_value.attribute, attributes.Attribute.ENUM_CASE - ): - cases = _split_enum_case_values(enum_case.string_constant.text) - return [name_conversion.convert_case("SHOUTY_CASE", case, name) for case in cases] + """Determines one or more enum names based on attributes.""" + cases = ["SHOUTY_CASE"] + name = enum_value.name.name.text + if enum_case := ir_util.get_attribute( + enum_value.attribute, attributes.Attribute.ENUM_CASE + ): + cases = _split_enum_case_values(enum_case.string_constant.text) + return [ + name_conversion.convert_case("SHOUTY_CASE", case, name) for case in cases + ] def _generate_enum_definition(type_ir, include_traits=True): - """Generates C++ for an Emboss enum.""" - enum_values = [] - enum_from_string_statements = [] - string_from_enum_statements = [] - enum_is_known_statements = [] - previously_seen_numeric_values = set() - max_bits = ir_util.get_integer_attribute(type_ir.attribute, "maximum_bits") - is_signed = ir_util.get_boolean_attribute(type_ir.attribute, "is_signed") - enum_type = _cpp_integer_type_for_enum(max_bits, is_signed) - for value in type_ir.enumeration.value: - numeric_value = ir_util.constant_value(value.value) - enum_value_names = _get_enum_value_names(value) - - for enum_value_name in enum_value_names: - enum_values.append( - code_template.format_template( - _TEMPLATES.enum_value, - name=enum_value_name, - value=_render_integer(numeric_value), - ) + """Generates C++ for an Emboss enum.""" + enum_values = [] + enum_from_string_statements = [] + string_from_enum_statements = [] + enum_is_known_statements = [] + previously_seen_numeric_values = set() + max_bits = ir_util.get_integer_attribute(type_ir.attribute, "maximum_bits") + is_signed = ir_util.get_boolean_attribute(type_ir.attribute, "is_signed") + enum_type = _cpp_integer_type_for_enum(max_bits, is_signed) + for value in type_ir.enumeration.value: + numeric_value = ir_util.constant_value(value.value) + enum_value_names = _get_enum_value_names(value) + + for enum_value_name in enum_value_names: + enum_values.append( + code_template.format_template( + _TEMPLATES.enum_value, + name=enum_value_name, + value=_render_integer(numeric_value), + ) + ) + if include_traits: + enum_from_string_statements.append( + code_template.format_template( + _TEMPLATES.enum_from_name_case, + enum=type_ir.name.name.text, + value=enum_value_name, + name=value.name.name.text, ) - if include_traits: - enum_from_string_statements.append( - code_template.format_template( - _TEMPLATES.enum_from_name_case, - enum=type_ir.name.name.text, - value=enum_value_name, - name=value.name.name.text, - ) - ) - - if numeric_value not in previously_seen_numeric_values: - string_from_enum_statements.append( - code_template.format_template( - _TEMPLATES.name_from_enum_case, - enum=type_ir.name.name.text, - value=enum_value_name, - name=value.name.name.text, - ) - ) - - enum_is_known_statements.append( - code_template.format_template( - _TEMPLATES.enum_is_known_case, - enum=type_ir.name.name.text, - name=enum_value_name, - ) - ) - previously_seen_numeric_values.add(numeric_value) - - declaration = code_template.format_template( - _TEMPLATES.enum_declaration, enum=type_ir.name.name.text, enum_type=enum_type - ) - definition = code_template.format_template( - _TEMPLATES.enum_definition, + ) + + if numeric_value not in previously_seen_numeric_values: + string_from_enum_statements.append( + code_template.format_template( + _TEMPLATES.name_from_enum_case, + enum=type_ir.name.name.text, + value=enum_value_name, + name=value.name.name.text, + ) + ) + + enum_is_known_statements.append( + code_template.format_template( + _TEMPLATES.enum_is_known_case, + enum=type_ir.name.name.text, + name=enum_value_name, + ) + ) + previously_seen_numeric_values.add(numeric_value) + + declaration = code_template.format_template( + _TEMPLATES.enum_declaration, + enum=type_ir.name.name.text, + enum_type=enum_type, + ) + definition = code_template.format_template( + _TEMPLATES.enum_definition, + enum=type_ir.name.name.text, + enum_type=enum_type, + enum_values="".join(enum_values), + ) + if include_traits: + definition += code_template.format_template( + _TEMPLATES.enum_traits, enum=type_ir.name.name.text, - enum_type=enum_type, - enum_values="".join(enum_values), + enum_from_name_cases="\n".join(enum_from_string_statements), + name_from_enum_cases="\n".join(string_from_enum_statements), + enum_is_known_cases="\n".join(enum_is_known_statements), ) - if include_traits: - definition += code_template.format_template( - _TEMPLATES.enum_traits, - enum=type_ir.name.name.text, - enum_from_name_cases="\n".join(enum_from_string_statements), - name_from_enum_cases="\n".join(string_from_enum_statements), - enum_is_known_cases="\n".join(enum_is_known_statements), - ) - return (declaration, definition, "") + return (declaration, definition, "") def _generate_type_definition(type_ir, ir, config: Config): - """Generates C++ for an Emboss type.""" - if type_ir.has_field("structure"): - return _generate_structure_definition(type_ir, ir, config) - elif type_ir.has_field("enumeration"): - return _generate_enum_definition(type_ir, config.include_enum_traits) - elif type_ir.has_field("external"): - # TODO(bolms): This should probably generate an #include. - return "", "", "" - else: - # TODO(bolms): provide error message instead of ICE - assert False, "Unknown type {}".format(type_ir) + """Generates C++ for an Emboss type.""" + if type_ir.has_field("structure"): + return _generate_structure_definition(type_ir, ir, config) + elif type_ir.has_field("enumeration"): + return _generate_enum_definition(type_ir, config.include_enum_traits) + elif type_ir.has_field("external"): + # TODO(bolms): This should probably generate an #include. + return "", "", "" + else: + # TODO(bolms): provide error message instead of ICE + assert False, "Unknown type {}".format(type_ir) def _generate_header_guard(file_path): - # TODO(bolms): Make this configurable. - header_path = file_path + ".h" - uppercased_path = header_path.upper() - no_punctuation_path = re.sub(r"[^A-Za-z0-9_]", "_", uppercased_path) - suffixed_path = no_punctuation_path + "_" - no_double_underscore_path = re.sub(r"__+", "_", suffixed_path) - return no_double_underscore_path + # TODO(bolms): Make this configurable. + header_path = file_path + ".h" + uppercased_path = header_path.upper() + no_punctuation_path = re.sub(r"[^A-Za-z0-9_]", "_", uppercased_path) + suffixed_path = no_punctuation_path + "_" + no_double_underscore_path = re.sub(r"__+", "_", suffixed_path) + return no_double_underscore_path def _add_missing_enum_case_attribute_on_enum_value(enum_value, defaults): - """Adds an `enum_case` attribute if there isn't one but a default is set.""" - if ( - ir_util.get_attribute(enum_value.attribute, attributes.Attribute.ENUM_CASE) - is None - ): - if attributes.Attribute.ENUM_CASE in defaults: - enum_value.attribute.extend([defaults[attributes.Attribute.ENUM_CASE]]) + """Adds an `enum_case` attribute if there isn't one but a default is set.""" + if ( + ir_util.get_attribute( + enum_value.attribute, attributes.Attribute.ENUM_CASE + ) + is None + ): + if attributes.Attribute.ENUM_CASE in defaults: + enum_value.attribute.extend([defaults[attributes.Attribute.ENUM_CASE]]) def _propagate_defaults(ir, targets, ancestors, add_fn): - """Propagates default values - - Traverses the IR to propagate default values to target nodes. - - Arguments: - ir: The IR to process. - targets: A list of target IR types to add attributes to. - ancestors: Ancestor types which may contain the default values. - add_fn: Function to add the attribute. May use any parameter available - in fast_traverse_ir_top_down actions as well as `defaults` - containing the - default attributes set by ancestors. - - Returns: - None - """ - traverse_ir.fast_traverse_ir_top_down( - ir, - targets, - add_fn, - incidental_actions={ - ancestor: attribute_util.gather_default_attributes for ancestor in ancestors - }, - parameters={"defaults": {}}, - ) + """Propagates default values + + Traverses the IR to propagate default values to target nodes. + + Arguments: + ir: The IR to process. + targets: A list of target IR types to add attributes to. + ancestors: Ancestor types which may contain the default values. + add_fn: Function to add the attribute. May use any parameter available in + fast_traverse_ir_top_down actions as well as `defaults` containing the + default attributes set by ancestors. + + Returns: + None + """ + traverse_ir.fast_traverse_ir_top_down( + ir, + targets, + add_fn, + incidental_actions={ + ancestor: attribute_util.gather_default_attributes + for ancestor in ancestors + }, + parameters={"defaults": {}}, + ) def _offset_source_location_column(source_location, offset): - """Adds offsets from the start column of the supplied source location. - - Arguments: - source_location: the initial source location - offset: a tuple of (start, end), which are the offsets relative to - source_location.start.column to set the new start.column and - end.column. - - Returns: - A new source location with all of the same properties as the provided - source location, but with the columns modified by offsets from the - original start column. - """ - - new_location = source_location._replace( - start=source_location.start._replace( - column=source_location.start.column + offset[0] - ), - end=source_location.start._replace( - column=source_location.start.column + offset[1] - ), - ) + """Adds offsets from the start column of the supplied source location. - return new_location + Arguments: + source_location: the initial source location + offset: a tuple of (start, end), which are the offsets relative to + source_location.start.column to set the new start.column and end.column. + + Returns: + A new source location with all of the same properties as the provided + source location, but with the columns modified by offsets from the + original start column. + """ + + new_location = source_location._replace( + start=source_location.start._replace( + column=source_location.start.column + offset[0] + ), + end=source_location.start._replace( + column=source_location.start.column + offset[1] + ), + ) + + return new_location def _verify_namespace_attribute(attr, source_file_name, errors): - if attr.name.text != attributes.Attribute.NAMESPACE: - return - namespace_value = ir_data_utils.reader(attr).value.string_constant - if not re.fullmatch(_NS_RE, namespace_value.text): - if re.fullmatch(_NS_EMPTY_RE, namespace_value.text): - errors.append( - [ - error.error( - source_file_name, - namespace_value.source_location, - "Empty namespace value is not allowed.", - ) - ] - ) - elif re.fullmatch(_NS_GLOBAL_RE, namespace_value.text): - errors.append( - [ - error.error( - source_file_name, - namespace_value.source_location, - "Global namespace is not allowed.", - ) - ] - ) - else: - errors.append( - [ - error.error( - source_file_name, - namespace_value.source_location, - 'Invalid namespace, must be a valid C++ namespace, such as "abc", ' - '"abc::def", or "::abc::def::ghi" (ISO/IEC 14882:2017 ' - "enclosing-namespace-specifier).", - ) - ] - ) - return - for word in _get_namespace_components(namespace_value.text): - if word in _CPP_RESERVED_WORDS: - errors.append( - [ - error.error( - source_file_name, - namespace_value.source_location, - f'Reserved word "{word}" is not allowed as a namespace component.', - ) - ] - ) + if attr.name.text != attributes.Attribute.NAMESPACE: + return + namespace_value = ir_data_utils.reader(attr).value.string_constant + if not re.fullmatch(_NS_RE, namespace_value.text): + if re.fullmatch(_NS_EMPTY_RE, namespace_value.text): + errors.append([ + error.error( + source_file_name, + namespace_value.source_location, + "Empty namespace value is not allowed.", + ) + ]) + elif re.fullmatch(_NS_GLOBAL_RE, namespace_value.text): + errors.append([ + error.error( + source_file_name, + namespace_value.source_location, + "Global namespace is not allowed.", + ) + ]) + else: + errors.append([ + error.error( + source_file_name, + namespace_value.source_location, + 'Invalid namespace, must be a valid C++ namespace, such as "abc",' + ' "abc::def", or "::abc::def::ghi" (ISO/IEC 14882:2017' + " enclosing-namespace-specifier).", + ) + ]) + return + for word in _get_namespace_components(namespace_value.text): + if word in _CPP_RESERVED_WORDS: + errors.append([ + error.error( + source_file_name, + namespace_value.source_location, + f'Reserved word "{word}" is not allowed as a namespace' + " component.", + ) + ]) _VALID_CASES = ", ".join(case for case in _SUPPORTED_ENUM_CASES) def _verify_enum_case_attribute(attr, source_file_name, errors): - """Verify that `enum_case` values are supported.""" - if attr.name.text != attributes.Attribute.ENUM_CASE: - return + """Verify that `enum_case` values are supported.""" + if attr.name.text != attributes.Attribute.ENUM_CASE: + return - enum_case_value = attr.value.string_constant - case_spans = _split_enum_case_values_into_spans(enum_case_value.text) - seen_cases = set() + enum_case_value = attr.value.string_constant + case_spans = _split_enum_case_values_into_spans(enum_case_value.text) + seen_cases = set() - for start, end in case_spans: - case_source_location = _offset_source_location_column( - enum_case_value.source_location, (start, end) - ) - case = enum_case_value.text[start:end] - - if start == end: - errors.append( - [ - error.error( - source_file_name, - case_source_location, - "Empty enum case (or excess comma).", - ) - ] - ) - continue - - if case in seen_cases: - errors.append( - [ - error.error( - source_file_name, - case_source_location, - f'Duplicate enum case "{case}".', - ) - ] - ) - continue - seen_cases.add(case) - - if case not in _SUPPORTED_ENUM_CASES: - errors.append( - [ - error.error( - source_file_name, - case_source_location, - f'Unsupported enum case "{case}", ' - f"supported cases are: {_VALID_CASES}.", - ) - ] - ) + for start, end in case_spans: + case_source_location = _offset_source_location_column( + enum_case_value.source_location, (start, end) + ) + case = enum_case_value.text[start:end] + + if start == end: + errors.append([ + error.error( + source_file_name, + case_source_location, + "Empty enum case (or excess comma).", + ) + ]) + continue + + if case in seen_cases: + errors.append([ + error.error( + source_file_name, + case_source_location, + f'Duplicate enum case "{case}".', + ) + ]) + continue + seen_cases.add(case) + + if case not in _SUPPORTED_ENUM_CASES: + errors.append([ + error.error( + source_file_name, + case_source_location, + f'Unsupported enum case "{case}", ' + f"supported cases are: {_VALID_CASES}.", + ) + ]) def _verify_attribute_values(ir): - """Verify backend attribute values.""" - errors = [] + """Verify backend attribute values.""" + errors = [] - traverse_ir.fast_traverse_ir_top_down( - ir, - [ir_data.Attribute], - _verify_namespace_attribute, - parameters={"errors": errors}, - ) - traverse_ir.fast_traverse_ir_top_down( - ir, - [ir_data.Attribute], - _verify_enum_case_attribute, - parameters={"errors": errors}, - ) + traverse_ir.fast_traverse_ir_top_down( + ir, + [ir_data.Attribute], + _verify_namespace_attribute, + parameters={"errors": errors}, + ) + traverse_ir.fast_traverse_ir_top_down( + ir, + [ir_data.Attribute], + _verify_enum_case_attribute, + parameters={"errors": errors}, + ) - return errors + return errors def _propagate_defaults_and_verify_attributes(ir): - """Verify attributes and ensure defaults are set when not overridden. - - Arguments: - ir: The IR to process. - - Returns: - A list of errors if there are errors present, or an empty list if - verification completed successfully.""" - if errors := attribute_util.check_attributes_in_ir( - ir, - back_end="cpp", - types=attributes.TYPES, - module_attributes=attributes.Scope.MODULE, - struct_attributes=attributes.Scope.STRUCT, - bits_attributes=attributes.Scope.BITS, - enum_attributes=attributes.Scope.ENUM, - enum_value_attributes=attributes.Scope.ENUM_VALUE, - ): - return errors + """Verify attributes and ensure defaults are set when not overridden. + + Arguments: + ir: The IR to process. + + Returns: + A list of errors if there are errors present, or an empty list if + verification completed successfully. + """ + if errors := attribute_util.check_attributes_in_ir( + ir, + back_end="cpp", + types=attributes.TYPES, + module_attributes=attributes.Scope.MODULE, + struct_attributes=attributes.Scope.STRUCT, + bits_attributes=attributes.Scope.BITS, + enum_attributes=attributes.Scope.ENUM, + enum_value_attributes=attributes.Scope.ENUM_VALUE, + ): + return errors - if errors := _verify_attribute_values(ir): - return errors + if errors := _verify_attribute_values(ir): + return errors - # Ensure defaults are set on EnumValues for `enum_case`. - _propagate_defaults( - ir, - targets=[ir_data.EnumValue], - ancestors=[ir_data.Module, ir_data.TypeDefinition], - add_fn=_add_missing_enum_case_attribute_on_enum_value, - ) + # Ensure defaults are set on EnumValues for `enum_case`. + _propagate_defaults( + ir, + targets=[ir_data.EnumValue], + ancestors=[ir_data.Module, ir_data.TypeDefinition], + add_fn=_add_missing_enum_case_attribute_on_enum_value, + ) - return [] + return [] def generate_header(ir, config=Config()): - """Generates a C++ header from an Emboss module. - - Arguments: - ir: An EmbossIr of the module. - - Returns: - A tuple of (header, errors), where `header` is either a string containing - the text of a C++ header which implements Views for the types in the Emboss - module, or None, and `errors` is a possibly-empty list of error messages to - display to the user. - """ - errors = _propagate_defaults_and_verify_attributes(ir) - if errors: - return None, errors - type_declarations = [] - type_definitions = [] - method_definitions = [] - for type_definition in ir.module[0].type: - declaration, definition, methods = _generate_type_definition( - type_definition, ir, config - ) - type_declarations.append(declaration) - type_definitions.append(definition) - method_definitions.append(methods) - body = code_template.format_template( - _TEMPLATES.body, - type_declarations="".join(type_declarations), - type_definitions="".join(type_definitions), - method_definitions="".join(method_definitions), - ) - body = _wrap_in_namespace(body, _get_module_namespace(ir.module[0])) - includes = _get_includes(ir.module[0], config) - return ( - code_template.format_template( - _TEMPLATES.outline, - includes=includes, - body=body, - header_guard=_generate_header_guard(ir.module[0].source_file_name), - ), - [], + """Generates a C++ header from an Emboss module. + + Arguments: + ir: An EmbossIr of the module. + + Returns: + A tuple of (header, errors), where `header` is either a string containing + the text of a C++ header which implements Views for the types in the Emboss + module, or None, and `errors` is a possibly-empty list of error messages to + display to the user. + """ + errors = _propagate_defaults_and_verify_attributes(ir) + if errors: + return None, errors + type_declarations = [] + type_definitions = [] + method_definitions = [] + for type_definition in ir.module[0].type: + declaration, definition, methods = _generate_type_definition( + type_definition, ir, config ) + type_declarations.append(declaration) + type_definitions.append(definition) + method_definitions.append(methods) + body = code_template.format_template( + _TEMPLATES.body, + type_declarations="".join(type_declarations), + type_definitions="".join(type_definitions), + method_definitions="".join(method_definitions), + ) + body = _wrap_in_namespace(body, _get_module_namespace(ir.module[0])) + includes = _get_includes(ir.module[0], config) + return ( + code_template.format_template( + _TEMPLATES.outline, + includes=includes, + body=body, + header_guard=_generate_header_guard(ir.module[0].source_file_name), + ), + [], + ) diff --git a/compiler/back_end/cpp/run_one_golden_test.py b/compiler/back_end/cpp/run_one_golden_test.py index 7e8b6fc..150b4d9 100644 --- a/compiler/back_end/cpp/run_one_golden_test.py +++ b/compiler/back_end/cpp/run_one_golden_test.py @@ -14,50 +14,51 @@ # See the License for the specific language governing permissions and # limitations under the License. -import unittest -import sys import os - -sys.path.insert(0, os.path.dirname(__file__)) +import sys +import unittest from one_golden_test import OneGoldenTest +sys.path.insert(0, os.path.dirname(__file__)) + def main(argv): - if len(argv) < 5: - print( - f"Usage: {argv[0]} emboss_front_end emboss_compiler emb_file golden_file [include_dir...]" - ) - return 1 - - emboss_front_end = argv[1] - emboss_compiler = argv[2] - emb_file = argv[3] - golden_file = argv[4] - - include_dirs = [] - compiler_flags = [] - for arg in argv[5:]: - if arg.startswith("--import-dir="): - include_dirs.append(arg[len("--import-dir="):]) - else: - compiler_flags.append(arg) - - suite = unittest.TestSuite() - suite.addTest( - OneGoldenTest( - emboss_front_end, - emboss_compiler, - emb_file, - golden_file, - include_dirs, - compiler_flags, - ) + if len(argv) < 5: + print( + f"Usage: {argv[0]} emboss_front_end emboss_compiler emb_file" + " golden_file [include_dir...]" ) - runner = unittest.TextTestRunner() - result = runner.run(suite) - return 0 if result.wasSuccessful() else 1 + return 1 + + emboss_front_end = argv[1] + emboss_compiler = argv[2] + emb_file = argv[3] + golden_file = argv[4] + + include_dirs = [] + compiler_flags = [] + for arg in argv[5:]: + if arg.startswith("--import-dir="): + include_dirs.append(arg[len("--import-dir=") :]) + else: + compiler_flags.append(arg) + + suite = unittest.TestSuite() + suite.addTest( + OneGoldenTest( + emboss_front_end, + emboss_compiler, + emb_file, + golden_file, + include_dirs, + compiler_flags, + ) + ) + runner = unittest.TextTestRunner() + result = runner.run(suite) + return 0 if result.wasSuccessful() else 1 if __name__ == "__main__": - sys.exit(main(sys.argv)) + sys.exit(main(sys.argv)) diff --git a/compiler/back_end/cpp/testcode/many_conditionals_benchmark.cc b/compiler/back_end/cpp/testcode/many_conditionals_benchmark.cc index 826e226..61a2f99 100644 --- a/compiler/back_end/cpp/testcode/many_conditionals_benchmark.cc +++ b/compiler/back_end/cpp/testcode/many_conditionals_benchmark.cc @@ -1,12 +1,14 @@ #include -#include "testdata/many_conditionals.emb.h" -#include + #include #include +#include + +#include "testdata/many_conditionals.emb.h" // A simple test that acts as a benchmark/sanity check. -// Since this file is in compiler/back_end/cpp/testcode/, it will be built as a cc_test. -// We can use GoogleTest macros. +// Since this file is in compiler/back_end/cpp/testcode/, it will be built as a +// cc_test. We can use GoogleTest macros. TEST(ComplexConditionals, PerformanceBenchmark) { std::vector buffer(100, 0); @@ -17,17 +19,19 @@ TEST(ComplexConditionals, PerformanceBenchmark) { volatile bool result = false; for (int i = 0; i < iterations; ++i) { for (int tag = 0; tag < 100; ++tag) { - view.tag().Write(tag); - result = view.Ok(); + view.tag().Write(tag); + result = view.Ok(); } } auto end = std::chrono::high_resolution_clock::now(); - + std::chrono::duration elapsed = end - start; // We don't strictly fail on time, but we print it. // In a real CI system we might assert upper bounds. - std::cout << "Time for " << iterations << " iterations (x100 tags): " << elapsed.count() << "s" << std::endl; - + std::cout << "Time for " << iterations + << " iterations (x100 tags): " << elapsed.count() << "s" + << std::endl; + EXPECT_TRUE(result); EXPECT_TRUE(view.Ok()); } diff --git a/testdata/BUILD b/testdata/BUILD index 7b27f25..8498fe5 100644 --- a/testdata/BUILD +++ b/testdata/BUILD @@ -36,11 +36,8 @@ filegroup( ], ) - - exports_files(glob(["**/*.emb"])) - filegroup( name = "test_embs", srcs = [ diff --git a/testdata/many_conditionals.emb b/testdata/many_conditionals.emb index e8d9e16..6efa7c6 100644 --- a/testdata/many_conditionals.emb +++ b/testdata/many_conditionals.emb @@ -1,205 +1,305 @@ [(cpp) namespace: "emboss::test"] [$default byte_order: "LittleEndian"] + struct LargeConditionals: - 0 [+4] UInt tag + 0 [+4] UInt tag if tag == 0: - 4 [+4] UInt f0 + 4 [+4] UInt f0 + if tag == 1: - 4 [+4] UInt f1 + 4 [+4] UInt f1 + if tag == 2: - 4 [+4] UInt f2 + 4 [+4] UInt f2 + if tag == 3: - 4 [+4] UInt f3 + 4 [+4] UInt f3 + if tag == 4: - 4 [+4] UInt f4 + 4 [+4] UInt f4 + if tag == 5: - 4 [+4] UInt f5 + 4 [+4] UInt f5 + if tag == 6: - 4 [+4] UInt f6 + 4 [+4] UInt f6 + if tag == 7: - 4 [+4] UInt f7 + 4 [+4] UInt f7 + if tag == 8: - 4 [+4] UInt f8 + 4 [+4] UInt f8 + if tag == 9: - 4 [+4] UInt f9 + 4 [+4] UInt f9 + if tag == 10: - 4 [+4] UInt f10 + 4 [+4] UInt f10 + if tag == 11: - 4 [+4] UInt f11 + 4 [+4] UInt f11 + if tag == 12: - 4 [+4] UInt f12 + 4 [+4] UInt f12 + if tag == 13: - 4 [+4] UInt f13 + 4 [+4] UInt f13 + if tag == 14: - 4 [+4] UInt f14 + 4 [+4] UInt f14 + if tag == 15: - 4 [+4] UInt f15 + 4 [+4] UInt f15 + if tag == 16: - 4 [+4] UInt f16 + 4 [+4] UInt f16 + if tag == 17: - 4 [+4] UInt f17 + 4 [+4] UInt f17 + if tag == 18: - 4 [+4] UInt f18 + 4 [+4] UInt f18 + if tag == 19: - 4 [+4] UInt f19 + 4 [+4] UInt f19 + if tag == 20: - 4 [+4] UInt f20 + 4 [+4] UInt f20 + if tag == 21: - 4 [+4] UInt f21 + 4 [+4] UInt f21 + if tag == 22: - 4 [+4] UInt f22 + 4 [+4] UInt f22 + if tag == 23: - 4 [+4] UInt f23 + 4 [+4] UInt f23 + if tag == 24: - 4 [+4] UInt f24 + 4 [+4] UInt f24 + if tag == 25: - 4 [+4] UInt f25 + 4 [+4] UInt f25 + if tag == 26: - 4 [+4] UInt f26 + 4 [+4] UInt f26 + if tag == 27: - 4 [+4] UInt f27 + 4 [+4] UInt f27 + if tag == 28: - 4 [+4] UInt f28 + 4 [+4] UInt f28 + if tag == 29: - 4 [+4] UInt f29 + 4 [+4] UInt f29 + if tag == 30: - 4 [+4] UInt f30 + 4 [+4] UInt f30 + if tag == 31: - 4 [+4] UInt f31 + 4 [+4] UInt f31 + if tag == 32: - 4 [+4] UInt f32 + 4 [+4] UInt f32 + if tag == 33: - 4 [+4] UInt f33 + 4 [+4] UInt f33 + if tag == 34: - 4 [+4] UInt f34 + 4 [+4] UInt f34 + if tag == 35: - 4 [+4] UInt f35 + 4 [+4] UInt f35 + if tag == 36: - 4 [+4] UInt f36 + 4 [+4] UInt f36 + if tag == 37: - 4 [+4] UInt f37 + 4 [+4] UInt f37 + if tag == 38: - 4 [+4] UInt f38 + 4 [+4] UInt f38 + if tag == 39: - 4 [+4] UInt f39 + 4 [+4] UInt f39 + if tag == 40: - 4 [+4] UInt f40 + 4 [+4] UInt f40 + if tag == 41: - 4 [+4] UInt f41 + 4 [+4] UInt f41 + if tag == 42: - 4 [+4] UInt f42 + 4 [+4] UInt f42 + if tag == 43: - 4 [+4] UInt f43 + 4 [+4] UInt f43 + if tag == 44: - 4 [+4] UInt f44 + 4 [+4] UInt f44 + if tag == 45: - 4 [+4] UInt f45 + 4 [+4] UInt f45 + if tag == 46: - 4 [+4] UInt f46 + 4 [+4] UInt f46 + if tag == 47: - 4 [+4] UInt f47 + 4 [+4] UInt f47 + if tag == 48: - 4 [+4] UInt f48 + 4 [+4] UInt f48 + if tag == 49: - 4 [+4] UInt f49 + 4 [+4] UInt f49 + if tag == 50: - 4 [+4] UInt f50 + 4 [+4] UInt f50 + if tag == 51: - 4 [+4] UInt f51 + 4 [+4] UInt f51 + if tag == 52: - 4 [+4] UInt f52 + 4 [+4] UInt f52 + if tag == 53: - 4 [+4] UInt f53 + 4 [+4] UInt f53 + if tag == 54: - 4 [+4] UInt f54 + 4 [+4] UInt f54 + if tag == 55: - 4 [+4] UInt f55 + 4 [+4] UInt f55 + if tag == 56: - 4 [+4] UInt f56 + 4 [+4] UInt f56 + if tag == 57: - 4 [+4] UInt f57 + 4 [+4] UInt f57 + if tag == 58: - 4 [+4] UInt f58 + 4 [+4] UInt f58 + if tag == 59: - 4 [+4] UInt f59 + 4 [+4] UInt f59 + if tag == 60: - 4 [+4] UInt f60 + 4 [+4] UInt f60 + if tag == 61: - 4 [+4] UInt f61 + 4 [+4] UInt f61 + if tag == 62: - 4 [+4] UInt f62 + 4 [+4] UInt f62 + if tag == 63: - 4 [+4] UInt f63 + 4 [+4] UInt f63 + if tag == 64: - 4 [+4] UInt f64 + 4 [+4] UInt f64 + if tag == 65: - 4 [+4] UInt f65 + 4 [+4] UInt f65 + if tag == 66: - 4 [+4] UInt f66 + 4 [+4] UInt f66 + if tag == 67: - 4 [+4] UInt f67 + 4 [+4] UInt f67 + if tag == 68: - 4 [+4] UInt f68 + 4 [+4] UInt f68 + if tag == 69: - 4 [+4] UInt f69 + 4 [+4] UInt f69 + if tag == 70: - 4 [+4] UInt f70 + 4 [+4] UInt f70 + if tag == 71: - 4 [+4] UInt f71 + 4 [+4] UInt f71 + if tag == 72: - 4 [+4] UInt f72 + 4 [+4] UInt f72 + if tag == 73: - 4 [+4] UInt f73 + 4 [+4] UInt f73 + if tag == 74: - 4 [+4] UInt f74 + 4 [+4] UInt f74 + if tag == 75: - 4 [+4] UInt f75 + 4 [+4] UInt f75 + if tag == 76: - 4 [+4] UInt f76 + 4 [+4] UInt f76 + if tag == 77: - 4 [+4] UInt f77 + 4 [+4] UInt f77 + if tag == 78: - 4 [+4] UInt f78 + 4 [+4] UInt f78 + if tag == 79: - 4 [+4] UInt f79 + 4 [+4] UInt f79 + if tag == 80: - 4 [+4] UInt f80 + 4 [+4] UInt f80 + if tag == 81: - 4 [+4] UInt f81 + 4 [+4] UInt f81 + if tag == 82: - 4 [+4] UInt f82 + 4 [+4] UInt f82 + if tag == 83: - 4 [+4] UInt f83 + 4 [+4] UInt f83 + if tag == 84: - 4 [+4] UInt f84 + 4 [+4] UInt f84 + if tag == 85: - 4 [+4] UInt f85 + 4 [+4] UInt f85 + if tag == 86: - 4 [+4] UInt f86 + 4 [+4] UInt f86 + if tag == 87: - 4 [+4] UInt f87 + 4 [+4] UInt f87 + if tag == 88: - 4 [+4] UInt f88 + 4 [+4] UInt f88 + if tag == 89: - 4 [+4] UInt f89 + 4 [+4] UInt f89 + if tag == 90: - 4 [+4] UInt f90 + 4 [+4] UInt f90 + if tag == 91: - 4 [+4] UInt f91 + 4 [+4] UInt f91 + if tag == 92: - 4 [+4] UInt f92 + 4 [+4] UInt f92 + if tag == 93: - 4 [+4] UInt f93 + 4 [+4] UInt f93 + if tag == 94: - 4 [+4] UInt f94 + 4 [+4] UInt f94 + if tag == 95: - 4 [+4] UInt f95 + 4 [+4] UInt f95 + if tag == 96: - 4 [+4] UInt f96 + 4 [+4] UInt f96 + if tag == 97: - 4 [+4] UInt f97 + 4 [+4] UInt f97 + if tag == 98: - 4 [+4] UInt f98 + 4 [+4] UInt f98 + if tag == 99: - 4 [+4] UInt f99 + 4 [+4] UInt f99 From 72544fce71a7c02ecdf433bc7932d4683a6de083 Mon Sep 17 00:00:00 2001 From: Aaron Webster Date: Tue, 25 Nov 2025 13:34:14 -0800 Subject: [PATCH 4/9] Revert: Reformat compiler/back_end/cpp/header_generator.py to original spacing --- compiler/back_end/cpp/header_generator.py | 3401 ++++++++++----------- 1 file changed, 1688 insertions(+), 1713 deletions(-) diff --git a/compiler/back_end/cpp/header_generator.py b/compiler/back_end/cpp/header_generator.py index 77087b9..30ba343 100644 --- a/compiler/back_end/cpp/header_generator.py +++ b/compiler/back_end/cpp/header_generator.py @@ -37,119 +37,121 @@ resources.load("compiler.back_end.cpp", "generated_code_templates") ) -_CPP_RESERVED_WORDS = set(( - # C keywords. A few of these are not (yet) C++ keywords, but some compilers - # accept the superset of C and C++, so we still want to avoid them. - "asm", - "auto", - "break", - "case", - "char", - "const", - "continue", - "default", - "do", - "double", - "else", - "enum", - "extern", - "float", - "for", - "fortran", - "goto", - "if", - "inline", - "int", - "long", - "register", - "restrict", - "return", - "short", - "signed", - "sizeof", - "static", - "struct", - "switch", - "typedef", - "union", - "unsigned", - "void", - "volatile", - "while", - "_Alignas", - "_Alignof", - "_Atomic", - "_Bool", - "_Complex", - "_Generic", - "_Imaginary", - "_Noreturn", - "_Pragma", - "_Static_assert", - "_Thread_local", - # The following are not technically reserved words, but collisions are - # likely due to the standard macros. - "complex", - "imaginary", - "noreturn", - # C++ keywords that are not also C keywords. - "alignas", - "alignof", - "and", - "and_eq", - "asm", - "bitand", - "bitor", - "bool", - "catch", - "char16_t", - "char32_t", - "class", - "compl", - "concept", - "constexpr", - "const_cast", - "decltype", - "delete", - "dynamic_cast", - "explicit", - "export", - "false", - "friend", - "mutable", - "namespace", - "new", - "noexcept", - "not", - "not_eq", - "nullptr", - "operator", - "or", - "or_eq", - "private", - "protected", - "public", - "reinterpret_cast", - "requires", - "static_assert", - "static_cast", - "template", - "this", - "thread_local", - "throw", - "true", - "try", - "typeid", - "typename", - "using", - "virtual", - "wchar_t", - "xor", - "xor_eq", - # "NULL" is not a keyword, but is still very likely to cause problems if - # used as a namespace name. - "NULL", -)) +_CPP_RESERVED_WORDS = set( + ( + # C keywords. A few of these are not (yet) C++ keywords, but some compilers + # accept the superset of C and C++, so we still want to avoid them. + "asm", + "auto", + "break", + "case", + "char", + "const", + "continue", + "default", + "do", + "double", + "else", + "enum", + "extern", + "float", + "for", + "fortran", + "goto", + "if", + "inline", + "int", + "long", + "register", + "restrict", + "return", + "short", + "signed", + "sizeof", + "static", + "struct", + "switch", + "typedef", + "union", + "unsigned", + "void", + "volatile", + "while", + "_Alignas", + "_Alignof", + "_Atomic", + "_Bool", + "_Complex", + "_Generic", + "_Imaginary", + "_Noreturn", + "_Pragma", + "_Static_assert", + "_Thread_local", + # The following are not technically reserved words, but collisions are + # likely due to the standard macros. + "complex", + "imaginary", + "noreturn", + # C++ keywords that are not also C keywords. + "alignas", + "alignof", + "and", + "and_eq", + "asm", + "bitand", + "bitor", + "bool", + "catch", + "char16_t", + "char32_t", + "class", + "compl", + "concept", + "constexpr", + "const_cast", + "decltype", + "delete", + "dynamic_cast", + "explicit", + "export", + "false", + "friend", + "mutable", + "namespace", + "new", + "noexcept", + "not", + "not_eq", + "nullptr", + "operator", + "or", + "or_eq", + "private", + "protected", + "public", + "reinterpret_cast", + "requires", + "static_assert", + "static_cast", + "template", + "this", + "thread_local", + "throw", + "true", + "try", + "typeid", + "typename", + "using", + "virtual", + "wchar_t", + "xor", + "xor_eq", + # "NULL" is not a keyword, but is still very likely to cause problems if + # used as a namespace name. + "NULL", + ) +) # The support namespace, as a C++ namespace prefix. This namespace contains the # Emboss C++ support classes. @@ -174,218 +176,211 @@ # Verify that all supported enum cases have valid, implemented conversions. for _enum_case in _SUPPORTED_ENUM_CASES: - assert name_conversion.is_case_conversion_supported("SHOUTY_CASE", _enum_case) + assert name_conversion.is_case_conversion_supported("SHOUTY_CASE", _enum_case) class Config(NamedTuple): - """Configuration for C++ header generation.""" + """Configuration for C++ header generation.""" - include_enum_traits: bool = True - """Whether or not to include EnumTraits in the generated header.""" + include_enum_traits: bool = True + """Whether or not to include EnumTraits in the generated header.""" def _get_namespace_components(namespace): - """Gets the components of a C++ namespace. + """Gets the components of a C++ namespace. - Examples: - "::some::name::detail" -> ["some", "name", "detail"] - "product::name" -> ["product", "name"] - "simple" -> ["simple"] + Examples: + "::some::name::detail" -> ["some", "name", "detail"] + "product::name" -> ["product", "name"] + "simple" -> ["simple"] - Arguments: - namespace: A string containing the namespace. May be fully-qualified. + Arguments: + namespace: A string containing the namespace. May be fully-qualified. - Returns: - A list of strings, one per namespace component. - """ - return re.findall(_NS_COMPONENT_RE, namespace) + Returns: + A list of strings, one per namespace component.""" + return re.findall(_NS_COMPONENT_RE, namespace) def _get_module_namespace(module): - """Returns the C++ namespace of the module, as a list of components. - - Arguments: - module: The IR of an Emboss module whose namespace should be returned. - - Returns: - A list of strings, one per namespace component. This list can be formatted - as appropriate by the caller. - """ - namespace_attr = ir_util.get_attribute(module.attribute, "namespace") - if namespace_attr and namespace_attr.string_constant.text: - namespace = namespace_attr.string_constant.text - else: - namespace = "emboss_generated_code" - return _get_namespace_components(namespace) + """Returns the C++ namespace of the module, as a list of components. + + Arguments: + module: The IR of an Emboss module whose namespace should be returned. + + Returns: + A list of strings, one per namespace component. This list can be formatted + as appropriate by the caller. + """ + namespace_attr = ir_util.get_attribute(module.attribute, "namespace") + if namespace_attr and namespace_attr.string_constant.text: + namespace = namespace_attr.string_constant.text + else: + namespace = "emboss_generated_code" + return _get_namespace_components(namespace) def _cpp_string_escape(string): - return re.sub("['\"\\\\]", r"\\\0", string) + return re.sub("['\"\\\\]", r"\\\0", string) def _get_includes(module, config: Config): - """Returns the appropriate #includes based on module's imports.""" - includes = [] - for import_ in module.foreign_import: - if import_.file_name.text: - includes.append( - code_template.format_template( - _TEMPLATES.include, - file_name=_cpp_string_escape(import_.file_name.text + ".h"), - ) - ) - else: - includes.append( - code_template.format_template( - _TEMPLATES.include, - file_name=_cpp_string_escape(_PRELUDE_INCLUDE_FILE), - ) - ) - if config.include_enum_traits: - includes.extend([ - code_template.format_template( - _TEMPLATES.include, file_name=_cpp_string_escape(file_name) + """Returns the appropriate #includes based on module's imports.""" + includes = [] + for import_ in module.foreign_import: + if import_.file_name.text: + includes.append( + code_template.format_template( + _TEMPLATES.include, + file_name=_cpp_string_escape(import_.file_name.text + ".h"), + ) ) - for file_name in ( - _ENUM_VIEW_INCLUDE_FILE, - _TEXT_UTIL_INCLUDE_FILE, + else: + includes.append( + code_template.format_template( + _TEMPLATES.include, + file_name=_cpp_string_escape(_PRELUDE_INCLUDE_FILE), + ) ) - ]) - return "".join(includes) + if config.include_enum_traits: + includes.extend( + [ + code_template.format_template( + _TEMPLATES.include, file_name=_cpp_string_escape(file_name) + ) + for file_name in ( + _ENUM_VIEW_INCLUDE_FILE, + _TEXT_UTIL_INCLUDE_FILE, + ) + ] + ) + return "".join(includes) def _render_namespace_prefix(namespace): - """Returns namespace rendered as a prefix, like ::foo::bar::baz.""" - return "".join(["::" + n for n in namespace]) + """Returns namespace rendered as a prefix, like ::foo::bar::baz.""" + return "".join(["::" + n for n in namespace]) def _render_integer(value): - """Returns a C++ string representation of a constant integer.""" - integer_type = _cpp_integer_type_for_range(value, value) - assert ( - integer_type - ), "Bug: value should never be outside [-2**63, 2**64), got {}.".format(value) - # C++ literals are always positive. Negative constants are actually the - # positive literal with the unary `-` operator applied. - # - # This means that C++ compilers for 2s-complement systems get finicky about - # minimum integers: if you feed `-9223372036854775808` into GCC, with -Wall, - # you get: - # - # warning: integer constant is so large that it is unsigned - # - # and Clang gives: - # - # warning: integer literal is too large to be represented in a signed - # integer type, interpreting as unsigned [-Wimplicitly-unsigned-literal] - # - # and MSVC: - # - # warning C4146: unary minus operator applied to unsigned type, result - # still unsigned - # - # So, workaround #1: -(2**63) must be written `(-9223372036854775807 - 1)`. - # - # The next problem is that MSVC (but not Clang or GCC) will pick `unsigned` - # as the type of a literal like `2147483648`. As far as I can tell, this is a - # violation of the C++11 standard, but it's possible that the final standard - # has different rules. (MSVC seems to treat decimal literals the way that the - # standard says octal and hexadecimal literals should be treated.) - # - # Luckily, workaround #2: we can unconditionally append `LL` to all constants - # to force them to be interpreted as `long long` (or `unsigned long long` for - # `ULL`-suffixed constants), and then use a narrowing cast to the appropriate - # type, without any warnings on any major compilers. - # - # TODO(bolms): This suffix computation is kind of a hack. - suffix = "U" if "uint" in integer_type else "" - if value == -(2**63): - return "static_cast({1}LL - 1)".format(integer_type, -(2**63 - 1)) - else: - return "static_cast({1}{2}LL)".format(integer_type, value, suffix) + """Returns a C++ string representation of a constant integer.""" + integer_type = _cpp_integer_type_for_range(value, value) + assert ( + integer_type + ), "Bug: value should never be outside [-2**63, 2**64), " "got {}.".format(value) + # C++ literals are always positive. Negative constants are actually the + # positive literal with the unary `-` operator applied. + # + # This means that C++ compilers for 2s-complement systems get finicky about + # minimum integers: if you feed `-9223372036854775808` into GCC, with -Wall, + # you get: + # + # warning: integer constant is so large that it is unsigned + # + # and Clang gives: + # + # warning: integer literal is too large to be represented in a signed + # integer type, interpreting as unsigned [-Wimplicitly-unsigned-literal] + # + # and MSVC: + # + # warning C4146: unary minus operator applied to unsigned type, result + # still unsigned + # + # So, workaround #1: -(2**63) must be written `(-9223372036854775807 - 1)`. + # + # The next problem is that MSVC (but not Clang or GCC) will pick `unsigned` + # as the type of a literal like `2147483648`. As far as I can tell, this is a + # violation of the C++11 standard, but it's possible that the final standard + # has different rules. (MSVC seems to treat decimal literals the way that the + # standard says octal and hexadecimal literals should be treated.) + # + # Luckily, workaround #2: we can unconditionally append `LL` to all constants + # to force them to be interpreted as `long long` (or `unsigned long long` for + # `ULL`-suffixed constants), and then use a narrowing cast to the appropriate + # type, without any warnings on any major compilers. + # + # TODO(bolms): This suffix computation is kind of a hack. + suffix = "U" if "uint" in integer_type else "" + if value == -(2**63): + return "static_cast({1}LL - 1)".format(integer_type, -(2**63 - 1)) + else: + return "static_cast({1}{2}LL)".format(integer_type, value, suffix) def _maybe_type(wrapped_type): - return "::emboss::support::Maybe".format(wrapped_type) + return "::emboss::support::Maybe".format(wrapped_type) def _render_integer_for_expression(value): - integer_type = _cpp_integer_type_for_range(value, value) - return "{0}({1})".format(_maybe_type(integer_type), _render_integer(value)) + integer_type = _cpp_integer_type_for_range(value, value) + return "{0}({1})".format(_maybe_type(integer_type), _render_integer(value)) def _wrap_in_namespace(body, namespace): - """Returns the given body wrapped in the given namespace.""" - for component in reversed(namespace): - body = ( - code_template.format_template( - _TEMPLATES.namespace_wrap, component=component, body=body + """Returns the given body wrapped in the given namespace.""" + for component in reversed(namespace): + body = ( + code_template.format_template( + _TEMPLATES.namespace_wrap, component=component, body=body + ) + + "\n" ) - + "\n" - ) - return body + return body def _get_type_size(type_ir, ir): - size = ir_util.fixed_size_of_type_in_bits(type_ir, ir) - assert ( - size is not None - ), "_get_type_size should only be called for constant-sized types." - return size + size = ir_util.fixed_size_of_type_in_bits(type_ir, ir) + assert ( + size is not None + ), "_get_type_size should only be called for constant-sized types." + return size def _offset_storage_adapter(buffer_type, alignment, static_offset): - return "{}::template OffsetStorageType".format( - buffer_type, alignment, static_offset - ) + return "{}::template OffsetStorageType".format( + buffer_type, alignment, static_offset + ) def _bytes_to_bits_convertor(buffer_type, byte_order, size): - assert byte_order, "byte_order should not be empty." - return "{}::BitBlock, {}>".format( - _SUPPORT_NAMESPACE, _SUPPORT_NAMESPACE, byte_order, buffer_type, size - ) + assert byte_order, "byte_order should not be empty." + return "{}::BitBlock, {}>".format( + _SUPPORT_NAMESPACE, _SUPPORT_NAMESPACE, byte_order, buffer_type, size + ) def _get_fully_qualified_namespace(name, ir): - module = ir_util.find_object((name.module_file,), ir) - namespace = _render_namespace_prefix(_get_module_namespace(module)) - return namespace + "".join(["::" + str(s) for s in name.object_path[:-1]]) + module = ir_util.find_object((name.module_file,), ir) + namespace = _render_namespace_prefix(_get_module_namespace(module)) + return namespace + "".join(["::" + str(s) for s in name.object_path[:-1]]) def _get_unqualified_name(name): - return name.object_path[-1] + return name.object_path[-1] def _get_fully_qualified_name(name, ir): - return ( - _get_fully_qualified_namespace(name, ir) - + "::" - + _get_unqualified_name(name) - ) + return _get_fully_qualified_namespace(name, ir) + "::" + _get_unqualified_name(name) def _get_adapted_cpp_buffer_type_for_field( - type_definition, - size_in_bits, - buffer_type, - byte_order, - parent_addressable_unit, + type_definition, size_in_bits, buffer_type, byte_order, parent_addressable_unit ): - """Returns the adapted C++ type information needed to construct a view.""" - if ( - parent_addressable_unit == ir_data.AddressableUnit.BYTE - and type_definition.addressable_unit == ir_data.AddressableUnit.BIT - ): - assert byte_order - return _bytes_to_bits_convertor(buffer_type, byte_order, size_in_bits) - else: - assert ( - parent_addressable_unit == type_definition.addressable_unit - ), "Addressable unit mismatch: {} vs {}".format( - parent_addressable_unit, type_definition.addressable_unit - ) - return buffer_type + """Returns the adapted C++ type information needed to construct a view.""" + if ( + parent_addressable_unit == ir_data.AddressableUnit.BYTE + and type_definition.addressable_unit == ir_data.AddressableUnit.BIT + ): + assert byte_order + return _bytes_to_bits_convertor(buffer_type, byte_order, size_in_bits) + else: + assert ( + parent_addressable_unit == type_definition.addressable_unit + ), "Addressable unit mismatch: {} vs {}".format( + parent_addressable_unit, type_definition.addressable_unit + ) + return buffer_type def _get_cpp_view_type_for_type_definition( @@ -397,457 +392,444 @@ def _get_cpp_view_type_for_type_definition( parent_addressable_unit, validator, ): - """Returns the C++ type information needed to construct a view. - - Returns the C++ type for a view of the given Emboss TypeDefinition, and the - C++ types of its parameters, if any. - - Arguments: - type_definition: The ir_data.TypeDefinition whose view should be - constructed. - size: The size, in type_definition.addressable_units, of the instantiated - type, or None if it is not known at compile time. - ir: The complete IR. - buffer_type: The C++ type to be used as the Storage parameter of the view - (e.g., "ContiguousBuffer<...>"). - byte_order: For BIT types which are direct children of BYTE types, - "LittleEndian", "BigEndian", or "None". Otherwise, None. - parent_addressable_unit: The addressable_unit_size of the structure - containing this structure. - validator: The name of the validator type to be injected into the view. - - Returns: - A tuple of: the C++ view type and a (possibly-empty) list of the C++ types - of Emboss parameters which must be passed to the view's constructor. - """ - adapted_buffer_type = _get_adapted_cpp_buffer_type_for_field( - type_definition, size, buffer_type, byte_order, parent_addressable_unit - ) - if type_definition.has_field("external"): - # Externals do not (yet) support runtime parameters. - return ( - code_template.format_template( - _TEMPLATES.external_view_type, - namespace=_get_fully_qualified_namespace( - type_definition.name.canonical_name, ir - ), - name=_get_unqualified_name(type_definition.name.canonical_name), - bits=size, - validator=validator, - buffer_type=adapted_buffer_type, - ), - [], + """Returns the C++ type information needed to construct a view. + + Returns the C++ type for a view of the given Emboss TypeDefinition, and the + C++ types of its parameters, if any. + + Arguments: + type_definition: The ir_data.TypeDefinition whose view should be + constructed. + size: The size, in type_definition.addressable_units, of the instantiated + type, or None if it is not known at compile time. + ir: The complete IR. + buffer_type: The C++ type to be used as the Storage parameter of the view + (e.g., "ContiguousBuffer<...>"). + byte_order: For BIT types which are direct children of BYTE types, + "LittleEndian", "BigEndian", or "None". Otherwise, None. + parent_addressable_unit: The addressable_unit_size of the structure + containing this structure. + validator: The name of the validator type to be injected into the view. + + Returns: + A tuple of: the C++ view type and a (possibly-empty) list of the C++ types + of Emboss parameters which must be passed to the view's constructor. + """ + adapted_buffer_type = _get_adapted_cpp_buffer_type_for_field( + type_definition, size, buffer_type, byte_order, parent_addressable_unit ) - elif type_definition.has_field("structure"): - parameter_types = [] - for parameter in type_definition.runtime_parameter: - parameter_types.append( - _cpp_basic_type_for_expression_type(parameter.type, ir) - ) - return ( - code_template.format_template( - _TEMPLATES.structure_view_type, - namespace=_get_fully_qualified_namespace( - type_definition.name.canonical_name, ir + if type_definition.has_field("external"): + # Externals do not (yet) support runtime parameters. + return ( + code_template.format_template( + _TEMPLATES.external_view_type, + namespace=_get_fully_qualified_namespace( + type_definition.name.canonical_name, ir + ), + name=_get_unqualified_name(type_definition.name.canonical_name), + bits=size, + validator=validator, + buffer_type=adapted_buffer_type, ), - name=_get_unqualified_name(type_definition.name.canonical_name), - buffer_type=adapted_buffer_type, - ), - parameter_types, - ) - elif type_definition.has_field("enumeration"): - return ( - code_template.format_template( - _TEMPLATES.enum_view_type, - support_namespace=_SUPPORT_NAMESPACE, - enum_type=_get_fully_qualified_name( - type_definition.name.canonical_name, ir + [], + ) + elif type_definition.has_field("structure"): + parameter_types = [] + for parameter in type_definition.runtime_parameter: + parameter_types.append( + _cpp_basic_type_for_expression_type(parameter.type, ir) + ) + return ( + code_template.format_template( + _TEMPLATES.structure_view_type, + namespace=_get_fully_qualified_namespace( + type_definition.name.canonical_name, ir + ), + name=_get_unqualified_name(type_definition.name.canonical_name), + buffer_type=adapted_buffer_type, ), - bits=size, - validator=validator, - buffer_type=adapted_buffer_type, - ), - [], - ) - else: - assert False, "Unknown variety of type {}".format(type_definition) + parameter_types, + ) + elif type_definition.has_field("enumeration"): + return ( + code_template.format_template( + _TEMPLATES.enum_view_type, + support_namespace=_SUPPORT_NAMESPACE, + enum_type=_get_fully_qualified_name( + type_definition.name.canonical_name, ir + ), + bits=size, + validator=validator, + buffer_type=adapted_buffer_type, + ), + [], + ) + else: + assert False, "Unknown variety of type {}".format(type_definition) def _get_cpp_view_type_for_physical_type( - type_ir, - size, - byte_order, - ir, - buffer_type, - parent_addressable_unit, - validator, + type_ir, size, byte_order, ir, buffer_type, parent_addressable_unit, validator ): - """Returns the C++ type information needed to construct a field's view. - - Returns the C++ type of an ir_data.Type, and the C++ types of its parameters, - if any. - - Arguments: - type_ir: The ir_data.Type whose view should be constructed. - size: The size, in type_definition.addressable_units, of the instantiated - type, or None if it is not known at compile time. - byte_order: For BIT types which are direct children of BYTE types, - "LittleEndian", "BigEndian", or "None". Otherwise, None. - ir: The complete IR. - buffer_type: The C++ type to be used as the Storage parameter of the view - (e.g., "ContiguousBuffer<...>"). - parent_addressable_unit: The addressable_unit_size of the structure - containing this type. - validator: The name of the validator type to be injected into the view. - - Returns: - A tuple of: the C++ type for a view of the given Emboss Type and a list of - the C++ types of any parameters of the view type, which should be passed - to the view's constructor. - """ - if ir_util.is_array(type_ir): - # An array view is parameterized by the element's view type. - base_type = type_ir.array_type.base_type - element_size_in_bits = _get_type_size(base_type, ir) - assert ( - element_size_in_bits - ), "TODO(bolms): Implement arrays of dynamically-sized elements." - assert ( - element_size_in_bits % parent_addressable_unit == 0 - ), "Array elements must fall on byte boundaries." - element_size = element_size_in_bits // parent_addressable_unit - element_view_type, element_view_parameter_types, element_view_parameters = ( - _get_cpp_view_type_for_physical_type( - base_type, - element_size_in_bits, - byte_order, + """Returns the C++ type information needed to construct a field's view. + + Returns the C++ type of an ir_data.Type, and the C++ types of its parameters, + if any. + + Arguments: + type_ir: The ir_data.Type whose view should be constructed. + size: The size, in type_definition.addressable_units, of the instantiated + type, or None if it is not known at compile time. + byte_order: For BIT types which are direct children of BYTE types, + "LittleEndian", "BigEndian", or "None". Otherwise, None. + ir: The complete IR. + buffer_type: The C++ type to be used as the Storage parameter of the view + (e.g., "ContiguousBuffer<...>"). + parent_addressable_unit: The addressable_unit_size of the structure + containing this type. + validator: The name of the validator type to be injected into the view. + + Returns: + A tuple of: the C++ type for a view of the given Emboss Type and a list of + the C++ types of any parameters of the view type, which should be passed + to the view's constructor. + """ + if ir_util.is_array(type_ir): + # An array view is parameterized by the element's view type. + base_type = type_ir.array_type.base_type + element_size_in_bits = _get_type_size(base_type, ir) + assert ( + element_size_in_bits + ), "TODO(bolms): Implement arrays of dynamically-sized elements." + assert ( + element_size_in_bits % parent_addressable_unit == 0 + ), "Array elements must fall on byte boundaries." + element_size = element_size_in_bits // parent_addressable_unit + element_view_type, element_view_parameter_types, element_view_parameters = ( + _get_cpp_view_type_for_physical_type( + base_type, + element_size_in_bits, + byte_order, + ir, + _offset_storage_adapter(buffer_type, element_size, 0), + parent_addressable_unit, + validator, + ) + ) + return ( + code_template.format_template( + _TEMPLATES.array_view_adapter, + support_namespace=_SUPPORT_NAMESPACE, + # TODO(bolms): The element size should be calculable from the field + # size and array length. + element_view_type=element_view_type, + element_view_parameter_types="".join( + ", " + p for p in element_view_parameter_types + ), + element_size=element_size, + addressable_unit_size=int(parent_addressable_unit), + buffer_type=buffer_type, + ), + element_view_parameter_types, + element_view_parameters, + ) + else: + assert type_ir.has_field("atomic_type") + reference = type_ir.atomic_type.reference + referenced_type = ir_util.find_object(reference, ir) + if parent_addressable_unit > referenced_type.addressable_unit: + assert byte_order, repr(type_ir) + reader, parameter_types = _get_cpp_view_type_for_type_definition( + referenced_type, + size, ir, - _offset_storage_adapter(buffer_type, element_size, 0), + buffer_type, + byte_order, parent_addressable_unit, validator, ) - ) - return ( - code_template.format_template( - _TEMPLATES.array_view_adapter, - support_namespace=_SUPPORT_NAMESPACE, - # TODO(bolms): The element size should be calculable from the field - # size and array length. - element_view_type=element_view_type, - element_view_parameter_types="".join( - ", " + p for p in element_view_parameter_types - ), - element_size=element_size, - addressable_unit_size=int(parent_addressable_unit), - buffer_type=buffer_type, - ), - element_view_parameter_types, - element_view_parameters, - ) - else: - assert type_ir.has_field("atomic_type") - reference = type_ir.atomic_type.reference - referenced_type = ir_util.find_object(reference, ir) - if parent_addressable_unit > referenced_type.addressable_unit: - assert byte_order, repr(type_ir) - reader, parameter_types = _get_cpp_view_type_for_type_definition( - referenced_type, - size, - ir, - buffer_type, - byte_order, - parent_addressable_unit, - validator, - ) - return reader, parameter_types, list(type_ir.atomic_type.runtime_parameter) + return reader, parameter_types, list(type_ir.atomic_type.runtime_parameter) def _render_variable(variable, prefix=""): - """Renders a variable reference (e.g., `foo` or `foo.bar.baz`) in C++ code.""" - # A "variable" could be an immediate field or a subcomponent of an immediate - # field. For either case, in C++ it is valid to just use the last component - # of the name; it is not necessary to qualify the method with the type. - components = [] - for component in variable: - components.append(_cpp_field_name(component[-1]) + "()") - components[-1] = prefix + components[-1] - return ".".join(components) + """Renders a variable reference (e.g., `foo` or `foo.bar.baz`) in C++ code.""" + # A "variable" could be an immediate field or a subcomponent of an immediate + # field. For either case, in C++ it is valid to just use the last component + # of the name; it is not necessary to qualify the method with the type. + components = [] + for component in variable: + components.append(_cpp_field_name(component[-1]) + "()") + components[-1] = prefix + components[-1] + return ".".join(components) def _render_enum_value(enum_type, ir): - cpp_enum_type = _get_fully_qualified_name(enum_type.name.canonical_name, ir) - return "{}(static_cast({}))".format( - _maybe_type(cpp_enum_type), cpp_enum_type, enum_type.value - ) + cpp_enum_type = _get_fully_qualified_name(enum_type.name.canonical_name, ir) + return "{}(static_cast({}))".format( + _maybe_type(cpp_enum_type), cpp_enum_type, enum_type.value + ) def _builtin_function_name(function): - """Returns the C++ operator name corresponding to an Emboss operator.""" - functions = { - ir_data.FunctionMapping.ADDITION: "Sum", - ir_data.FunctionMapping.SUBTRACTION: "Difference", - ir_data.FunctionMapping.MULTIPLICATION: "Product", - ir_data.FunctionMapping.EQUALITY: "Equal", - ir_data.FunctionMapping.INEQUALITY: "NotEqual", - ir_data.FunctionMapping.AND: "And", - ir_data.FunctionMapping.OR: "Or", - ir_data.FunctionMapping.LESS: "LessThan", - ir_data.FunctionMapping.LESS_OR_EQUAL: "LessThanOrEqual", - ir_data.FunctionMapping.GREATER: "GreaterThan", - ir_data.FunctionMapping.GREATER_OR_EQUAL: "GreaterThanOrEqual", - ir_data.FunctionMapping.CHOICE: "Choice", - ir_data.FunctionMapping.MAXIMUM: "Maximum", - } - return functions[function] + """Returns the C++ operator name corresponding to an Emboss operator.""" + functions = { + ir_data.FunctionMapping.ADDITION: "Sum", + ir_data.FunctionMapping.SUBTRACTION: "Difference", + ir_data.FunctionMapping.MULTIPLICATION: "Product", + ir_data.FunctionMapping.EQUALITY: "Equal", + ir_data.FunctionMapping.INEQUALITY: "NotEqual", + ir_data.FunctionMapping.AND: "And", + ir_data.FunctionMapping.OR: "Or", + ir_data.FunctionMapping.LESS: "LessThan", + ir_data.FunctionMapping.LESS_OR_EQUAL: "LessThanOrEqual", + ir_data.FunctionMapping.GREATER: "GreaterThan", + ir_data.FunctionMapping.GREATER_OR_EQUAL: "GreaterThanOrEqual", + ir_data.FunctionMapping.CHOICE: "Choice", + ir_data.FunctionMapping.MAXIMUM: "Maximum", + } + return functions[function] def _cpp_basic_type_for_expression_type(expression_type, ir): - """Returns the C++ basic type (int32_t, bool, etc.) for an ExpressionType.""" - if expression_type.which_type == "integer": - return _cpp_integer_type_for_range( - int(expression_type.integer.minimum_value), - int(expression_type.integer.maximum_value), - ) - elif expression_type.which_type == "boolean": - return "bool" - elif expression_type.which_type == "enumeration": - return _get_fully_qualified_name( - expression_type.enumeration.name.canonical_name, ir - ) - else: - assert False, "Unknown expression type " + expression_type.which_type + """Returns the C++ basic type (int32_t, bool, etc.) for an ExpressionType.""" + if expression_type.which_type == "integer": + return _cpp_integer_type_for_range( + int(expression_type.integer.minimum_value), + int(expression_type.integer.maximum_value), + ) + elif expression_type.which_type == "boolean": + return "bool" + elif expression_type.which_type == "enumeration": + return _get_fully_qualified_name( + expression_type.enumeration.name.canonical_name, ir + ) + else: + assert False, "Unknown expression type " + expression_type.which_type def _cpp_basic_type_for_expression(expression, ir): - """Returns the C++ basic type (int32_t, bool, etc.) for an Expression.""" - return _cpp_basic_type_for_expression_type(expression.type, ir) + """Returns the C++ basic type (int32_t, bool, etc.) for an Expression.""" + return _cpp_basic_type_for_expression_type(expression.type, ir) def _cpp_integer_type_for_range(min_val, max_val): - """Returns the appropriate C++ integer type to hold min_val up to max_val.""" - # The choice of int32_t, uint32_t, int64_t, then uint64_t is somewhat - # arbitrary here, and might not be perfectly ideal. I (bolms@) have chosen - # this set of types to a) minimize the number of casts that occur in - # arithmetic expressions, and b) favor 32-bit arithmetic, which is mostly - # "cheapest" on current (2018) systems. Signed integers are also preferred - # over unsigned so that the C++ compiler can take advantage of undefined - # overflow. - for size in (32, 64): - if min_val >= -(2 ** (size - 1)) and max_val <= 2 ** (size - 1) - 1: - return "::std::int{}_t".format(size) - elif min_val >= 0 and max_val <= 2**size - 1: - return "::std::uint{}_t".format(size) - return None + """Returns the appropriate C++ integer type to hold min_val up to max_val.""" + # The choice of int32_t, uint32_t, int64_t, then uint64_t is somewhat + # arbitrary here, and might not be perfectly ideal. I (bolms@) have chosen + # this set of types to a) minimize the number of casts that occur in + # arithmetic expressions, and b) favor 32-bit arithmetic, which is mostly + # "cheapest" on current (2018) systems. Signed integers are also preferred + # over unsigned so that the C++ compiler can take advantage of undefined + # overflow. + for size in (32, 64): + if min_val >= -(2 ** (size - 1)) and max_val <= 2 ** (size - 1) - 1: + return "::std::int{}_t".format(size) + elif min_val >= 0 and max_val <= 2**size - 1: + return "::std::uint{}_t".format(size) + return None def _cpp_integer_type_for_enum(max_bits, is_signed): - """Returns the appropriate C++ integer type to hold an enum.""" - # This is used to determine the `X` in `enum class : X`. - # - # Unlike _cpp_integer_type_for_range, the type chosen here is used for actual - # storage. Further, sizes smaller than 64 are explicitly chosen by a human - # author, so take the smallest size that can hold the given number of bits. - # - # Technically, the C++ standard allows some of these sizes of integer to not - # exist, and other sizes (say, int24_t) might exist, but in practice this set - # is almost always available. If you're compiling for some exotic DSP that - # uses unusual int sizes, email emboss-dev@google.com. - for size in (8, 16, 32, 64): - if max_bits <= size: - return "::std::{}int{}_t".format("" if is_signed else "u", size) - assert False, f"Invalid value {max_bits} for maximum_bits" + """Returns the appropriate C++ integer type to hold an enum.""" + # This is used to determine the `X` in `enum class : X`. + # + # Unlike _cpp_integer_type_for_range, the type chosen here is used for actual + # storage. Further, sizes smaller than 64 are explicitly chosen by a human + # author, so take the smallest size that can hold the given number of bits. + # + # Technically, the C++ standard allows some of these sizes of integer to not + # exist, and other sizes (say, int24_t) might exist, but in practice this set + # is almost always available. If you're compiling for some exotic DSP that + # uses unusual int sizes, email emboss-dev@google.com. + for size in (8, 16, 32, 64): + if max_bits <= size: + return "::std::{}int{}_t".format("" if is_signed else "u", size) + assert False, f"Invalid value {max_bits} for maximum_bits" def _render_builtin_operation(expression, ir, field_reader, subexpressions): - """Renders a built-in operation (+, -, &&, etc.) into C++ code.""" - assert expression.function.function not in ( - ir_data.FunctionMapping.UPPER_BOUND, - ir_data.FunctionMapping.LOWER_BOUND, - ), "UPPER_BOUND and LOWER_BOUND should be constant." - if expression.function.function == ir_data.FunctionMapping.PRESENCE: - return field_reader.render_existence( - expression.function.args[0], subexpressions + """Renders a built-in operation (+, -, &&, etc.) into C++ code.""" + assert expression.function.function not in ( + ir_data.FunctionMapping.UPPER_BOUND, + ir_data.FunctionMapping.LOWER_BOUND, + ), "UPPER_BOUND and LOWER_BOUND should be constant." + if expression.function.function == ir_data.FunctionMapping.PRESENCE: + return field_reader.render_existence( + expression.function.args[0], subexpressions + ) + args = expression.function.args + rendered_args = [ + _render_expression(arg, ir, field_reader, subexpressions).rendered + for arg in args + ] + minimum_integers = [] + maximum_integers = [] + enum_types = set() + have_boolean_types = False + for subexpression in [expression] + list(args): + if subexpression.type.which_type == "integer": + minimum_integers.append(int(subexpression.type.integer.minimum_value)) + maximum_integers.append(int(subexpression.type.integer.maximum_value)) + elif subexpression.type.which_type == "enumeration": + enum_types.add(_cpp_basic_type_for_expression(subexpression, ir)) + elif subexpression.type.which_type == "boolean": + have_boolean_types = True + # At present, all Emboss functions other than `$has` take and return one of + # the following: + # + # integers + # integers and booleans + # a single enum type + # a single enum type and booleans + # booleans + # + # Really, the intermediate type is only necessary for integers, but it + # simplifies the C++ somewhat if the appropriate enum/boolean type is provided + # as "IntermediateT" -- it means that, e.g., the choice ("?:") operator does + # not have to have two versions, one of which casts (some of) its arguments to + # IntermediateT, and one of which does not. + # + # This is not a particularly robust scheme, but it works for all of the Emboss + # functions I (bolms@) have written and am considering (division, modulus, + # exponentiation, logical negation, bit shifts, bitwise and/or/xor, $min, + # $floor, $ceil, $has). + if minimum_integers and not enum_types: + intermediate_type = _cpp_integer_type_for_range( + min(minimum_integers), max(maximum_integers) + ) + elif len(enum_types) == 1 and not minimum_integers: + intermediate_type = list(enum_types)[0] + else: + assert have_boolean_types + assert not enum_types + assert not minimum_integers + intermediate_type = "bool" + arg_types = [_cpp_basic_type_for_expression(arg, ir) for arg in args] + result_type = _cpp_basic_type_for_expression(expression, ir) + function_variant = "".format( + intermediate_type, result_type, ", ".join(arg_types) ) - args = expression.function.args - rendered_args = [ - _render_expression(arg, ir, field_reader, subexpressions).rendered - for arg in args - ] - minimum_integers = [] - maximum_integers = [] - enum_types = set() - have_boolean_types = False - for subexpression in [expression] + list(args): - if subexpression.type.which_type == "integer": - minimum_integers.append(int(subexpression.type.integer.minimum_value)) - maximum_integers.append(int(subexpression.type.integer.maximum_value)) - elif subexpression.type.which_type == "enumeration": - enum_types.add(_cpp_basic_type_for_expression(subexpression, ir)) - elif subexpression.type.which_type == "boolean": - have_boolean_types = True - # At present, all Emboss functions other than `$has` take and return one of - # the following: - # - # integers - # integers and booleans - # a single enum type - # a single enum type and booleans - # booleans - # - # Really, the intermediate type is only necessary for integers, but it - # simplifies the C++ somewhat if the appropriate enum/boolean type is provided - # as "IntermediateT" -- it means that, e.g., the choice ("?:") operator does - # not have to have two versions, one of which casts (some of) its arguments to - # IntermediateT, and one of which does not. - # - # This is not a particularly robust scheme, but it works for all of the Emboss - # functions I (bolms@) have written and am considering (division, modulus, - # exponentiation, logical negation, bit shifts, bitwise and/or/xor, $min, - # $floor, $ceil, $has). - if minimum_integers and not enum_types: - intermediate_type = _cpp_integer_type_for_range( - min(minimum_integers), max(maximum_integers) + return "::emboss::support::{}{}({})".format( + _builtin_function_name(expression.function.function), + function_variant, + ", ".join(rendered_args), ) - elif len(enum_types) == 1 and not minimum_integers: - intermediate_type = list(enum_types)[0] - else: - assert have_boolean_types - assert not enum_types - assert not minimum_integers - intermediate_type = "bool" - arg_types = [_cpp_basic_type_for_expression(arg, ir) for arg in args] - result_type = _cpp_basic_type_for_expression(expression, ir) - function_variant = "".format( - intermediate_type, result_type, ", ".join(arg_types) - ) - return "::emboss::support::{}{}({})".format( - _builtin_function_name(expression.function.function), - function_variant, - ", ".join(rendered_args), - ) class _FieldRenderer(object): - """Base class for rendering field reads.""" + """Base class for rendering field reads.""" - def render_field_read_with_context( - self, expression, ir, prefix, subexpressions - ): - field = prefix + _render_variable( - ir_util.hashable_form_of_field_reference(expression.field_reference) - ) - if subexpressions is None: - field_expression = field - else: - field_expression = subexpressions.add(field) - expression_cpp_type = _cpp_basic_type_for_expression(expression, ir) - return ( - "({0}.Ok()" - " ? {1}(static_cast({0}.UncheckedRead()))" - " : {1}())".format( - field_expression, - _maybe_type(expression_cpp_type), - expression_cpp_type, + def render_field_read_with_context(self, expression, ir, prefix, subexpressions): + field = prefix + _render_variable( + ir_util.hashable_form_of_field_reference(expression.field_reference) + ) + if subexpressions is None: + field_expression = field + else: + field_expression = subexpressions.add(field) + expression_cpp_type = _cpp_basic_type_for_expression(expression, ir) + return ( + "({0}.Ok()" + " ? {1}(static_cast({0}.UncheckedRead()))" + " : {1}())".format( + field_expression, _maybe_type(expression_cpp_type), expression_cpp_type + ) ) - ) - def render_existence_with_context(self, expression, prefix, subexpressions): - return "{1}{0}".format( - _render_variable( - ir_util.hashable_form_of_field_reference( - expression.field_reference + def render_existence_with_context(self, expression, prefix, subexpressions): + return "{1}{0}".format( + _render_variable( + ir_util.hashable_form_of_field_reference(expression.field_reference), + "has_", ), - "has_", - ), - prefix, - ) + prefix, + ) class _DirectFieldRenderer(_FieldRenderer): - """Renderer for fields read from inside a structure's View type.""" + """Renderer for fields read from inside a structure's View type.""" - def render_field(self, expression, ir, subexpressions): - return self.render_field_read_with_context( - expression, ir, "", subexpressions - ) + def render_field(self, expression, ir, subexpressions): + return self.render_field_read_with_context(expression, ir, "", subexpressions) - def render_existence(self, expression, subexpressions): - return self.render_existence_with_context(expression, "", subexpressions) + def render_existence(self, expression, subexpressions): + return self.render_existence_with_context(expression, "", subexpressions) class _VirtualViewFieldRenderer(_FieldRenderer): - """Renderer for field reads from inside a virtual field's View.""" + """Renderer for field reads from inside a virtual field's View.""" - def render_existence(self, expression, subexpressions): - return self.render_existence_with_context( - expression, "view_.", subexpressions - ) + def render_existence(self, expression, subexpressions): + return self.render_existence_with_context(expression, "view_.", subexpressions) - def render_field(self, expression, ir, subexpressions): - return self.render_field_read_with_context( - expression, ir, "view_.", subexpressions - ) + def render_field(self, expression, ir, subexpressions): + return self.render_field_read_with_context( + expression, ir, "view_.", subexpressions + ) class _SubexpressionStore(object): - """Holder for subexpressions to be assigned to local variables.""" - - def __init__(self, prefix): - self._prefix = prefix - self._subexpr_to_name = {} - self._index_to_subexpr = [] - - def add(self, subexpr): - if subexpr not in self._subexpr_to_name: - self._index_to_subexpr.append(subexpr) - self._subexpr_to_name[subexpr] = self._prefix + str( - len(self._index_to_subexpr) - ) - return self._subexpr_to_name[subexpr] - - def subexprs(self): - return [ - (self._subexpr_to_name[subexpr], subexpr) - for subexpr in self._index_to_subexpr - ] + """Holder for subexpressions to be assigned to local variables.""" + + def __init__(self, prefix): + self._prefix = prefix + self._subexpr_to_name = {} + self._index_to_subexpr = [] + + def add(self, subexpr): + if subexpr not in self._subexpr_to_name: + self._index_to_subexpr.append(subexpr) + self._subexpr_to_name[subexpr] = self._prefix + str( + len(self._index_to_subexpr) + ) + return self._subexpr_to_name[subexpr] + + def subexprs(self): + return [ + (self._subexpr_to_name[subexpr], subexpr) + for subexpr in self._index_to_subexpr + ] class _UsageCountingStore(object): - """A mock SubexpressionStore that counts subexpression usage.""" + """A mock SubexpressionStore that counts subexpression usage.""" + + def __init__(self): + self.counts = collections.defaultdict(int) + + def add(self, subexpr): + self.counts[subexpr] += 1 + return subexpr + - def __init__(self): - self.counts = collections.defaultdict(int) - def add(self, subexpr): - self.counts[subexpr] += 1 - return subexpr class _SmartSubexpressionStore(object): - """A SubexpressionStore that only caches subexpressions used multiple times.""" - - def __init__(self, prefix, counts): - self._prefix = prefix - self._counts = counts - self._subexpr_to_name = {} - self._index_to_subexpr = [] - - def add(self, subexpr): - if self._counts[subexpr] <= 1: - return subexpr - - if subexpr not in self._subexpr_to_name: - self._index_to_subexpr.append(subexpr) - self._subexpr_to_name[subexpr] = self._prefix + str( - len(self._index_to_subexpr) - ) - return self._subexpr_to_name[subexpr] - - def subexprs(self): - return [ - (self._subexpr_to_name[subexpr], subexpr) - for subexpr in self._index_to_subexpr - ] + """A SubexpressionStore that only caches subexpressions used multiple times.""" + + def __init__(self, prefix, counts): + self._prefix = prefix + self._counts = counts + self._subexpr_to_name = {} + self._index_to_subexpr = [] + + def add(self, subexpr): + if self._counts[subexpr] <= 1: + return subexpr + + if subexpr not in self._subexpr_to_name: + self._index_to_subexpr.append(subexpr) + self._subexpr_to_name[subexpr] = self._prefix + str( + len(self._index_to_subexpr) + ) + return self._subexpr_to_name[subexpr] + + def subexprs(self): + return [ + (self._subexpr_to_name[subexpr], subexpr) + for subexpr in self._index_to_subexpr + ] _ExpressionResult = collections.namedtuple( @@ -856,1197 +838,1190 @@ def subexprs(self): def _render_expression(expression, ir, field_reader=None, subexpressions=None): - """Renders an expression into C++ code. - - Arguments: - expression: The expression to render. - ir: The IR in which to look up references. - field_reader: An object with render_existence and render_field methods - appropriate for the C++ context of the expression. - subexpressions: A _SubexpressionStore in which to put subexpressions, or - None if subexpressions should be inline. - - Returns: - A tuple of (rendered_text, is_constant), where rendered_text is C++ code - that can be emitted, and is_constant is True if the expression is a - compile-time constant suitable for use in a C++11 constexpr context, - otherwise False. - """ - if field_reader is None: - field_reader = _DirectFieldRenderer() - - # If the expression is constant, there are no guarantees that subexpressions - # will fit into C++ types, or that operator arguments and return types can fit - # in the same type: expressions like `-0x8000_0000_0000_0000` and - # `0x1_0000_0000_0000_0000 - 1` can appear. - if expression.type.which_type == "integer": - if expression.type.integer.modulus == "infinity": - return _ExpressionResult( - _render_integer_for_expression( - int(expression.type.integer.modular_value) - ), - True, - ) - elif expression.type.which_type == "boolean": - if expression.type.boolean.has_field("value"): - if expression.type.boolean.value: - return _ExpressionResult(_maybe_type("bool") + "(true)", True) - else: - return _ExpressionResult(_maybe_type("bool") + "(false)", True) - elif expression.type.which_type == "enumeration": - if expression.type.enumeration.has_field("value"): - return _ExpressionResult( - _render_enum_value(expression.type.enumeration, ir), True - ) - else: - # There shouldn't be any "opaque" type expressions here. - assert False, "Unhandled expression type {}".format( - expression.type.which_type - ) - - result = None - # Otherwise, render the operation. - if expression.which_expression == "function": - result = _render_builtin_operation( - expression, ir, field_reader, subexpressions - ) - elif expression.which_expression == "field_reference": - result = field_reader.render_field(expression, ir, subexpressions) - elif ( - expression.which_expression == "builtin_reference" - and expression.builtin_reference.canonical_name.object_path[-1] - == "$logical_value" - ): - return _ExpressionResult( - _maybe_type("decltype(emboss_reserved_local_value)") - + "(emboss_reserved_local_value)", - False, - ) + """Renders an expression into C++ code. + + Arguments: + expression: The expression to render. + ir: The IR in which to look up references. + field_reader: An object with render_existence and render_field methods + appropriate for the C++ context of the expression. + subexpressions: A _SubexpressionStore in which to put subexpressions, or + None if subexpressions should be inline. + + Returns: + A tuple of (rendered_text, is_constant), where rendered_text is C++ code + that can be emitted, and is_constant is True if the expression is a + compile-time constant suitable for use in a C++11 constexpr context, + otherwise False. + """ + if field_reader is None: + field_reader = _DirectFieldRenderer() + + # If the expression is constant, there are no guarantees that subexpressions + # will fit into C++ types, or that operator arguments and return types can fit + # in the same type: expressions like `-0x8000_0000_0000_0000` and + # `0x1_0000_0000_0000_0000 - 1` can appear. + if expression.type.which_type == "integer": + if expression.type.integer.modulus == "infinity": + return _ExpressionResult( + _render_integer_for_expression( + int(expression.type.integer.modular_value) + ), + True, + ) + elif expression.type.which_type == "boolean": + if expression.type.boolean.has_field("value"): + if expression.type.boolean.value: + return _ExpressionResult(_maybe_type("bool") + "(true)", True) + else: + return _ExpressionResult(_maybe_type("bool") + "(false)", True) + elif expression.type.which_type == "enumeration": + if expression.type.enumeration.has_field("value"): + return _ExpressionResult( + _render_enum_value(expression.type.enumeration, ir), True + ) + else: + # There shouldn't be any "opaque" type expressions here. + assert False, "Unhandled expression type {}".format(expression.type.which_type) + + result = None + # Otherwise, render the operation. + if expression.which_expression == "function": + result = _render_builtin_operation(expression, ir, field_reader, subexpressions) + elif expression.which_expression == "field_reference": + result = field_reader.render_field(expression, ir, subexpressions) + elif ( + expression.which_expression == "builtin_reference" + and expression.builtin_reference.canonical_name.object_path[-1] + == "$logical_value" + ): + return _ExpressionResult( + _maybe_type("decltype(emboss_reserved_local_value)") + + "(emboss_reserved_local_value)", + False, + ) - # Any of the constant expression types should have been handled in the - # previous section. - assert result is not None, "Unable to render expression {}".format( - str(expression) - ) + # Any of the constant expression types should have been handled in the + # previous section. + assert result is not None, "Unable to render expression {}".format(str(expression)) - if subexpressions is None: - return _ExpressionResult(result, False) - else: - return _ExpressionResult(subexpressions.add(result), False) + if subexpressions is None: + return _ExpressionResult(result, False) + else: + return _ExpressionResult(subexpressions.add(result), False) def _render_existence_test(field, ir, subexpressions=None): - return _render_expression( - field.existence_condition, ir, subexpressions=subexpressions - ) + return _render_expression( + field.existence_condition, ir, subexpressions=subexpressions + ) def _alignment_of_location(location): - constraints = location.start.type.integer - if constraints.modulus == "infinity": - # The C++ templates use 0 as a sentinel value meaning infinity for - # alignment. - return 0, constraints.modular_value - else: - return constraints.modulus, constraints.modular_value + constraints = location.start.type.integer + if constraints.modulus == "infinity": + # The C++ templates use 0 as a sentinel value meaning infinity for + # alignment. + return 0, constraints.modular_value + else: + return constraints.modulus, constraints.modular_value def _get_cpp_type_reader_of_field( field_ir, ir, buffer_type, validator, parent_addressable_unit ): - """Returns the C++ view type for a field.""" - field_size = None - if field_ir.type.has_field("size_in_bits"): - field_size = ir_util.constant_value(field_ir.type.size_in_bits) - assert field_size is not None - elif ir_util.is_constant(field_ir.location.size): - # TODO(bolms): Normalize the IR so that this clause is unnecessary. - field_size = ( - ir_util.constant_value(field_ir.location.size) * parent_addressable_unit + """Returns the C++ view type for a field.""" + field_size = None + if field_ir.type.has_field("size_in_bits"): + field_size = ir_util.constant_value(field_ir.type.size_in_bits) + assert field_size is not None + elif ir_util.is_constant(field_ir.location.size): + # TODO(bolms): Normalize the IR so that this clause is unnecessary. + field_size = ( + ir_util.constant_value(field_ir.location.size) * parent_addressable_unit + ) + byte_order_attr = ir_util.get_attribute(field_ir.attribute, "byte_order") + if byte_order_attr: + byte_order = byte_order_attr.string_constant.text + else: + byte_order = "" + field_alignment, field_offset = _alignment_of_location(field_ir.location) + return _get_cpp_view_type_for_physical_type( + field_ir.type, + field_size, + byte_order, + ir, + _offset_storage_adapter(buffer_type, field_alignment, field_offset), + parent_addressable_unit, + validator, ) - byte_order_attr = ir_util.get_attribute(field_ir.attribute, "byte_order") - if byte_order_attr: - byte_order = byte_order_attr.string_constant.text - else: - byte_order = "" - field_alignment, field_offset = _alignment_of_location(field_ir.location) - return _get_cpp_view_type_for_physical_type( - field_ir.type, - field_size, - byte_order, - ir, - _offset_storage_adapter(buffer_type, field_alignment, field_offset), - parent_addressable_unit, - validator, - ) def _generate_structure_field_methods( enclosing_type_name, field_ir, ir, parent_addressable_unit ): - if ir_util.field_is_virtual(field_ir): - return _generate_structure_virtual_field_methods( - enclosing_type_name, field_ir, ir - ) - else: - return _generate_structure_physical_field_methods( - enclosing_type_name, field_ir, ir, parent_addressable_unit - ) + if ir_util.field_is_virtual(field_ir): + return _generate_structure_virtual_field_methods( + enclosing_type_name, field_ir, ir + ) + else: + return _generate_structure_physical_field_methods( + enclosing_type_name, field_ir, ir, parent_addressable_unit + ) def _generate_custom_validator_expression_for(field_ir, ir): - """Returns a validator expression for the given field, or None.""" - requires_attr = ir_util.get_attribute(field_ir.attribute, "requires") - if requires_attr: - - class _ValidatorFieldReader(object): - """A "FieldReader" that translates the current field to `value`.""" - - def render_existence(self, expression, subexpressions): - del expression # Unused. - assert False, "Shouldn't be here." - - def render_field(self, expression, ir, subexpressions): - assert len(expression.field_reference.path) == 1 - assert ( - expression.field_reference.path[0].canonical_name - == field_ir.name.canonical_name + """Returns a validator expression for the given field, or None.""" + requires_attr = ir_util.get_attribute(field_ir.attribute, "requires") + if requires_attr: + + class _ValidatorFieldReader(object): + """A "FieldReader" that translates the current field to `value`.""" + + def render_existence(self, expression, subexpressions): + del expression # Unused. + assert False, "Shouldn't be here." + + def render_field(self, expression, ir, subexpressions): + assert len(expression.field_reference.path) == 1 + assert ( + expression.field_reference.path[0].canonical_name + == field_ir.name.canonical_name + ) + expression_cpp_type = _cpp_basic_type_for_expression(expression, ir) + return "{}(emboss_reserved_local_value)".format( + _maybe_type(expression_cpp_type) + ) + + validation_body = _render_expression( + requires_attr.expression, ir, _ValidatorFieldReader() ) - expression_cpp_type = _cpp_basic_type_for_expression(expression, ir) - return "{}(emboss_reserved_local_value)".format( - _maybe_type(expression_cpp_type) - ) - - validation_body = _render_expression( - requires_attr.expression, ir, _ValidatorFieldReader() - ) - return validation_body.rendered - else: - return None + return validation_body.rendered + else: + return None def _generate_validator_expression_for(field_ir, ir): - """Returns a validator expression for the given field.""" - result = _generate_custom_validator_expression_for(field_ir, ir) - if result is None: - return "::emboss::support::Maybe(true)" - return result + """Returns a validator expression for the given field.""" + result = _generate_custom_validator_expression_for(field_ir, ir) + if result is None: + return "::emboss::support::Maybe(true)" + return result + + +def _generate_structure_virtual_field_methods(enclosing_type_name, field_ir, ir): + """Generates C++ code for methods for a single virtual field. + + Arguments: + enclosing_type_name: The text name of the enclosing type. + field_ir: The IR for the field to generate methods for. + ir: The full IR for the module. + + Returns: + A tuple of ("", declarations, definitions). The declarations can be + inserted into the class definition for the enclosing type's View. Any + definitions should be placed after the class definition. These are + separated to satisfy C++'s declaration-before-use requirements. + """ + if field_ir.write_method.which_method == "alias": + return _generate_field_indirection(field_ir, enclosing_type_name, ir) + + read_subexpressions = _SubexpressionStore("emboss_reserved_local_subexpr_") + read_value = _render_expression( + field_ir.read_transform, + ir, + field_reader=_VirtualViewFieldRenderer(), + subexpressions=read_subexpressions, + ) + field_exists = _render_existence_test(field_ir, ir) + logical_type = _cpp_basic_type_for_expression(field_ir.read_transform, ir) + if read_value.is_constant and field_exists.is_constant: + assert not read_subexpressions.subexprs() + declaration_template = ( + _TEMPLATES.structure_single_const_virtual_field_method_declarations + ) + definition_template = ( + _TEMPLATES.structure_single_const_virtual_field_method_definitions + ) + else: + declaration_template = ( + _TEMPLATES.structure_single_virtual_field_method_declarations + ) + definition_template = ( + _TEMPLATES.structure_single_virtual_field_method_definitions + ) -def _generate_structure_virtual_field_methods( - enclosing_type_name, field_ir, ir -): - """Generates C++ code for methods for a single virtual field. - - Arguments: - enclosing_type_name: The text name of the enclosing type. - field_ir: The IR for the field to generate methods for. - ir: The full IR for the module. - - Returns: - A tuple of ("", declarations, definitions). The declarations can be - inserted into the class definition for the enclosing type's View. Any - definitions should be placed after the class definition. These are - separated to satisfy C++'s declaration-before-use requirements. - """ - if field_ir.write_method.which_method == "alias": - return _generate_field_indirection(field_ir, enclosing_type_name, ir) - - read_subexpressions = _SubexpressionStore("emboss_reserved_local_subexpr_") - read_value = _render_expression( - field_ir.read_transform, - ir, - field_reader=_VirtualViewFieldRenderer(), - subexpressions=read_subexpressions, - ) - field_exists = _render_existence_test(field_ir, ir) - logical_type = _cpp_basic_type_for_expression(field_ir.read_transform, ir) - - if read_value.is_constant and field_exists.is_constant: - assert not read_subexpressions.subexprs() - declaration_template = ( - _TEMPLATES.structure_single_const_virtual_field_method_declarations - ) - definition_template = ( - _TEMPLATES.structure_single_const_virtual_field_method_definitions - ) - else: - declaration_template = ( - _TEMPLATES.structure_single_virtual_field_method_declarations - ) - definition_template = ( - _TEMPLATES.structure_single_virtual_field_method_definitions - ) + if field_ir.write_method.which_method == "transform": + destination = _render_variable( + ir_util.hashable_form_of_field_reference( + field_ir.write_method.transform.destination + ) + ) + transform = _render_expression( + field_ir.write_method.transform.function_body, + ir, + field_reader=_VirtualViewFieldRenderer(), + ).rendered + write_methods = code_template.format_template( + _TEMPLATES.structure_single_virtual_field_write_methods, + logical_type=logical_type, + destination=destination, + transform=transform, + ) + else: + write_methods = "" - if field_ir.write_method.which_method == "transform": - destination = _render_variable( - ir_util.hashable_form_of_field_reference( - field_ir.write_method.transform.destination + name = field_ir.name.canonical_name.object_path[-1] + if name.startswith("$"): + name = _cpp_field_name(field_ir.name.name.text) + virtual_view_type_name = "EmbossReservedDollarVirtual{}View".format(name) + else: + virtual_view_type_name = "EmbossReservedVirtual{}View".format( + name_conversion.snake_to_camel(name) ) + assert logical_type, "Could not find appropriate C++ type for {}".format( + field_ir.read_transform ) - transform = _render_expression( - field_ir.write_method.transform.function_body, - ir, - field_reader=_VirtualViewFieldRenderer(), - ).rendered - write_methods = code_template.format_template( - _TEMPLATES.structure_single_virtual_field_write_methods, + if field_ir.read_transform.type.which_type == "integer": + write_to_text_stream_function = "WriteIntegerViewToTextStream" + elif field_ir.read_transform.type.which_type == "boolean": + write_to_text_stream_function = "WriteBooleanViewToTextStream" + elif field_ir.read_transform.type.which_type == "enumeration": + write_to_text_stream_function = "WriteEnumViewToTextStream" + else: + assert False, "Unexpected read-only virtual field type {}".format( + field_ir.read_transform.type.which_type + ) + + value_is_ok = _generate_validator_expression_for(field_ir, ir) + declaration = code_template.format_template( + declaration_template, + visibility=_visibility_for_field(field_ir), + name=name, + virtual_view_type_name=virtual_view_type_name, logical_type=logical_type, - destination=destination, - transform=transform, - ) - else: - write_methods = "" - - name = field_ir.name.canonical_name.object_path[-1] - if name.startswith("$"): - name = _cpp_field_name(field_ir.name.name.text) - virtual_view_type_name = "EmbossReservedDollarVirtual{}View".format(name) - else: - virtual_view_type_name = "EmbossReservedVirtual{}View".format( - name_conversion.snake_to_camel(name) + read_subexpressions="".join( + [ + " const auto {} = {};\n".format(subexpr_name, subexpr) + for subexpr_name, subexpr in read_subexpressions.subexprs() + ] + ), + read_value=read_value.rendered, + write_to_text_stream_function=write_to_text_stream_function, + parent_type=enclosing_type_name, + write_methods=write_methods, + value_is_ok=value_is_ok, ) - assert logical_type, "Could not find appropriate C++ type for {}".format( - field_ir.read_transform - ) - if field_ir.read_transform.type.which_type == "integer": - write_to_text_stream_function = "WriteIntegerViewToTextStream" - elif field_ir.read_transform.type.which_type == "boolean": - write_to_text_stream_function = "WriteBooleanViewToTextStream" - elif field_ir.read_transform.type.which_type == "enumeration": - write_to_text_stream_function = "WriteEnumViewToTextStream" - else: - assert False, "Unexpected read-only virtual field type {}".format( - field_ir.read_transform.type.which_type + definition = code_template.format_template( + definition_template, + name=name, + virtual_view_type_name=virtual_view_type_name, + logical_type=logical_type, + read_value=read_value.rendered, + parent_type=enclosing_type_name, + field_exists=field_exists.rendered, ) - - value_is_ok = _generate_validator_expression_for(field_ir, ir) - declaration = code_template.format_template( - declaration_template, - visibility=_visibility_for_field(field_ir), - name=name, - virtual_view_type_name=virtual_view_type_name, - logical_type=logical_type, - read_subexpressions="".join([ - " const auto {} = {};\n".format(subexpr_name, subexpr) - for subexpr_name, subexpr in read_subexpressions.subexprs() - ]), - read_value=read_value.rendered, - write_to_text_stream_function=write_to_text_stream_function, - parent_type=enclosing_type_name, - write_methods=write_methods, - value_is_ok=value_is_ok, - ) - definition = code_template.format_template( - definition_template, - name=name, - virtual_view_type_name=virtual_view_type_name, - logical_type=logical_type, - read_value=read_value.rendered, - parent_type=enclosing_type_name, - field_exists=field_exists.rendered, - ) - return "", declaration, definition + return "", declaration, definition def _generate_validator_type_for(enclosing_type_name, field_ir, ir): - """Returns a validator type name and definition for the given field.""" - result_expression = _generate_custom_validator_expression_for(field_ir, ir) - if result_expression is None: - return "::emboss::support::AllValuesAreOk", "" - - field_name = field_ir.name.canonical_name.object_path[-1] - validator_type_name = "EmbossReservedValidatorFor{}".format( - name_conversion.snake_to_camel(field_name) - ) - qualified_validator_type_name = "{}::{}".format( - enclosing_type_name, validator_type_name - ) - - validator_declaration = code_template.format_template( - _TEMPLATES.structure_field_validator, - name=validator_type_name, - expression=result_expression, - ) - validator_declaration = _wrap_in_namespace( - validator_declaration, [enclosing_type_name] - ) - return qualified_validator_type_name, validator_declaration + """Returns a validator type name and definition for the given field.""" + result_expression = _generate_custom_validator_expression_for(field_ir, ir) + if result_expression is None: + return "::emboss::support::AllValuesAreOk", "" + + field_name = field_ir.name.canonical_name.object_path[-1] + validator_type_name = "EmbossReservedValidatorFor{}".format( + name_conversion.snake_to_camel(field_name) + ) + qualified_validator_type_name = "{}::{}".format( + enclosing_type_name, validator_type_name + ) + + validator_declaration = code_template.format_template( + _TEMPLATES.structure_field_validator, + name=validator_type_name, + expression=result_expression, + ) + validator_declaration = _wrap_in_namespace( + validator_declaration, [enclosing_type_name] + ) + return qualified_validator_type_name, validator_declaration def _generate_structure_physical_field_methods( enclosing_type_name, field_ir, ir, parent_addressable_unit ): - """Generates C++ code for methods for a single physical field. - - Arguments: - enclosing_type_name: The text name of the enclosing type. - field_ir: The IR for the field to generate methods for. - ir: The full IR for the module. - parent_addressable_unit: The addressable unit (BIT or BYTE) of the enclosing - structure. - - Returns: - A tuple of (declarations, definitions). The declarations can be inserted - into the class definition for the enclosing type's View. Any definitions - should be placed after the class definition. These are separated to satisfy - C++'s declaration-before-use requirements. - """ - validator_type, validator_declaration = _generate_validator_type_for( - enclosing_type_name, field_ir, ir - ) - - type_reader, unused_parameter_types, parameter_expressions = ( - _get_cpp_type_reader_of_field( - field_ir, ir, "Storage", validator_type, parent_addressable_unit - ) - ) - - field_name = field_ir.name.canonical_name.object_path[-1] - - subexpressions = _SubexpressionStore("emboss_reserved_local_subexpr_") - parameter_values = [] - parameters_known = [] - for parameter in parameter_expressions: - parameter_cpp_expr = _render_expression( - parameter, ir, subexpressions=subexpressions + """Generates C++ code for methods for a single physical field. + + Arguments: + enclosing_type_name: The text name of the enclosing type. + field_ir: The IR for the field to generate methods for. + ir: The full IR for the module. + parent_addressable_unit: The addressable unit (BIT or BYTE) of the enclosing + structure. + + Returns: + A tuple of (declarations, definitions). The declarations can be inserted + into the class definition for the enclosing type's View. Any definitions + should be placed after the class definition. These are separated to satisfy + C++'s declaration-before-use requirements. + """ + validator_type, validator_declaration = _generate_validator_type_for( + enclosing_type_name, field_ir, ir ) - parameter_values.append( - "{}.ValueOrDefault(), ".format(parameter_cpp_expr.rendered) + + type_reader, unused_parameter_types, parameter_expressions = ( + _get_cpp_type_reader_of_field( + field_ir, ir, "Storage", validator_type, parent_addressable_unit + ) ) - parameters_known.append( - "{}.Known() && ".format(parameter_cpp_expr.rendered) + + field_name = field_ir.name.canonical_name.object_path[-1] + + subexpressions = _SubexpressionStore("emboss_reserved_local_subexpr_") + parameter_values = [] + parameters_known = [] + for parameter in parameter_expressions: + parameter_cpp_expr = _render_expression( + parameter, ir, subexpressions=subexpressions + ) + parameter_values.append( + "{}.ValueOrDefault(), ".format(parameter_cpp_expr.rendered) + ) + parameters_known.append("{}.Known() && ".format(parameter_cpp_expr.rendered)) + parameter_subexpressions = "".join( + [ + " const auto {} = {};\n".format(name, subexpr) + for name, subexpr in subexpressions.subexprs() + ] ) - parameter_subexpressions = "".join([ - " const auto {} = {};\n".format(name, subexpr) - for name, subexpr in subexpressions.subexprs() - ]) - - first_size_and_offset_subexpr = len(subexpressions.subexprs()) - offset = _render_expression( - field_ir.location.start, ir, subexpressions=subexpressions - ).rendered - size = _render_expression( - field_ir.location.size, ir, subexpressions=subexpressions - ).rendered - size_and_offset_subexpressions = "".join([ - " const auto {} = {};\n".format(name, subexpr) - for name, subexpr in subexpressions.subexprs()[ - first_size_and_offset_subexpr: - ] - ]) - - field_alignment, field_offset = _alignment_of_location(field_ir.location) - declaration = code_template.format_template( - _TEMPLATES.structure_single_field_method_declarations, - type_reader=type_reader, - visibility=_visibility_for_field(field_ir), - name=field_name, - ) - definition = code_template.format_template( - _TEMPLATES.structure_single_field_method_definitions, - parent_type=enclosing_type_name, - name=field_name, - type_reader=type_reader, - offset=offset, - size=size, - size_and_offset_subexpressions=size_and_offset_subexpressions, - field_exists=_render_existence_test(field_ir, ir).rendered, - alignment=field_alignment, - parameters_known="".join(parameters_known), - parameter_values="".join(parameter_values), - parameter_subexpressions=parameter_subexpressions, - static_offset=field_offset, - ) - return validator_declaration, declaration, definition + + first_size_and_offset_subexpr = len(subexpressions.subexprs()) + offset = _render_expression( + field_ir.location.start, ir, subexpressions=subexpressions + ).rendered + size = _render_expression( + field_ir.location.size, ir, subexpressions=subexpressions + ).rendered + size_and_offset_subexpressions = "".join( + [ + " const auto {} = {};\n".format(name, subexpr) + for name, subexpr in subexpressions.subexprs()[ + first_size_and_offset_subexpr: + ] + ] + ) + + field_alignment, field_offset = _alignment_of_location(field_ir.location) + declaration = code_template.format_template( + _TEMPLATES.structure_single_field_method_declarations, + type_reader=type_reader, + visibility=_visibility_for_field(field_ir), + name=field_name, + ) + definition = code_template.format_template( + _TEMPLATES.structure_single_field_method_definitions, + parent_type=enclosing_type_name, + name=field_name, + type_reader=type_reader, + offset=offset, + size=size, + size_and_offset_subexpressions=size_and_offset_subexpressions, + field_exists=_render_existence_test(field_ir, ir).rendered, + alignment=field_alignment, + parameters_known="".join(parameters_known), + parameter_values="".join(parameter_values), + parameter_subexpressions=parameter_subexpressions, + static_offset=field_offset, + ) + return validator_declaration, declaration, definition def _render_size_method(fields, ir): - """Renders the Size methods of a struct or bits, using the correct templates. - - Arguments: - fields: The list of fields in the struct or bits. This is used to find the - $size_in_bits or $size_in_bytes virtual field. - ir: The IR to which fields belong. - - Returns: - A string representation of the Size methods, suitable for inclusion in an - Emboss View class. - """ - # The SizeInBytes(), SizeInBits(), and SizeIsKnown() methods just forward to - # the generated IntrinsicSizeIn$_units_$() method, which returns a virtual - # field with Read() and Ok() methods. - # - # TODO(bolms): Remove these shims, rename IntrinsicSizeIn$_units_$ to - # SizeIn$_units_$, and update all callers to the new API. - for field in fields: - if field.name.name.text in ("$size_in_bits", "$size_in_bytes"): - # If the read_transform and existence_condition are constant, then the - # size is constexpr. - if ( - _render_expression(field.read_transform, ir).is_constant - and _render_expression(field.existence_condition, ir).is_constant - ): - template = _TEMPLATES.constant_structure_size_method - else: - template = _TEMPLATES.runtime_structure_size_method - return code_template.format_template( - template, - units="Bits" if field.name.name.text == "$size_in_bits" else "Bytes", - ) - assert False, "Expected a $size_in_bits or $size_in_bytes field." + """Renders the Size methods of a struct or bits, using the correct templates. + + Arguments: + fields: The list of fields in the struct or bits. This is used to find the + $size_in_bits or $size_in_bytes virtual field. + ir: The IR to which fields belong. + + Returns: + A string representation of the Size methods, suitable for inclusion in an + Emboss View class. + """ + # The SizeInBytes(), SizeInBits(), and SizeIsKnown() methods just forward to + # the generated IntrinsicSizeIn$_units_$() method, which returns a virtual + # field with Read() and Ok() methods. + # + # TODO(bolms): Remove these shims, rename IntrinsicSizeIn$_units_$ to + # SizeIn$_units_$, and update all callers to the new API. + for field in fields: + if field.name.name.text in ("$size_in_bits", "$size_in_bytes"): + # If the read_transform and existence_condition are constant, then the + # size is constexpr. + if ( + _render_expression(field.read_transform, ir).is_constant + and _render_expression(field.existence_condition, ir).is_constant + ): + template = _TEMPLATES.constant_structure_size_method + else: + template = _TEMPLATES.runtime_structure_size_method + return code_template.format_template( + template, + units="Bits" if field.name.name.text == "$size_in_bits" else "Bytes", + ) + assert False, "Expected a $size_in_bits or $size_in_bytes field." def _visibility_for_field(field_ir): - """Returns the C++ visibility for field_ir within its parent view.""" - # Generally, the Google style guide for hand-written C++ forbids having - # multiple public: and private: sections, but trying to conform to that bit of - # the style guide would make this file significantly more complex. - # - # Alias fields are generated as simple methods that forward directly to the - # aliased field's method: - # - # auto alias() const -> decltype(parent().child().aliased_subchild()) { - # return parent().child().aliased_subchild(); - # } - # - # Figuring out the return type of `parent().child().aliased_subchild()` is - # quite complex, since there are several levels of template indirection - # involved. It is much easier to just leave it up to the C++ compiler. - # - # Unfortunately, the C++ compiler will complain if `parent()` is not declared - # before `alias()`. If the `parent` field happens to be anonymous, the Google - # style guide would put `parent()`'s declaration after `alias()`'s - # declaration, which causes the C++ compiler to complain that `parent` is - # unknown. - # - # The easy fix to this is just to declare `parent()` before `alias()`, and - # explicitly mark `parent()` as `private` and `alias()` as `public`. - # - # Perhaps surprisingly, this limitation does not apply when `parent()`'s type - # is not yet complete at the point where `alias()` is declared; I believe this - # is because both `parent()` and `alias()` exist in a templated `class`, and - # by the time `parent().child().aliased_subchild()` is actually resolved, the - # compiler is instantiating the class and has the full definitions of all the - # other classes available. - if field_ir.name.is_anonymous: - return "private" - else: - return "public" + """Returns the C++ visibility for field_ir within its parent view.""" + # Generally, the Google style guide for hand-written C++ forbids having + # multiple public: and private: sections, but trying to conform to that bit of + # the style guide would make this file significantly more complex. + # + # Alias fields are generated as simple methods that forward directly to the + # aliased field's method: + # + # auto alias() const -> decltype(parent().child().aliased_subchild()) { + # return parent().child().aliased_subchild(); + # } + # + # Figuring out the return type of `parent().child().aliased_subchild()` is + # quite complex, since there are several levels of template indirection + # involved. It is much easier to just leave it up to the C++ compiler. + # + # Unfortunately, the C++ compiler will complain if `parent()` is not declared + # before `alias()`. If the `parent` field happens to be anonymous, the Google + # style guide would put `parent()`'s declaration after `alias()`'s + # declaration, which causes the C++ compiler to complain that `parent` is + # unknown. + # + # The easy fix to this is just to declare `parent()` before `alias()`, and + # explicitly mark `parent()` as `private` and `alias()` as `public`. + # + # Perhaps surprisingly, this limitation does not apply when `parent()`'s type + # is not yet complete at the point where `alias()` is declared; I believe this + # is because both `parent()` and `alias()` exist in a templated `class`, and + # by the time `parent().child().aliased_subchild()` is actually resolved, the + # compiler is instantiating the class and has the full definitions of all the + # other classes available. + if field_ir.name.is_anonymous: + return "private" + else: + return "public" def _generate_field_indirection(field_ir, parent_type_name, ir): - """Renders a method which forwards to a field's view.""" - rendered_aliased_field = _render_variable( - ir_util.hashable_form_of_field_reference(field_ir.write_method.alias) - ) - declaration = code_template.format_template( - _TEMPLATES.structure_single_field_indirect_method_declarations, - aliased_field=rendered_aliased_field, - visibility=_visibility_for_field(field_ir), - parent_type=parent_type_name, - name=field_ir.name.name.text, - ) - definition = code_template.format_template( - _TEMPLATES.struct_single_field_indirect_method_definitions, - parent_type=parent_type_name, - name=field_ir.name.name.text, - aliased_field=rendered_aliased_field, - field_exists=_render_existence_test(field_ir, ir).rendered, - ) - return "", declaration, definition + """Renders a method which forwards to a field's view.""" + rendered_aliased_field = _render_variable( + ir_util.hashable_form_of_field_reference(field_ir.write_method.alias) + ) + declaration = code_template.format_template( + _TEMPLATES.structure_single_field_indirect_method_declarations, + aliased_field=rendered_aliased_field, + visibility=_visibility_for_field(field_ir), + parent_type=parent_type_name, + name=field_ir.name.name.text, + ) + definition = code_template.format_template( + _TEMPLATES.struct_single_field_indirect_method_definitions, + parent_type=parent_type_name, + name=field_ir.name.name.text, + aliased_field=rendered_aliased_field, + field_exists=_render_existence_test(field_ir, ir).rendered, + ) + return "", declaration, definition def _generate_subtype_definitions(type_ir, ir, config: Config): - """Generates C++ code for subtypes of type_ir.""" - subtype_bodies = [] - subtype_forward_declarations = [] - subtype_method_definitions = [] - type_name = type_ir.name.name.text - for subtype in type_ir.subtype: - inner_defs = _generate_type_definition(subtype, ir, config) - subtype_forward_declaration, subtype_body, subtype_methods = inner_defs - subtype_forward_declarations.append(subtype_forward_declaration) - subtype_bodies.append(subtype_body) - subtype_method_definitions.append(subtype_methods) - wrapped_forward_declarations = _wrap_in_namespace( - "\n".join(subtype_forward_declarations), [type_name] - ) - wrapped_bodies = _wrap_in_namespace("\n".join(subtype_bodies), [type_name]) - wrapped_method_definitions = _wrap_in_namespace( - "\n".join(subtype_method_definitions), [type_name] - ) - return ( - wrapped_bodies, - wrapped_forward_declarations, - wrapped_method_definitions, - ) + """Generates C++ code for subtypes of type_ir.""" + subtype_bodies = [] + subtype_forward_declarations = [] + subtype_method_definitions = [] + type_name = type_ir.name.name.text + for subtype in type_ir.subtype: + inner_defs = _generate_type_definition(subtype, ir, config) + subtype_forward_declaration, subtype_body, subtype_methods = inner_defs + subtype_forward_declarations.append(subtype_forward_declaration) + subtype_bodies.append(subtype_body) + subtype_method_definitions.append(subtype_methods) + wrapped_forward_declarations = _wrap_in_namespace( + "\n".join(subtype_forward_declarations), [type_name] + ) + wrapped_bodies = _wrap_in_namespace("\n".join(subtype_bodies), [type_name]) + wrapped_method_definitions = _wrap_in_namespace( + "\n".join(subtype_method_definitions), [type_name] + ) + return (wrapped_bodies, wrapped_forward_declarations, wrapped_method_definitions) def _cpp_field_name(name): - """Returns the C++ name for the given field name.""" - if name.startswith("$"): - dollar_field_names = { - "$size_in_bits": "IntrinsicSizeInBits", - "$size_in_bytes": "IntrinsicSizeInBytes", - "$max_size_in_bits": "MaxSizeInBits", - "$min_size_in_bits": "MinSizeInBits", - "$max_size_in_bytes": "MaxSizeInBytes", - "$min_size_in_bytes": "MinSizeInBytes", - } - return dollar_field_names[name] - else: - return name + """Returns the C++ name for the given field name.""" + if name.startswith("$"): + dollar_field_names = { + "$size_in_bits": "IntrinsicSizeInBits", + "$size_in_bytes": "IntrinsicSizeInBytes", + "$max_size_in_bits": "MaxSizeInBits", + "$min_size_in_bits": "MinSizeInBits", + "$max_size_in_bytes": "MaxSizeInBytes", + "$min_size_in_bytes": "MinSizeInBytes", + } + return dollar_field_names[name] + else: + return name def _generate_structure_definition(type_ir, ir, config: Config): - """Generates C++ for an Emboss structure (struct or bits). - - Arguments: - type_ir: The IR for the struct definition. - ir: The full IR; used for type lookups. - config: The code generation configuration to use. - - Returns: - A tuple of: (forward declaration for classes, class bodies, method - bodies), suitable for insertion into the appropriate places in the - generated header. - """ - subtype_bodies, subtype_forward_declarations, subtype_method_definitions = ( - _generate_subtype_definitions(type_ir, ir, config) - ) - type_name = type_ir.name.name.text - field_helper_type_definitions = [] - field_method_declarations = [] - field_method_definitions = [] - virtual_field_type_definitions = [] - decode_field_clauses = [] - write_field_clauses = [] - ok_method_clauses = [] - equals_method_clauses = [] - unchecked_equals_method_clauses = [] - enum_using_statements = [] - parameter_fields = [] - constructor_parameters = [] - forwarded_parameters = [] - parameter_initializers = [] - parameter_copy_initializers = [] - units = {1: "Bits", 8: "Bytes"}[type_ir.addressable_unit] - - for subtype in type_ir.subtype: - if subtype.has_field("enumeration"): - enum_using_statements.append( - code_template.format_template( - _TEMPLATES.enum_using_statement, - component=_get_fully_qualified_name( - subtype.name.canonical_name, ir - ), - name=_get_unqualified_name(subtype.name.canonical_name), - ) - ) - - # TODO(bolms): Reorder parameter fields to optimize packing in the view type. - for parameter in type_ir.runtime_parameter: - parameter_type = _cpp_basic_type_for_expression_type(parameter.type, ir) - parameter_name = parameter.name.name.text - parameter_fields.append("{} {}_;".format(parameter_type, parameter_name)) - constructor_parameters.append( - "{} {}, ".format(parameter_type, parameter_name) - ) - forwarded_parameters.append( - "::std::forward({}),".format(parameter_type, parameter_name) - ) - parameter_initializers.append(", {0}_({0})".format(parameter_name)) - parameter_copy_initializers.append( - ", {0}_(emboss_reserved_local_other.{0}_)".format(parameter_name) + """Generates C++ for an Emboss structure (struct or bits). + + Arguments: + type_ir: The IR for the struct definition. + ir: The full IR; used for type lookups. + config: The code generation configuration to use. + + Returns: + A tuple of: (forward declaration for classes, class bodies, method + bodies), suitable for insertion into the appropriate places in the + generated header. + """ + subtype_bodies, subtype_forward_declarations, subtype_method_definitions = ( + _generate_subtype_definitions(type_ir, ir, config) ) + type_name = type_ir.name.name.text + field_helper_type_definitions = [] + field_method_declarations = [] + field_method_definitions = [] + virtual_field_type_definitions = [] + decode_field_clauses = [] + write_field_clauses = [] + ok_method_clauses = [] + equals_method_clauses = [] + unchecked_equals_method_clauses = [] + enum_using_statements = [] + parameter_fields = [] + constructor_parameters = [] + forwarded_parameters = [] + parameter_initializers = [] + parameter_copy_initializers = [] + units = {1: "Bits", 8: "Bytes"}[type_ir.addressable_unit] + + for subtype in type_ir.subtype: + if subtype.has_field("enumeration"): + enum_using_statements.append( + code_template.format_template( + _TEMPLATES.enum_using_statement, + component=_get_fully_qualified_name( + subtype.name.canonical_name, ir + ), + name=_get_unqualified_name(subtype.name.canonical_name), + ) + ) - field_method_declarations.append( - code_template.format_template( - _TEMPLATES.structure_single_parameter_field_method_declarations, - name=parameter_name, - logical_type=parameter_type, + # TODO(bolms): Reorder parameter fields to optimize packing in the view type. + for parameter in type_ir.runtime_parameter: + parameter_type = _cpp_basic_type_for_expression_type(parameter.type, ir) + parameter_name = parameter.name.name.text + parameter_fields.append("{} {}_;".format(parameter_type, parameter_name)) + constructor_parameters.append("{} {}, ".format(parameter_type, parameter_name)) + forwarded_parameters.append( + "::std::forward({}),".format(parameter_type, parameter_name) ) - ) - # TODO(bolms): Should parameters appear in text format? - equals_method_clauses.append( - code_template.format_template( - _TEMPLATES.equals_method_test, field=parameter_name + "()" + parameter_initializers.append(", {0}_({0})".format(parameter_name)) + parameter_copy_initializers.append( + ", {0}_(emboss_reserved_local_other.{0}_)".format(parameter_name) ) - ) - unchecked_equals_method_clauses.append( - code_template.format_template( - _TEMPLATES.unchecked_equals_method_test, field=parameter_name + "()" + + field_method_declarations.append( + code_template.format_template( + _TEMPLATES.structure_single_parameter_field_method_declarations, + name=parameter_name, + logical_type=parameter_type, + ) ) + # TODO(bolms): Should parameters appear in text format? + equals_method_clauses.append( + code_template.format_template( + _TEMPLATES.equals_method_test, field=parameter_name + "()" + ) + ) + unchecked_equals_method_clauses.append( + code_template.format_template( + _TEMPLATES.unchecked_equals_method_test, field=parameter_name + "()" + ) + ) + if type_ir.runtime_parameter: + flag_name = "parameters_initialized_" + parameter_copy_initializers.append( + ", {0}(emboss_reserved_local_other.{0})".format(flag_name) + ) + parameters_initialized_flag = "bool {} = false;".format(flag_name) + initialize_parameters_initialized_true = ", {}(true)".format(flag_name) + parameter_checks = ["if (!{}) return false;".format(flag_name)] + else: + parameters_initialized_flag = "" + initialize_parameters_initialized_true = "" + parameter_checks = [""] + + # Pass 1: Count subexpression usage. + ok_usage_counter = _UsageCountingStore() + for field_index in type_ir.structure.fields_in_dependency_order: + field = type_ir.structure.field[field_index] + _render_existence_test(field, ir, ok_usage_counter) + + # Pass 2: Generate code using smart store. + ok_subexpressions = _SmartSubexpressionStore( + "emboss_reserved_local_ok_subexpr_", ok_usage_counter.counts ) - if type_ir.runtime_parameter: - flag_name = "parameters_initialized_" - parameter_copy_initializers.append( - ", {0}(emboss_reserved_local_other.{0})".format(flag_name) - ) - parameters_initialized_flag = "bool {} = false;".format(flag_name) - initialize_parameters_initialized_true = ", {}(true)".format(flag_name) - parameter_checks = ["if (!{}) return false;".format(flag_name)] - else: - parameters_initialized_flag = "" - initialize_parameters_initialized_true = "" - parameter_checks = [""] - - # Pass 1: Count subexpression usage. - ok_usage_counter = _UsageCountingStore() - for field_index in type_ir.structure.fields_in_dependency_order: - field = type_ir.structure.field[field_index] - _render_existence_test(field, ir, ok_usage_counter) - - # Pass 2: Generate code using smart store. - ok_subexpressions = _SmartSubexpressionStore( - "emboss_reserved_local_ok_subexpr_", ok_usage_counter.counts - ) - for field_index in type_ir.structure.fields_in_dependency_order: - field = type_ir.structure.field[field_index] - helper_types, declaration, definition = _generate_structure_field_methods( - type_name, field, ir, type_ir.addressable_unit - ) - field_helper_type_definitions.append(helper_types) - field_method_definitions.append(definition) - ok_method_clauses.append( - code_template.format_template( - _TEMPLATES.ok_method_test, - field=_cpp_field_name(field.name.name.text) + "()", - existence_condition=_render_existence_test( - field, ir, subexpressions=ok_subexpressions - ).rendered, + for field_index in type_ir.structure.fields_in_dependency_order: + field = type_ir.structure.field[field_index] + helper_types, declaration, definition = _generate_structure_field_methods( + type_name, field, ir, type_ir.addressable_unit + ) + field_helper_type_definitions.append(helper_types) + field_method_definitions.append(definition) + ok_method_clauses.append( + code_template.format_template( + _TEMPLATES.ok_method_test, + field=_cpp_field_name(field.name.name.text) + "()", + existence_condition=_render_existence_test( + field, ir, subexpressions=ok_subexpressions + ).rendered, + ) ) + if not ir_util.field_is_virtual(field): + # Virtual fields do not participate in equality tests -- they are equal by + # definition. + equals_method_clauses.append( + code_template.format_template( + _TEMPLATES.equals_method_test, field=field.name.name.text + "()" + ) + ) + unchecked_equals_method_clauses.append( + code_template.format_template( + _TEMPLATES.unchecked_equals_method_test, + field=field.name.name.text + "()", + ) + ) + field_method_declarations.append(declaration) + if not field.name.is_anonymous and not ir_util.field_is_read_only(field): + # As above, read-only fields cannot be decoded from text format. + decode_field_clauses.append( + code_template.format_template( + _TEMPLATES.decode_field, + field_name=field.name.canonical_name.object_path[-1], + ) + ) + text_output_attr = ir_util.get_attribute(field.attribute, "text_output") + if not text_output_attr or text_output_attr.string_constant == "Emit": + if ir_util.field_is_read_only(field): + write_field_template = _TEMPLATES.write_read_only_field_to_text_stream + else: + write_field_template = _TEMPLATES.write_field_to_text_stream + write_field_clauses.append( + code_template.format_template( + write_field_template, + field_name=field.name.canonical_name.object_path[-1], + ) + ) + + requires_attr = ir_util.get_attribute(type_ir.attribute, "requires") + if requires_attr is not None: + requires_clause = _render_expression( + requires_attr.expression, ir, _DirectFieldRenderer() + ).rendered + requires_check = ( + " if (!({}).ValueOr(false))\n" " return false;" + ).format(requires_clause) + else: + requires_check = "" + + if config.include_enum_traits: + text_stream_methods = code_template.format_template( + _TEMPLATES.struct_text_stream, + decode_fields="\n".join(decode_field_clauses), + write_fields="\n".join(write_field_clauses), + ) + else: + text_stream_methods = "" + + class_forward_declarations = code_template.format_template( + _TEMPLATES.structure_view_declaration, name=type_name ) - if not ir_util.field_is_virtual(field): - # Virtual fields do not participate in equality tests -- they are equal by - # definition. - equals_method_clauses.append( - code_template.format_template( - _TEMPLATES.equals_method_test, field=field.name.name.text + "()" - ) - ) - unchecked_equals_method_clauses.append( - code_template.format_template( - _TEMPLATES.unchecked_equals_method_test, - field=field.name.name.text + "()", - ) - ) - field_method_declarations.append(declaration) - if not field.name.is_anonymous and not ir_util.field_is_read_only(field): - # As above, read-only fields cannot be decoded from text format. - decode_field_clauses.append( - code_template.format_template( - _TEMPLATES.decode_field, - field_name=field.name.canonical_name.object_path[-1], - ) - ) - text_output_attr = ir_util.get_attribute(field.attribute, "text_output") - if not text_output_attr or text_output_attr.string_constant == "Emit": - if ir_util.field_is_read_only(field): - write_field_template = _TEMPLATES.write_read_only_field_to_text_stream - else: - write_field_template = _TEMPLATES.write_field_to_text_stream - write_field_clauses.append( - code_template.format_template( - write_field_template, - field_name=field.name.canonical_name.object_path[-1], - ) - ) - - requires_attr = ir_util.get_attribute(type_ir.attribute, "requires") - if requires_attr is not None: - requires_clause = _render_expression( - requires_attr.expression, ir, _DirectFieldRenderer() - ).rendered - requires_check = ( - " if (!({}).ValueOr(false))\n return false;" - ).format(requires_clause) - else: - requires_check = "" - - if config.include_enum_traits: - text_stream_methods = code_template.format_template( - _TEMPLATES.struct_text_stream, - decode_fields="\n".join(decode_field_clauses), - write_fields="\n".join(write_field_clauses), + class_bodies = code_template.format_template( + _TEMPLATES.structure_view_class, + name=type_ir.name.canonical_name.object_path[-1], + size_method=_render_size_method(type_ir.structure.field, ir), + field_method_declarations="".join(field_method_declarations), + field_ok_checks="\n".join(ok_method_clauses), + ok_subexpressions="".join( + [ + " const auto {} = {};\n".format(name, subexpr) + for name, subexpr in ok_subexpressions.subexprs() + ] + ), + parameter_ok_checks="\n".join(parameter_checks), + requires_check=requires_check, + equals_method_body="\n".join(equals_method_clauses), + unchecked_equals_method_body="\n".join(unchecked_equals_method_clauses), + enum_usings="\n".join(enum_using_statements), + text_stream_methods=text_stream_methods, + parameter_fields="\n".join(parameter_fields), + constructor_parameters="".join(constructor_parameters), + forwarded_parameters="".join(forwarded_parameters), + parameter_initializers="\n".join(parameter_initializers), + parameter_copy_initializers="\n".join(parameter_copy_initializers), + parameters_initialized_flag=parameters_initialized_flag, + initialize_parameters_initialized_true=(initialize_parameters_initialized_true), + units=units, + ) + method_definitions = "\n".join(field_method_definitions) + early_virtual_field_types = "\n".join(virtual_field_type_definitions) + all_field_helper_type_definitions = "\n".join(field_helper_type_definitions) + return ( + early_virtual_field_types + + subtype_forward_declarations + + class_forward_declarations, + all_field_helper_type_definitions + subtype_bodies + class_bodies, + subtype_method_definitions + method_definitions, ) - else: - text_stream_methods = "" - - class_forward_declarations = code_template.format_template( - _TEMPLATES.structure_view_declaration, name=type_name - ) - class_bodies = code_template.format_template( - _TEMPLATES.structure_view_class, - name=type_ir.name.canonical_name.object_path[-1], - size_method=_render_size_method(type_ir.structure.field, ir), - field_method_declarations="".join(field_method_declarations), - field_ok_checks="\n".join(ok_method_clauses), - ok_subexpressions="".join([ - " const auto {} = {};\n".format(name, subexpr) - for name, subexpr in ok_subexpressions.subexprs() - ]), - parameter_ok_checks="\n".join(parameter_checks), - requires_check=requires_check, - equals_method_body="\n".join(equals_method_clauses), - unchecked_equals_method_body="\n".join(unchecked_equals_method_clauses), - enum_usings="\n".join(enum_using_statements), - text_stream_methods=text_stream_methods, - parameter_fields="\n".join(parameter_fields), - constructor_parameters="".join(constructor_parameters), - forwarded_parameters="".join(forwarded_parameters), - parameter_initializers="\n".join(parameter_initializers), - parameter_copy_initializers="\n".join(parameter_copy_initializers), - parameters_initialized_flag=parameters_initialized_flag, - initialize_parameters_initialized_true=( - initialize_parameters_initialized_true - ), - units=units, - ) - method_definitions = "\n".join(field_method_definitions) - early_virtual_field_types = "\n".join(virtual_field_type_definitions) - all_field_helper_type_definitions = "\n".join(field_helper_type_definitions) - return ( - early_virtual_field_types - + subtype_forward_declarations - + class_forward_declarations, - all_field_helper_type_definitions + subtype_bodies + class_bodies, - subtype_method_definitions + method_definitions, - ) def _split_enum_case_values_into_spans(enum_case_value): - """Yields spans containing each enum case in an enum_case attribute value. - - Arguments: - enum_case_value: the value of the `enum_case` attribute to be parsed. - - Returns: - An iterator over spans, where each span covers one enum case name. - Each span is a half-open range of the form [start, end), which is the - start and end position relative to the beginning of the enum_case_value - string. The name can be retrieved with `enum_case_value[start:end]`. - - To keep the grammar of this attribute simple, this only splits on - delimiters and trims whitespace for each case. - - Example: 'SHOUTY_CASE, kCamelCase' -> [(0, 11), (13, 23)] - """ - # Scan the string from left to right, finding commas and trimming whitespace. - # This is essentially equivalent to (x.trim() fror x in str.split(',')) - # except that this yields spans within the string rather than the strings - # themselves, and no span is yielded for a trailing comma. - start, end = 0, len(enum_case_value) - while start <= end: - # Find a ',' delimiter to split on - delimiter = enum_case_value.find(",", start, end) - if delimiter < 0: - delimiter = end - - substr_start = start - substr_end = delimiter - - # Drop leading whitespace - while substr_start < substr_end and enum_case_value[substr_start].isspace(): - substr_start += 1 - # Drop trailing whitespace - while ( - substr_start < substr_end and enum_case_value[substr_end - 1].isspace() - ): - substr_end -= 1 - - # Skip a trailing comma - if substr_start == end and start != 0: - break - - yield substr_start, substr_end - start = delimiter + 1 + """Yields spans containing each enum case in an enum_case attribute value. + + Arguments: + enum_case_value: the value of the `enum_case` attribute to be parsed. + + Returns: + An iterator over spans, where each span covers one enum case name. + Each span is a half-open range of the form [start, end), which is the + start and end position relative to the beginning of the enum_case_value + string. The name can be retrieved with `enum_case_value[start:end]`. + + To keep the grammar of this attribute simple, this only splits on + delimiters and trims whitespace for each case. + + Example: 'SHOUTY_CASE, kCamelCase' -> [(0, 11), (13, 23)]""" + # Scan the string from left to right, finding commas and trimming whitespace. + # This is essentially equivalent to (x.trim() fror x in str.split(',')) + # except that this yields spans within the string rather than the strings + # themselves, and no span is yielded for a trailing comma. + start, end = 0, len(enum_case_value) + while start <= end: + # Find a ',' delimiter to split on + delimiter = enum_case_value.find(",", start, end) + if delimiter < 0: + delimiter = end + + substr_start = start + substr_end = delimiter + + # Drop leading whitespace + while substr_start < substr_end and enum_case_value[substr_start].isspace(): + substr_start += 1 + # Drop trailing whitespace + while substr_start < substr_end and enum_case_value[substr_end - 1].isspace(): + substr_end -= 1 + + # Skip a trailing comma + if substr_start == end and start != 0: + break + + yield substr_start, substr_end + start = delimiter + 1 def _split_enum_case_values(enum_case_value): - """Returns all enum cases in an enum case value. + """Returns all enum cases in an enum case value. - Arguments: - enum_case_value: the value of the enum case attribute to parse. + Arguments: + enum_case_value: the value of the enum case attribute to parse. - Returns: - All enum case names from `enum_case_value`. + Returns: + All enum case names from `enum_case_value`. - Example: 'SHOUTY_CASE, kCamelCase' -> ['SHOUTY_CASE', 'kCamelCase'] - """ - return [ - enum_case_value[start:end] - for start, end in _split_enum_case_values_into_spans(enum_case_value) - ] + Example: 'SHOUTY_CASE, kCamelCase' -> ['SHOUTY_CASE', 'kCamelCase']""" + return [ + enum_case_value[start:end] + for start, end in _split_enum_case_values_into_spans(enum_case_value) + ] def _get_enum_value_names(enum_value): - """Determines one or more enum names based on attributes.""" - cases = ["SHOUTY_CASE"] - name = enum_value.name.name.text - if enum_case := ir_util.get_attribute( - enum_value.attribute, attributes.Attribute.ENUM_CASE - ): - cases = _split_enum_case_values(enum_case.string_constant.text) - return [ - name_conversion.convert_case("SHOUTY_CASE", case, name) for case in cases - ] + """Determines one or more enum names based on attributes.""" + cases = ["SHOUTY_CASE"] + name = enum_value.name.name.text + if enum_case := ir_util.get_attribute( + enum_value.attribute, attributes.Attribute.ENUM_CASE + ): + cases = _split_enum_case_values(enum_case.string_constant.text) + return [name_conversion.convert_case("SHOUTY_CASE", case, name) for case in cases] def _generate_enum_definition(type_ir, include_traits=True): - """Generates C++ for an Emboss enum.""" - enum_values = [] - enum_from_string_statements = [] - string_from_enum_statements = [] - enum_is_known_statements = [] - previously_seen_numeric_values = set() - max_bits = ir_util.get_integer_attribute(type_ir.attribute, "maximum_bits") - is_signed = ir_util.get_boolean_attribute(type_ir.attribute, "is_signed") - enum_type = _cpp_integer_type_for_enum(max_bits, is_signed) - for value in type_ir.enumeration.value: - numeric_value = ir_util.constant_value(value.value) - enum_value_names = _get_enum_value_names(value) - - for enum_value_name in enum_value_names: - enum_values.append( - code_template.format_template( - _TEMPLATES.enum_value, - name=enum_value_name, - value=_render_integer(numeric_value), - ) - ) - if include_traits: - enum_from_string_statements.append( - code_template.format_template( - _TEMPLATES.enum_from_name_case, - enum=type_ir.name.name.text, - value=enum_value_name, - name=value.name.name.text, + """Generates C++ for an Emboss enum.""" + enum_values = [] + enum_from_string_statements = [] + string_from_enum_statements = [] + enum_is_known_statements = [] + previously_seen_numeric_values = set() + max_bits = ir_util.get_integer_attribute(type_ir.attribute, "maximum_bits") + is_signed = ir_util.get_boolean_attribute(type_ir.attribute, "is_signed") + enum_type = _cpp_integer_type_for_enum(max_bits, is_signed) + for value in type_ir.enumeration.value: + numeric_value = ir_util.constant_value(value.value) + enum_value_names = _get_enum_value_names(value) + + for enum_value_name in enum_value_names: + enum_values.append( + code_template.format_template( + _TEMPLATES.enum_value, + name=enum_value_name, + value=_render_integer(numeric_value), + ) ) - ) - - if numeric_value not in previously_seen_numeric_values: - string_from_enum_statements.append( - code_template.format_template( - _TEMPLATES.name_from_enum_case, - enum=type_ir.name.name.text, - value=enum_value_name, - name=value.name.name.text, - ) - ) - - enum_is_known_statements.append( - code_template.format_template( - _TEMPLATES.enum_is_known_case, - enum=type_ir.name.name.text, - name=enum_value_name, - ) - ) - previously_seen_numeric_values.add(numeric_value) - - declaration = code_template.format_template( - _TEMPLATES.enum_declaration, - enum=type_ir.name.name.text, - enum_type=enum_type, - ) - definition = code_template.format_template( - _TEMPLATES.enum_definition, - enum=type_ir.name.name.text, - enum_type=enum_type, - enum_values="".join(enum_values), - ) - if include_traits: - definition += code_template.format_template( - _TEMPLATES.enum_traits, + if include_traits: + enum_from_string_statements.append( + code_template.format_template( + _TEMPLATES.enum_from_name_case, + enum=type_ir.name.name.text, + value=enum_value_name, + name=value.name.name.text, + ) + ) + + if numeric_value not in previously_seen_numeric_values: + string_from_enum_statements.append( + code_template.format_template( + _TEMPLATES.name_from_enum_case, + enum=type_ir.name.name.text, + value=enum_value_name, + name=value.name.name.text, + ) + ) + + enum_is_known_statements.append( + code_template.format_template( + _TEMPLATES.enum_is_known_case, + enum=type_ir.name.name.text, + name=enum_value_name, + ) + ) + previously_seen_numeric_values.add(numeric_value) + + declaration = code_template.format_template( + _TEMPLATES.enum_declaration, enum=type_ir.name.name.text, enum_type=enum_type + ) + definition = code_template.format_template( + _TEMPLATES.enum_definition, enum=type_ir.name.name.text, - enum_from_name_cases="\n".join(enum_from_string_statements), - name_from_enum_cases="\n".join(string_from_enum_statements), - enum_is_known_cases="\n".join(enum_is_known_statements), + enum_type=enum_type, + enum_values="".join(enum_values), ) + if include_traits: + definition += code_template.format_template( + _TEMPLATES.enum_traits, + enum=type_ir.name.name.text, + enum_from_name_cases="\n".join(enum_from_string_statements), + name_from_enum_cases="\n".join(string_from_enum_statements), + enum_is_known_cases="\n".join(enum_is_known_statements), + ) - return (declaration, definition, "") + return (declaration, definition, "") def _generate_type_definition(type_ir, ir, config: Config): - """Generates C++ for an Emboss type.""" - if type_ir.has_field("structure"): - return _generate_structure_definition(type_ir, ir, config) - elif type_ir.has_field("enumeration"): - return _generate_enum_definition(type_ir, config.include_enum_traits) - elif type_ir.has_field("external"): - # TODO(bolms): This should probably generate an #include. - return "", "", "" - else: - # TODO(bolms): provide error message instead of ICE - assert False, "Unknown type {}".format(type_ir) + """Generates C++ for an Emboss type.""" + if type_ir.has_field("structure"): + return _generate_structure_definition(type_ir, ir, config) + elif type_ir.has_field("enumeration"): + return _generate_enum_definition(type_ir, config.include_enum_traits) + elif type_ir.has_field("external"): + # TODO(bolms): This should probably generate an #include. + return "", "", "" + else: + # TODO(bolms): provide error message instead of ICE + assert False, "Unknown type {}".format(type_ir) def _generate_header_guard(file_path): - # TODO(bolms): Make this configurable. - header_path = file_path + ".h" - uppercased_path = header_path.upper() - no_punctuation_path = re.sub(r"[^A-Za-z0-9_]", "_", uppercased_path) - suffixed_path = no_punctuation_path + "_" - no_double_underscore_path = re.sub(r"__+", "_", suffixed_path) - return no_double_underscore_path + # TODO(bolms): Make this configurable. + header_path = file_path + ".h" + uppercased_path = header_path.upper() + no_punctuation_path = re.sub(r"[^A-Za-z0-9_]", "_", uppercased_path) + suffixed_path = no_punctuation_path + "_" + no_double_underscore_path = re.sub(r"__+", "_", suffixed_path) + return no_double_underscore_path def _add_missing_enum_case_attribute_on_enum_value(enum_value, defaults): - """Adds an `enum_case` attribute if there isn't one but a default is set.""" - if ( - ir_util.get_attribute( - enum_value.attribute, attributes.Attribute.ENUM_CASE - ) - is None - ): - if attributes.Attribute.ENUM_CASE in defaults: - enum_value.attribute.extend([defaults[attributes.Attribute.ENUM_CASE]]) + """Adds an `enum_case` attribute if there isn't one but a default is set.""" + if ( + ir_util.get_attribute(enum_value.attribute, attributes.Attribute.ENUM_CASE) + is None + ): + if attributes.Attribute.ENUM_CASE in defaults: + enum_value.attribute.extend([defaults[attributes.Attribute.ENUM_CASE]]) def _propagate_defaults(ir, targets, ancestors, add_fn): - """Propagates default values - - Traverses the IR to propagate default values to target nodes. - - Arguments: - ir: The IR to process. - targets: A list of target IR types to add attributes to. - ancestors: Ancestor types which may contain the default values. - add_fn: Function to add the attribute. May use any parameter available in - fast_traverse_ir_top_down actions as well as `defaults` containing the - default attributes set by ancestors. - - Returns: - None - """ - traverse_ir.fast_traverse_ir_top_down( - ir, - targets, - add_fn, - incidental_actions={ - ancestor: attribute_util.gather_default_attributes - for ancestor in ancestors - }, - parameters={"defaults": {}}, - ) + """Propagates default values + + Traverses the IR to propagate default values to target nodes. + + Arguments: + ir: The IR to process. + targets: A list of target IR types to add attributes to. + ancestors: Ancestor types which may contain the default values. + add_fn: Function to add the attribute. May use any parameter available + in fast_traverse_ir_top_down actions as well as `defaults` + containing the + default attributes set by ancestors. + + Returns: + None + """ + traverse_ir.fast_traverse_ir_top_down( + ir, + targets, + add_fn, + incidental_actions={ + ancestor: attribute_util.gather_default_attributes for ancestor in ancestors + }, + parameters={"defaults": {}}, + ) def _offset_source_location_column(source_location, offset): - """Adds offsets from the start column of the supplied source location. - - Arguments: - source_location: the initial source location - offset: a tuple of (start, end), which are the offsets relative to - source_location.start.column to set the new start.column and end.column. - - Returns: - A new source location with all of the same properties as the provided - source location, but with the columns modified by offsets from the - original start column. - """ - - new_location = source_location._replace( - start=source_location.start._replace( - column=source_location.start.column + offset[0] - ), - end=source_location.start._replace( - column=source_location.start.column + offset[1] - ), - ) + """Adds offsets from the start column of the supplied source location. + + Arguments: + source_location: the initial source location + offset: a tuple of (start, end), which are the offsets relative to + source_location.start.column to set the new start.column and + end.column. + + Returns: + A new source location with all of the same properties as the provided + source location, but with the columns modified by offsets from the + original start column. + """ + + new_location = source_location._replace( + start=source_location.start._replace( + column=source_location.start.column + offset[0] + ), + end=source_location.start._replace( + column=source_location.start.column + offset[1] + ), + ) - return new_location + return new_location def _verify_namespace_attribute(attr, source_file_name, errors): - if attr.name.text != attributes.Attribute.NAMESPACE: - return - namespace_value = ir_data_utils.reader(attr).value.string_constant - if not re.fullmatch(_NS_RE, namespace_value.text): - if re.fullmatch(_NS_EMPTY_RE, namespace_value.text): - errors.append([ - error.error( - source_file_name, - namespace_value.source_location, - "Empty namespace value is not allowed.", - ) - ]) - elif re.fullmatch(_NS_GLOBAL_RE, namespace_value.text): - errors.append([ - error.error( - source_file_name, - namespace_value.source_location, - "Global namespace is not allowed.", - ) - ]) - else: - errors.append([ - error.error( - source_file_name, - namespace_value.source_location, - 'Invalid namespace, must be a valid C++ namespace, such as "abc",' - ' "abc::def", or "::abc::def::ghi" (ISO/IEC 14882:2017' - " enclosing-namespace-specifier).", - ) - ]) - return - for word in _get_namespace_components(namespace_value.text): - if word in _CPP_RESERVED_WORDS: - errors.append([ - error.error( - source_file_name, - namespace_value.source_location, - f'Reserved word "{word}" is not allowed as a namespace' - " component.", - ) - ]) + if attr.name.text != attributes.Attribute.NAMESPACE: + return + namespace_value = ir_data_utils.reader(attr).value.string_constant + if not re.fullmatch(_NS_RE, namespace_value.text): + if re.fullmatch(_NS_EMPTY_RE, namespace_value.text): + errors.append( + [ + error.error( + source_file_name, + namespace_value.source_location, + "Empty namespace value is not allowed.", + ) + ] + ) + elif re.fullmatch(_NS_GLOBAL_RE, namespace_value.text): + errors.append( + [ + error.error( + source_file_name, + namespace_value.source_location, + "Global namespace is not allowed.", + ) + ] + ) + else: + errors.append( + [ + error.error( + source_file_name, + namespace_value.source_location, + 'Invalid namespace, must be a valid C++ namespace, such as "abc", ' + '"abc::def", or "::abc::def::ghi" (ISO/IEC 14882:2017 ' + "enclosing-namespace-specifier).", + ) + ] + ) + return + for word in _get_namespace_components(namespace_value.text): + if word in _CPP_RESERVED_WORDS: + errors.append( + [ + error.error( + source_file_name, + namespace_value.source_location, + f'Reserved word "{word}" is not allowed as a namespace component.', + ) + ] + ) _VALID_CASES = ", ".join(case for case in _SUPPORTED_ENUM_CASES) def _verify_enum_case_attribute(attr, source_file_name, errors): - """Verify that `enum_case` values are supported.""" - if attr.name.text != attributes.Attribute.ENUM_CASE: - return + """Verify that `enum_case` values are supported.""" + if attr.name.text != attributes.Attribute.ENUM_CASE: + return - enum_case_value = attr.value.string_constant - case_spans = _split_enum_case_values_into_spans(enum_case_value.text) - seen_cases = set() + enum_case_value = attr.value.string_constant + case_spans = _split_enum_case_values_into_spans(enum_case_value.text) + seen_cases = set() - for start, end in case_spans: - case_source_location = _offset_source_location_column( - enum_case_value.source_location, (start, end) - ) - case = enum_case_value.text[start:end] - - if start == end: - errors.append([ - error.error( - source_file_name, - case_source_location, - "Empty enum case (or excess comma).", - ) - ]) - continue - - if case in seen_cases: - errors.append([ - error.error( - source_file_name, - case_source_location, - f'Duplicate enum case "{case}".', - ) - ]) - continue - seen_cases.add(case) - - if case not in _SUPPORTED_ENUM_CASES: - errors.append([ - error.error( - source_file_name, - case_source_location, - f'Unsupported enum case "{case}", ' - f"supported cases are: {_VALID_CASES}.", - ) - ]) + for start, end in case_spans: + case_source_location = _offset_source_location_column( + enum_case_value.source_location, (start, end) + ) + case = enum_case_value.text[start:end] + + if start == end: + errors.append( + [ + error.error( + source_file_name, + case_source_location, + "Empty enum case (or excess comma).", + ) + ] + ) + continue + + if case in seen_cases: + errors.append( + [ + error.error( + source_file_name, + case_source_location, + f'Duplicate enum case "{case}".', + ) + ] + ) + continue + seen_cases.add(case) + + if case not in _SUPPORTED_ENUM_CASES: + errors.append( + [ + error.error( + source_file_name, + case_source_location, + f'Unsupported enum case "{case}", ' + f"supported cases are: {_VALID_CASES}.", + ) + ] + ) def _verify_attribute_values(ir): - """Verify backend attribute values.""" - errors = [] + """Verify backend attribute values.""" + errors = [] - traverse_ir.fast_traverse_ir_top_down( - ir, - [ir_data.Attribute], - _verify_namespace_attribute, - parameters={"errors": errors}, - ) - traverse_ir.fast_traverse_ir_top_down( - ir, - [ir_data.Attribute], - _verify_enum_case_attribute, - parameters={"errors": errors}, - ) + traverse_ir.fast_traverse_ir_top_down( + ir, + [ir_data.Attribute], + _verify_namespace_attribute, + parameters={"errors": errors}, + ) + traverse_ir.fast_traverse_ir_top_down( + ir, + [ir_data.Attribute], + _verify_enum_case_attribute, + parameters={"errors": errors}, + ) - return errors + return errors def _propagate_defaults_and_verify_attributes(ir): - """Verify attributes and ensure defaults are set when not overridden. - - Arguments: - ir: The IR to process. - - Returns: - A list of errors if there are errors present, or an empty list if - verification completed successfully. - """ - if errors := attribute_util.check_attributes_in_ir( - ir, - back_end="cpp", - types=attributes.TYPES, - module_attributes=attributes.Scope.MODULE, - struct_attributes=attributes.Scope.STRUCT, - bits_attributes=attributes.Scope.BITS, - enum_attributes=attributes.Scope.ENUM, - enum_value_attributes=attributes.Scope.ENUM_VALUE, - ): - return errors + """Verify attributes and ensure defaults are set when not overridden. - if errors := _verify_attribute_values(ir): - return errors + Arguments: + ir: The IR to process. + + Returns: + A list of errors if there are errors present, or an empty list if + verification completed successfully.""" + if errors := attribute_util.check_attributes_in_ir( + ir, + back_end="cpp", + types=attributes.TYPES, + module_attributes=attributes.Scope.MODULE, + struct_attributes=attributes.Scope.STRUCT, + bits_attributes=attributes.Scope.BITS, + enum_attributes=attributes.Scope.ENUM, + enum_value_attributes=attributes.Scope.ENUM_VALUE, + ): + return errors - # Ensure defaults are set on EnumValues for `enum_case`. - _propagate_defaults( - ir, - targets=[ir_data.EnumValue], - ancestors=[ir_data.Module, ir_data.TypeDefinition], - add_fn=_add_missing_enum_case_attribute_on_enum_value, - ) + if errors := _verify_attribute_values(ir): + return errors - return [] + # Ensure defaults are set on EnumValues for `enum_case`. + _propagate_defaults( + ir, + targets=[ir_data.EnumValue], + ancestors=[ir_data.Module, ir_data.TypeDefinition], + add_fn=_add_missing_enum_case_attribute_on_enum_value, + ) + + return [] def generate_header(ir, config=Config()): - """Generates a C++ header from an Emboss module. - - Arguments: - ir: An EmbossIr of the module. - - Returns: - A tuple of (header, errors), where `header` is either a string containing - the text of a C++ header which implements Views for the types in the Emboss - module, or None, and `errors` is a possibly-empty list of error messages to - display to the user. - """ - errors = _propagate_defaults_and_verify_attributes(ir) - if errors: - return None, errors - type_declarations = [] - type_definitions = [] - method_definitions = [] - for type_definition in ir.module[0].type: - declaration, definition, methods = _generate_type_definition( - type_definition, ir, config + """Generates a C++ header from an Emboss module. + + Arguments: + ir: An EmbossIr of the module. + + Returns: + A tuple of (header, errors), where `header` is either a string containing + the text of a C++ header which implements Views for the types in the Emboss + module, or None, and `errors` is a possibly-empty list of error messages to + display to the user. + """ + errors = _propagate_defaults_and_verify_attributes(ir) + if errors: + return None, errors + type_declarations = [] + type_definitions = [] + method_definitions = [] + for type_definition in ir.module[0].type: + declaration, definition, methods = _generate_type_definition( + type_definition, ir, config + ) + type_declarations.append(declaration) + type_definitions.append(definition) + method_definitions.append(methods) + body = code_template.format_template( + _TEMPLATES.body, + type_declarations="".join(type_declarations), + type_definitions="".join(type_definitions), + method_definitions="".join(method_definitions), + ) + body = _wrap_in_namespace(body, _get_module_namespace(ir.module[0])) + includes = _get_includes(ir.module[0], config) + return ( + code_template.format_template( + _TEMPLATES.outline, + includes=includes, + body=body, + header_guard=_generate_header_guard(ir.module[0].source_file_name), + ), + [], ) - type_declarations.append(declaration) - type_definitions.append(definition) - method_definitions.append(methods) - body = code_template.format_template( - _TEMPLATES.body, - type_declarations="".join(type_declarations), - type_definitions="".join(type_definitions), - method_definitions="".join(method_definitions), - ) - body = _wrap_in_namespace(body, _get_module_namespace(ir.module[0])) - includes = _get_includes(ir.module[0], config) - return ( - code_template.format_template( - _TEMPLATES.outline, - includes=includes, - body=body, - header_guard=_generate_header_guard(ir.module[0].source_file_name), - ), - [], - ) From b095555dff4dd0209ed34f601361b9192dd6964c Mon Sep 17 00:00:00 2001 From: Aaron Webster Date: Tue, 25 Nov 2025 13:36:00 -0800 Subject: [PATCH 5/9] Revert: Reformat compiler/back_end/cpp/run_one_golden_test.py to original spacing --- compiler/back_end/cpp/run_one_golden_test.py | 75 ++++++++++---------- 1 file changed, 37 insertions(+), 38 deletions(-) diff --git a/compiler/back_end/cpp/run_one_golden_test.py b/compiler/back_end/cpp/run_one_golden_test.py index 150b4d9..7e8b6fc 100644 --- a/compiler/back_end/cpp/run_one_golden_test.py +++ b/compiler/back_end/cpp/run_one_golden_test.py @@ -14,51 +14,50 @@ # See the License for the specific language governing permissions and # limitations under the License. -import os -import sys import unittest - -from one_golden_test import OneGoldenTest +import sys +import os sys.path.insert(0, os.path.dirname(__file__)) +from one_golden_test import OneGoldenTest + def main(argv): - if len(argv) < 5: - print( - f"Usage: {argv[0]} emboss_front_end emboss_compiler emb_file" - " golden_file [include_dir...]" + if len(argv) < 5: + print( + f"Usage: {argv[0]} emboss_front_end emboss_compiler emb_file golden_file [include_dir...]" + ) + return 1 + + emboss_front_end = argv[1] + emboss_compiler = argv[2] + emb_file = argv[3] + golden_file = argv[4] + + include_dirs = [] + compiler_flags = [] + for arg in argv[5:]: + if arg.startswith("--import-dir="): + include_dirs.append(arg[len("--import-dir="):]) + else: + compiler_flags.append(arg) + + suite = unittest.TestSuite() + suite.addTest( + OneGoldenTest( + emboss_front_end, + emboss_compiler, + emb_file, + golden_file, + include_dirs, + compiler_flags, + ) ) - return 1 - - emboss_front_end = argv[1] - emboss_compiler = argv[2] - emb_file = argv[3] - golden_file = argv[4] - - include_dirs = [] - compiler_flags = [] - for arg in argv[5:]: - if arg.startswith("--import-dir="): - include_dirs.append(arg[len("--import-dir=") :]) - else: - compiler_flags.append(arg) - - suite = unittest.TestSuite() - suite.addTest( - OneGoldenTest( - emboss_front_end, - emboss_compiler, - emb_file, - golden_file, - include_dirs, - compiler_flags, - ) - ) - runner = unittest.TextTestRunner() - result = runner.run(suite) - return 0 if result.wasSuccessful() else 1 + runner = unittest.TextTestRunner() + result = runner.run(suite) + return 0 if result.wasSuccessful() else 1 if __name__ == "__main__": - sys.exit(main(sys.argv)) + sys.exit(main(sys.argv)) From 6e5672c75bb33f4790ecac267bc4125f36f1243f Mon Sep 17 00:00:00 2001 From: Aaron Webster Date: Tue, 25 Nov 2025 13:38:09 -0800 Subject: [PATCH 6/9] Reformat: Wrap many_conditionals_benchmark.cc in namespace --- .../back_end/cpp/testcode/many_conditionals_benchmark.cc | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/compiler/back_end/cpp/testcode/many_conditionals_benchmark.cc b/compiler/back_end/cpp/testcode/many_conditionals_benchmark.cc index 61a2f99..bc4ab96 100644 --- a/compiler/back_end/cpp/testcode/many_conditionals_benchmark.cc +++ b/compiler/back_end/cpp/testcode/many_conditionals_benchmark.cc @@ -10,6 +10,10 @@ // Since this file is in compiler/back_end/cpp/testcode/, it will be built as a // cc_test. We can use GoogleTest macros. +namespace emboss { +namespace test { +namespace { + TEST(ComplexConditionals, PerformanceBenchmark) { std::vector buffer(100, 0); auto view = emboss::test::MakeLargeConditionalsView(&buffer); @@ -35,3 +39,7 @@ TEST(ComplexConditionals, PerformanceBenchmark) { EXPECT_TRUE(result); EXPECT_TRUE(view.Ok()); } + +} // namespace +} // namespace test +} // namespace emboss From 79eaadac5dd04e0c2d2259774a958f58016c1cf5 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Wed, 26 Nov 2025 00:16:14 +0000 Subject: [PATCH 7/9] Fix Python formatting and regenerate golden files Co-authored-by: AaronWebster <3766083+AaronWebster@users.noreply.github.com> --- compiler/back_end/cpp/header_generator.py | 3 - compiler/back_end/cpp/run_one_golden_test.py | 4 +- testdata/golden_cpp/alignments.emb.h | 164 ++- testdata/golden_cpp/anonymous_bits.emb.h | 151 +- testdata/golden_cpp/auto_array_size.emb.h | 93 +- testdata/golden_cpp/bcd.emb.h | 193 ++- testdata/golden_cpp/bits.emb.h | 301 ++-- testdata/golden_cpp/complex_offset.emb.h | 206 ++- testdata/golden_cpp/complex_structure.emb.h | 267 +++- testdata/golden_cpp/condition.emb.h | 1359 +++++++++++++----- testdata/golden_cpp/dynamic_size.emb.h | 543 +++++-- testdata/golden_cpp/enum.emb.h | 151 +- testdata/golden_cpp/enum_case.emb.h | 43 +- testdata/golden_cpp/explicit_sizes.emb.h | 158 +- testdata/golden_cpp/float.emb.h | 72 +- testdata/golden_cpp/imported.emb.h | 29 +- testdata/golden_cpp/imported_genfiles.emb.h | 29 +- testdata/golden_cpp/importer.emb.h | 36 +- testdata/golden_cpp/importer2.emb.h | 29 +- testdata/golden_cpp/inline_type.emb.h | 36 +- testdata/golden_cpp/int_sizes.emb.h | 78 +- testdata/golden_cpp/large_array.emb.h | 36 +- testdata/golden_cpp/nested_structure.emb.h | 115 +- testdata/golden_cpp/next_keyword.emb.h | 50 +- testdata/golden_cpp/no_enum_traits.emb.h | 192 +-- testdata/golden_cpp/parameters.emb.h | 570 ++++++-- testdata/golden_cpp/requires.emb.h | 410 ++++-- testdata/golden_cpp/start_size_range.emb.h | 50 +- testdata/golden_cpp/subtypes.emb.h | 214 ++- testdata/golden_cpp/text_format.emb.h | 122 +- testdata/golden_cpp/uint_sizes.emb.h | 476 ++++-- testdata/golden_cpp/virtual_field.emb.h | 916 ++++++++---- 32 files changed, 4998 insertions(+), 2098 deletions(-) diff --git a/compiler/back_end/cpp/header_generator.py b/compiler/back_end/cpp/header_generator.py index 30ba343..8e504ad 100644 --- a/compiler/back_end/cpp/header_generator.py +++ b/compiler/back_end/cpp/header_generator.py @@ -802,9 +802,6 @@ def add(self, subexpr): return subexpr - - - class _SmartSubexpressionStore(object): """A SubexpressionStore that only caches subexpressions used multiple times.""" diff --git a/compiler/back_end/cpp/run_one_golden_test.py b/compiler/back_end/cpp/run_one_golden_test.py index 7e8b6fc..0faa513 100644 --- a/compiler/back_end/cpp/run_one_golden_test.py +++ b/compiler/back_end/cpp/run_one_golden_test.py @@ -34,12 +34,12 @@ def main(argv): emboss_compiler = argv[2] emb_file = argv[3] golden_file = argv[4] - + include_dirs = [] compiler_flags = [] for arg in argv[5:]: if arg.startswith("--import-dir="): - include_dirs.append(arg[len("--import-dir="):]) + include_dirs.append(arg[len("--import-dir=") :]) else: compiler_flags.append(arg) diff --git a/testdata/golden_cpp/alignments.emb.h b/testdata/golden_cpp/alignments.emb.h index e60daf5..f225198 100644 --- a/testdata/golden_cpp/alignments.emb.h +++ b/testdata/golden_cpp/alignments.emb.h @@ -116,60 +116,103 @@ class GenericAlignmentsView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_zero_offset().Known()) return false; - if (has_zero_offset().ValueOrDefault() && !zero_offset().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !zero_offset().Ok()) return false; + } - if (!has_zero_offset_substructure().Known()) return false; - if (has_zero_offset_substructure().ValueOrDefault() && !zero_offset_substructure().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !zero_offset_substructure().Ok()) return false; + } - if (!has_two_offset_substructure().Known()) return false; - if (has_two_offset_substructure().ValueOrDefault() && !two_offset_substructure().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !two_offset_substructure().Ok()) return false; + } - if (!has_three_offset().Known()) return false; - if (has_three_offset().ValueOrDefault() && !three_offset().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !three_offset().Ok()) return false; + } - if (!has_four_offset().Known()) return false; - if (has_four_offset().ValueOrDefault() && !four_offset().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !four_offset().Ok()) return false; + } - if (!has_eleven_offset().Known()) return false; - if (has_eleven_offset().ValueOrDefault() && !eleven_offset().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !eleven_offset().Ok()) return false; + } - if (!has_twelve_offset().Known()) return false; - if (has_twelve_offset().ValueOrDefault() && !twelve_offset().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !twelve_offset().Ok()) return false; + } - if (!has_zero_offset_four_stride_array().Known()) return false; - if (has_zero_offset_four_stride_array().ValueOrDefault() && !zero_offset_four_stride_array().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !zero_offset_four_stride_array().Ok()) return false; + } - if (!has_zero_offset_six_stride_array().Known()) return false; - if (has_zero_offset_six_stride_array().ValueOrDefault() && !zero_offset_six_stride_array().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !zero_offset_six_stride_array().Ok()) return false; + } - if (!has_three_offset_four_stride_array().Known()) return false; - if (has_three_offset_four_stride_array().ValueOrDefault() && !three_offset_four_stride_array().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !three_offset_four_stride_array().Ok()) return false; + } - if (!has_four_offset_six_stride_array().Known()) return false; - if (has_four_offset_six_stride_array().ValueOrDefault() && !four_offset_six_stride_array().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !four_offset_six_stride_array().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -1338,20 +1381,33 @@ class GenericPlaceholder4View final { bool Ok() const { if (!IsComplete()) return false; - if (!has_dummy().Known()) return false; - if (has_dummy().ValueOrDefault() && !dummy().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !dummy().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -1757,24 +1813,40 @@ class GenericPlaceholder6View final { bool Ok() const { if (!IsComplete()) return false; - if (!has_zero_offset().Known()) return false; - if (has_zero_offset().ValueOrDefault() && !zero_offset().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !zero_offset().Ok()) return false; + } - if (!has_two_offset().Known()) return false; - if (has_two_offset().ValueOrDefault() && !two_offset().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !two_offset().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/anonymous_bits.emb.h b/testdata/golden_cpp/anonymous_bits.emb.h index 7d505c9..42b1aac 100644 --- a/testdata/golden_cpp/anonymous_bits.emb.h +++ b/testdata/golden_cpp/anonymous_bits.emb.h @@ -122,28 +122,47 @@ class GenericEmbossReservedAnonymousField2View final { bool Ok() const { if (!IsComplete()) return false; - if (!has_high_bit().Known()) return false; - if (has_high_bit().ValueOrDefault() && !high_bit().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !high_bit().Ok()) return false; + } - if (!has_bar().Known()) return false; - if (has_bar().ValueOrDefault() && !bar().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !bar().Ok()) return false; + } - if (!has_first_bit().Known()) return false; - if (has_first_bit().ValueOrDefault() && !first_bit().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !first_bit().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -793,24 +812,40 @@ class GenericEmbossReservedAnonymousField1View final { bool Ok() const { if (!IsComplete()) return false; - if (!has_bit_23().Known()) return false; - if (has_bit_23().ValueOrDefault() && !bit_23().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !bit_23().Ok()) return false; + } - if (!has_low_bit().Known()) return false; - if (has_low_bit().ValueOrDefault() && !low_bit().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !low_bit().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -1288,44 +1323,76 @@ class GenericFooView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_emboss_reserved_anonymous_field_2().Known()) return false; - if (has_emboss_reserved_anonymous_field_2().ValueOrDefault() && !emboss_reserved_anonymous_field_2().Ok()) return false; + const auto emboss_reserved_local_ok_subexpr_1 = ::emboss::support::And(::emboss::support::Maybe(true), ::emboss::support::Maybe(true)); + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !emboss_reserved_anonymous_field_2().Ok()) return false; + } - if (!has_high_bit().Known()) return false; - if (has_high_bit().ValueOrDefault() && !high_bit().Ok()) return false; + { + const auto emboss_reserved_local_field_present = emboss_reserved_local_ok_subexpr_1; + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !high_bit().Ok()) return false; + } - if (!has_bar().Known()) return false; - if (has_bar().ValueOrDefault() && !bar().Ok()) return false; + { + const auto emboss_reserved_local_field_present = emboss_reserved_local_ok_subexpr_1; + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !bar().Ok()) return false; + } - if (!has_first_bit().Known()) return false; - if (has_first_bit().ValueOrDefault() && !first_bit().Ok()) return false; + { + const auto emboss_reserved_local_field_present = emboss_reserved_local_ok_subexpr_1; + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !first_bit().Ok()) return false; + } - if (!has_emboss_reserved_anonymous_field_1().Known()) return false; - if (has_emboss_reserved_anonymous_field_1().ValueOrDefault() && !emboss_reserved_anonymous_field_1().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !emboss_reserved_anonymous_field_1().Ok()) return false; + } - if (!has_bit_23().Known()) return false; - if (has_bit_23().ValueOrDefault() && !bit_23().Ok()) return false; + { + const auto emboss_reserved_local_field_present = emboss_reserved_local_ok_subexpr_1; + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !bit_23().Ok()) return false; + } - if (!has_low_bit().Known()) return false; - if (has_low_bit().ValueOrDefault() && !low_bit().Ok()) return false; + { + const auto emboss_reserved_local_field_present = emboss_reserved_local_ok_subexpr_1; + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !low_bit().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/auto_array_size.emb.h b/testdata/golden_cpp/auto_array_size.emb.h index 64e2973..66e01f0 100644 --- a/testdata/golden_cpp/auto_array_size.emb.h +++ b/testdata/golden_cpp/auto_array_size.emb.h @@ -99,24 +99,40 @@ class GenericElementView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_a().Known()) return false; - if (has_a().ValueOrDefault() && !a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a().Ok()) return false; + } - if (!has_b().Known()) return false; - if (has_b().ValueOrDefault() && !b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -602,36 +618,61 @@ class GenericAutoSizeView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_array_size().Known()) return false; - if (has_array_size().ValueOrDefault() && !array_size().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !array_size().Ok()) return false; + } - if (!has_four_byte_array().Known()) return false; - if (has_four_byte_array().ValueOrDefault() && !four_byte_array().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !four_byte_array().Ok()) return false; + } - if (!has_four_struct_array().Known()) return false; - if (has_four_struct_array().ValueOrDefault() && !four_struct_array().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !four_struct_array().Ok()) return false; + } - if (!has_dynamic_byte_array().Known()) return false; - if (has_dynamic_byte_array().ValueOrDefault() && !dynamic_byte_array().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !dynamic_byte_array().Ok()) return false; + } - if (!has_dynamic_struct_array().Known()) return false; - if (has_dynamic_struct_array().ValueOrDefault() && !dynamic_struct_array().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !dynamic_struct_array().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/bcd.emb.h b/testdata/golden_cpp/bcd.emb.h index 1e4edc2..c10e884 100644 --- a/testdata/golden_cpp/bcd.emb.h +++ b/testdata/golden_cpp/bcd.emb.h @@ -125,32 +125,54 @@ class GenericEmbossReservedAnonymousField1View final { bool Ok() const { if (!IsComplete()) return false; - if (!has_four_bit().Known()) return false; - if (has_four_bit().ValueOrDefault() && !four_bit().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !four_bit().Ok()) return false; + } - if (!has_six_bit().Known()) return false; - if (has_six_bit().ValueOrDefault() && !six_bit().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !six_bit().Ok()) return false; + } - if (!has_ten_bit().Known()) return false; - if (has_ten_bit().ValueOrDefault() && !ten_bit().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !ten_bit().Ok()) return false; + } - if (!has_twelve_bit().Known()) return false; - if (has_twelve_bit().ValueOrDefault() && !twelve_bit().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !twelve_bit().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -782,68 +804,118 @@ class GenericBcdSizesView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_one_byte().Known()) return false; - if (has_one_byte().ValueOrDefault() && !one_byte().Ok()) return false; + const auto emboss_reserved_local_ok_subexpr_1 = ::emboss::support::And(::emboss::support::Maybe(true), ::emboss::support::Maybe(true)); + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !one_byte().Ok()) return false; + } - if (!has_two_byte().Known()) return false; - if (has_two_byte().ValueOrDefault() && !two_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !two_byte().Ok()) return false; + } - if (!has_three_byte().Known()) return false; - if (has_three_byte().ValueOrDefault() && !three_byte().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !three_byte().Ok()) return false; + } - if (!has_four_byte().Known()) return false; - if (has_four_byte().ValueOrDefault() && !four_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !four_byte().Ok()) return false; + } - if (!has_five_byte().Known()) return false; - if (has_five_byte().ValueOrDefault() && !five_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !five_byte().Ok()) return false; + } - if (!has_six_byte().Known()) return false; - if (has_six_byte().ValueOrDefault() && !six_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !six_byte().Ok()) return false; + } - if (!has_seven_byte().Known()) return false; - if (has_seven_byte().ValueOrDefault() && !seven_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !seven_byte().Ok()) return false; + } - if (!has_eight_byte().Known()) return false; - if (has_eight_byte().ValueOrDefault() && !eight_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !eight_byte().Ok()) return false; + } - if (!has_emboss_reserved_anonymous_field_1().Known()) return false; - if (has_emboss_reserved_anonymous_field_1().ValueOrDefault() && !emboss_reserved_anonymous_field_1().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !emboss_reserved_anonymous_field_1().Ok()) return false; + } - if (!has_four_bit().Known()) return false; - if (has_four_bit().ValueOrDefault() && !four_bit().Ok()) return false; + { + const auto emboss_reserved_local_field_present = emboss_reserved_local_ok_subexpr_1; + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !four_bit().Ok()) return false; + } - if (!has_six_bit().Known()) return false; - if (has_six_bit().ValueOrDefault() && !six_bit().Ok()) return false; + { + const auto emboss_reserved_local_field_present = emboss_reserved_local_ok_subexpr_1; + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !six_bit().Ok()) return false; + } - if (!has_ten_bit().Known()) return false; - if (has_ten_bit().ValueOrDefault() && !ten_bit().Ok()) return false; + { + const auto emboss_reserved_local_field_present = emboss_reserved_local_ok_subexpr_1; + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !ten_bit().Ok()) return false; + } - if (!has_twelve_bit().Known()) return false; - if (has_twelve_bit().ValueOrDefault() && !twelve_bit().Ok()) return false; + { + const auto emboss_reserved_local_field_present = emboss_reserved_local_ok_subexpr_1; + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !twelve_bit().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -2004,20 +2076,33 @@ class GenericBcdBigEndianView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_four_byte().Known()) return false; - if (has_four_byte().ValueOrDefault() && !four_byte().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !four_byte().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/bits.emb.h b/testdata/golden_cpp/bits.emb.h index e6f29da..1509726 100644 --- a/testdata/golden_cpp/bits.emb.h +++ b/testdata/golden_cpp/bits.emb.h @@ -142,36 +142,61 @@ class GenericOneByteView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_high_bit().Known()) return false; - if (has_high_bit().ValueOrDefault() && !high_bit().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !high_bit().Ok()) return false; + } - if (!has_less_high_bit().Known()) return false; - if (has_less_high_bit().ValueOrDefault() && !less_high_bit().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !less_high_bit().Ok()) return false; + } - if (!has_mid_nibble().Known()) return false; - if (has_mid_nibble().ValueOrDefault() && !mid_nibble().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !mid_nibble().Ok()) return false; + } - if (!has_less_low_bit().Known()) return false; - if (has_less_low_bit().ValueOrDefault() && !less_low_bit().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !less_low_bit().Ok()) return false; + } - if (!has_low_bit().Known()) return false; - if (has_low_bit().ValueOrDefault() && !low_bit().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !low_bit().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -907,28 +932,47 @@ class GenericTwoByteWithGapsView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_high_bit().Known()) return false; - if (has_high_bit().ValueOrDefault() && !high_bit().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !high_bit().Ok()) return false; + } - if (!has_mid_nibble().Known()) return false; - if (has_mid_nibble().ValueOrDefault() && !mid_nibble().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !mid_nibble().Ok()) return false; + } - if (!has_low_bit().Known()) return false; - if (has_low_bit().ValueOrDefault() && !low_bit().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !low_bit().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -1483,36 +1527,61 @@ class GenericFourByteView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_high_nibble().Known()) return false; - if (has_high_nibble().ValueOrDefault() && !high_nibble().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !high_nibble().Ok()) return false; + } - if (!has_one_byte().Known()) return false; - if (has_one_byte().ValueOrDefault() && !one_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !one_byte().Ok()) return false; + } - if (!has_two_byte().Known()) return false; - if (has_two_byte().ValueOrDefault() && !two_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !two_byte().Ok()) return false; + } - if (!has_raw_low_nibble().Known()) return false; - if (has_raw_low_nibble().ValueOrDefault() && !raw_low_nibble().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !raw_low_nibble().Ok()) return false; + } - if (!has_low_nibble().Known()) return false; - if (has_low_nibble().ValueOrDefault() && !low_nibble().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !low_nibble().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -2274,24 +2343,40 @@ class GenericArrayInBitsView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_lone_flag().Known()) return false; - if (has_lone_flag().ValueOrDefault() && !lone_flag().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !lone_flag().Ok()) return false; + } - if (!has_flags().Known()) return false; - if (has_flags().ValueOrDefault() && !flags().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !flags().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -2777,20 +2862,33 @@ class GenericArrayInBitsInStructView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_array_in_bits().Known()) return false; - if (has_array_in_bits().ValueOrDefault() && !array_in_bits().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !array_in_bits().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -3196,32 +3294,54 @@ class GenericStructOfBitsView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_one_byte().Known()) return false; - if (has_one_byte().ValueOrDefault() && !one_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !one_byte().Ok()) return false; + } - if (!has_two_byte().Known()) return false; - if (has_two_byte().ValueOrDefault() && !two_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !two_byte().Ok()) return false; + } - if (!has_four_byte().Known()) return false; - if (has_four_byte().ValueOrDefault() && !four_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !four_byte().Ok()) return false; + } - if (!has_located_byte().Known()) return false; - if (has_located_byte().ValueOrDefault() && !located_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !located_byte().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -3881,20 +4001,33 @@ class GenericBitArrayView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_one_byte().Known()) return false; - if (has_one_byte().ValueOrDefault() && !one_byte().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !one_byte().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/complex_offset.emb.h b/testdata/golden_cpp/complex_offset.emb.h index 31889b0..e478bf3 100644 --- a/testdata/golden_cpp/complex_offset.emb.h +++ b/testdata/golden_cpp/complex_offset.emb.h @@ -106,20 +106,33 @@ class GenericLengthView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_length().Known()) return false; - if (has_length().ValueOrDefault() && !length().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !length().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -525,24 +538,40 @@ class GenericDataView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_length().Known()) return false; - if (has_length().ValueOrDefault() && !length().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !length().Ok()) return false; + } - if (!has_data().Known()) return false; - if (has_data().ValueOrDefault() && !data().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !data().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -1072,84 +1101,145 @@ class GenericPackedFieldsView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_length1().Known()) return false; - if (has_length1().ValueOrDefault() && !length1().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !length1().Ok()) return false; + } - if (!has_data1().Known()) return false; - if (has_data1().ValueOrDefault() && !data1().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !data1().Ok()) return false; + } - if (!has_o1().Known()) return false; - if (has_o1().ValueOrDefault() && !o1().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !o1().Ok()) return false; + } - if (!has_length2().Known()) return false; - if (has_length2().ValueOrDefault() && !length2().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !length2().Ok()) return false; + } - if (!has_data2().Known()) return false; - if (has_data2().ValueOrDefault() && !data2().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !data2().Ok()) return false; + } - if (!has_o2().Known()) return false; - if (has_o2().ValueOrDefault() && !o2().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !o2().Ok()) return false; + } - if (!has_length3().Known()) return false; - if (has_length3().ValueOrDefault() && !length3().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !length3().Ok()) return false; + } - if (!has_data3().Known()) return false; - if (has_data3().ValueOrDefault() && !data3().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !data3().Ok()) return false; + } - if (!has_o3().Known()) return false; - if (has_o3().ValueOrDefault() && !o3().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !o3().Ok()) return false; + } - if (!has_length4().Known()) return false; - if (has_length4().ValueOrDefault() && !length4().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !length4().Ok()) return false; + } - if (!has_data4().Known()) return false; - if (has_data4().ValueOrDefault() && !data4().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !data4().Ok()) return false; + } - if (!has_o4().Known()) return false; - if (has_o4().ValueOrDefault() && !o4().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !o4().Ok()) return false; + } - if (!has_length5().Known()) return false; - if (has_length5().ValueOrDefault() && !length5().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !length5().Ok()) return false; + } - if (!has_data5().Known()) return false; - if (has_data5().ValueOrDefault() && !data5().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !data5().Ok()) return false; + } - if (!has_o5().Known()) return false; - if (has_o5().ValueOrDefault() && !o5().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !o5().Ok()) return false; + } - if (!has_length6().Known()) return false; - if (has_length6().ValueOrDefault() && !length6().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !length6().Ok()) return false; + } - if (!has_data6().Known()) return false; - if (has_data6().ValueOrDefault() && !data6().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !data6().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/complex_structure.emb.h b/testdata/golden_cpp/complex_structure.emb.h index 745976a..2ea9495 100644 --- a/testdata/golden_cpp/complex_structure.emb.h +++ b/testdata/golden_cpp/complex_structure.emb.h @@ -115,28 +115,47 @@ class GenericRegisterLayoutView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_l().Known()) return false; - if (has_l().ValueOrDefault() && !l().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !l().Ok()) return false; + } - if (!has_h().Known()) return false; - if (has_h().ValueOrDefault() && !h().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !h().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -695,20 +714,33 @@ class GenericArrayElementView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_a().Known()) return false; - if (has_a().ValueOrDefault() && !a().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -1134,32 +1166,54 @@ class GenericEmbossReservedAnonymousField1View final { bool Ok() const { if (!IsComplete()) return false; - if (!has_a0().Known()) return false; - if (has_a0().ValueOrDefault() && !a0().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a0().Ok()) return false; + } - if (!has_s0().Known()) return false; - if (has_s0().ValueOrDefault() && !s0().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !s0().Ok()) return false; + } - if (!has_l0().Known()) return false; - if (has_l0().ValueOrDefault() && !l0().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !l0().Ok()) return false; + } - if (!has_h0().Known()) return false; - if (has_h0().ValueOrDefault() && !h0().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !h0().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -1791,84 +1845,149 @@ class GenericComplexView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_s().Known()) return false; - if (has_s().ValueOrDefault() && !s().Ok()) return false; + const auto emboss_reserved_local_ok_subexpr_1 = ::emboss::support::And(::emboss::support::Maybe(true), ::emboss::support::Maybe(true)); + const auto emboss_reserved_local_ok_subexpr_2 = a0(); + const auto emboss_reserved_local_ok_subexpr_3 = b2(); + const auto emboss_reserved_local_ok_subexpr_4 = s(); + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !s().Ok()) return false; + } - if (!has_u().Known()) return false; - if (has_u().ValueOrDefault() && !u().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !u().Ok()) return false; + } - if (!has_i().Known()) return false; - if (has_i().ValueOrDefault() && !i().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !i().Ok()) return false; + } - if (!has_b().Known()) return false; - if (has_b().ValueOrDefault() && !b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b().Ok()) return false; + } - if (!has_a().Known()) return false; - if (has_a().ValueOrDefault() && !a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a().Ok()) return false; + } - if (!has_emboss_reserved_anonymous_field_1().Known()) return false; - if (has_emboss_reserved_anonymous_field_1().ValueOrDefault() && !emboss_reserved_anonymous_field_1().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !emboss_reserved_anonymous_field_1().Ok()) return false; + } - if (!has_a0().Known()) return false; - if (has_a0().ValueOrDefault() && !a0().Ok()) return false; + { + const auto emboss_reserved_local_field_present = emboss_reserved_local_ok_subexpr_1; + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a0().Ok()) return false; + } - if (!has_s0().Known()) return false; - if (has_s0().ValueOrDefault() && !s0().Ok()) return false; + { + const auto emboss_reserved_local_field_present = emboss_reserved_local_ok_subexpr_1; + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !s0().Ok()) return false; + } - if (!has_l0().Known()) return false; - if (has_l0().ValueOrDefault() && !l0().Ok()) return false; + { + const auto emboss_reserved_local_field_present = emboss_reserved_local_ok_subexpr_1; + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !l0().Ok()) return false; + } - if (!has_h0().Known()) return false; - if (has_h0().ValueOrDefault() && !h0().Ok()) return false; + { + const auto emboss_reserved_local_field_present = emboss_reserved_local_ok_subexpr_1; + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !h0().Ok()) return false; + } - if (!has_e1().Known()) return false; - if (has_e1().ValueOrDefault() && !e1().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !e1().Ok()) return false; + } - if (!has_e2().Known()) return false; - if (has_e2().ValueOrDefault() && !e2().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::GreaterThanOrEqual((emboss_reserved_local_ok_subexpr_2.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_2.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(128LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !e2().Ok()) return false; + } - if (!has_b2().Known()) return false; - if (has_b2().ValueOrDefault() && !b2().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::LessThan((emboss_reserved_local_ok_subexpr_2.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_2.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(128LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b2().Ok()) return false; + } - if (!has_e3().Known()) return false; - if (has_e3().ValueOrDefault() && !e3().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::GreaterThan((emboss_reserved_local_ok_subexpr_3.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_3.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(25LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !e3().Ok()) return false; + } - if (!has_e4().Known()) return false; - if (has_e4().ValueOrDefault() && !e4().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::And(::emboss::support::GreaterThanOrEqual((emboss_reserved_local_ok_subexpr_4.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_4.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(4LL))), ::emboss::support::Choice(::emboss::support::GreaterThanOrEqual((emboss_reserved_local_ok_subexpr_2.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_2.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(80LL))), ::emboss::support::GreaterThanOrEqual((e3().Ok() ? ::emboss::support::Maybe(static_cast(e3().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(128LL))), ::emboss::support::LessThan((emboss_reserved_local_ok_subexpr_3.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_3.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(50LL))))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !e4().Ok()) return false; + } - if (!has_e5().Known()) return false; - if (has_e5().ValueOrDefault() && !e5().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::And(::emboss::support::GreaterThanOrEqual((emboss_reserved_local_ok_subexpr_4.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_4.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(5LL))), ::emboss::support::GreaterThan((e4().Ok() ? ::emboss::support::Maybe(static_cast(e4().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(0LL)))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !e5().Ok()) return false; + } - if (!has_e0().Known()) return false; - if (has_e0().ValueOrDefault() && !e0().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Or(::emboss::support::LessThan((emboss_reserved_local_ok_subexpr_4.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_4.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(2LL))), ::emboss::support::LessThan((emboss_reserved_local_ok_subexpr_2.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_2.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(4LL)))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !e0().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/condition.emb.h b/testdata/golden_cpp/condition.emb.h index 9d11fb7..1ba3f50 100644 --- a/testdata/golden_cpp/condition.emb.h +++ b/testdata/golden_cpp/condition.emb.h @@ -360,24 +360,40 @@ class GenericBasicConditionalView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Equal((x().Ok() ? ::emboss::support::Maybe(static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(0LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -890,24 +906,40 @@ class GenericNegativeConditionalView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::NotEqual((x().Ok() ? ::emboss::support::Maybe(static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(0LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -1421,28 +1453,47 @@ class GenericConditionalAndUnconditionalOverlappingFinalFieldView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Equal((x().Ok() ? ::emboss::support::Maybe(static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(0LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_z().Known()) return false; - if (has_z().ValueOrDefault() && !z().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !z().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -2002,24 +2053,40 @@ class GenericConditionalBasicConditionalFieldFirstView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Equal((x().Ok() ? ::emboss::support::Maybe(static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(0LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -2503,28 +2570,47 @@ class GenericConditionalAndDynamicLocationView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_y().Known()) return false; - if (has_y().ValueOrDefault() && !y().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !y().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Equal((x().Ok() ? ::emboss::support::Maybe(static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(0LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -3117,24 +3203,40 @@ class GenericConditionUsesMinIntView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Equal(::emboss::support::Difference((x().Ok() ? ::emboss::support::Maybe(static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(9223372036854775680LL))), ::emboss::support::Maybe(static_cast(-9223372036854775807LL - 1))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -3649,28 +3751,47 @@ class GenericNestedConditionalView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Equal((x().Ok() ? ::emboss::support::Maybe(static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(0LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_xcc().Known()) return false; - if (has_xcc().ValueOrDefault() && !xcc().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Equal((xc().Ok() ? ::emboss::support::Maybe(static_cast(xc().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(0LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xcc().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -4265,28 +4386,48 @@ class GenericCorrectNestedConditionalView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + const auto emboss_reserved_local_ok_subexpr_1 = x(); + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Equal((emboss_reserved_local_ok_subexpr_1.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_1.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(0LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_xcc().Known()) return false; - if (has_xcc().ValueOrDefault() && !xcc().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::And(::emboss::support::Equal((emboss_reserved_local_ok_subexpr_1.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_1.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(0LL))), ::emboss::support::Equal((xc().Ok() ? ::emboss::support::Maybe(static_cast(xc().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(0LL)))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xcc().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -4881,24 +5022,40 @@ class GenericAlwaysFalseConditionView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(false); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -5380,20 +5537,33 @@ class GenericOnlyAlwaysFalseConditionView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(false); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -5797,16 +5967,26 @@ class GenericEmptyStructView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -6140,28 +6320,47 @@ class GenericAlwaysFalseConditionDynamicSizeView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_y().Known()) return false; - if (has_y().ValueOrDefault() && !y().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !y().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(false); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -6752,28 +6951,47 @@ class GenericConditionDoesNotContributeToSizeView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Equal((x().Ok() ? ::emboss::support::Maybe(static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(0LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_y().Known()) return false; - if (has_y().ValueOrDefault() && !y().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !y().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -7421,28 +7639,48 @@ class GenericEnumConditionView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + const auto emboss_reserved_local_ok_subexpr_1 = x(); + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Equal((emboss_reserved_local_ok_subexpr_1.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_1.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(1))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_xc2().Known()) return false; - if (has_xc2().ValueOrDefault() && !xc2().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::GreaterThan((emboss_reserved_local_ok_subexpr_1.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_1.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(0))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc2().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -8035,24 +8273,40 @@ class GenericNegativeEnumConditionView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::NotEqual((x().Ok() ? ::emboss::support::Maybe(static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(1))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -8566,24 +8820,40 @@ class GenericLessThanConditionView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::LessThan((x().Ok() ? ::emboss::support::Maybe(static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(5LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -9096,24 +9366,40 @@ class GenericLessThanOrEqualConditionView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::LessThanOrEqual((x().Ok() ? ::emboss::support::Maybe(static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(5LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -9626,24 +9912,40 @@ class GenericGreaterThanOrEqualConditionView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::GreaterThanOrEqual((x().Ok() ? ::emboss::support::Maybe(static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(5LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -10156,24 +10458,40 @@ class GenericGreaterThanConditionView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::GreaterThan((x().Ok() ? ::emboss::support::Maybe(static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(5LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -10687,28 +11005,49 @@ class GenericRangeConditionView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + const auto emboss_reserved_local_ok_subexpr_1 = x(); + const auto emboss_reserved_local_ok_subexpr_2 = y(); + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_y().Known()) return false; - if (has_y().ValueOrDefault() && !y().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !y().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::And(::emboss::support::And(::emboss::support::LessThan(::emboss::support::Maybe(static_cast(5LL)), (emboss_reserved_local_ok_subexpr_1.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_1.UncheckedRead())) : ::emboss::support::Maybe())), ::emboss::support::LessThanOrEqual((emboss_reserved_local_ok_subexpr_1.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_1.UncheckedRead())) : ::emboss::support::Maybe()), (emboss_reserved_local_ok_subexpr_2.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_2.UncheckedRead())) : ::emboss::support::Maybe()))), ::emboss::support::LessThan((emboss_reserved_local_ok_subexpr_2.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_2.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(10LL)))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -11305,28 +11644,49 @@ class GenericReverseRangeConditionView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + const auto emboss_reserved_local_ok_subexpr_1 = y(); + const auto emboss_reserved_local_ok_subexpr_2 = x(); + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_y().Known()) return false; - if (has_y().ValueOrDefault() && !y().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !y().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::And(::emboss::support::And(::emboss::support::GreaterThan(::emboss::support::Maybe(static_cast(10LL)), (emboss_reserved_local_ok_subexpr_1.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_1.UncheckedRead())) : ::emboss::support::Maybe())), ::emboss::support::GreaterThanOrEqual((emboss_reserved_local_ok_subexpr_1.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_1.UncheckedRead())) : ::emboss::support::Maybe()), (emboss_reserved_local_ok_subexpr_2.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_2.UncheckedRead())) : ::emboss::support::Maybe()))), ::emboss::support::GreaterThan((emboss_reserved_local_ok_subexpr_2.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_2.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(5LL)))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -11923,28 +12283,47 @@ class GenericAndConditionView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_y().Known()) return false; - if (has_y().ValueOrDefault() && !y().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !y().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::And(::emboss::support::Equal((x().Ok() ? ::emboss::support::Maybe(static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(5LL))), ::emboss::support::Equal((y().Ok() ? ::emboss::support::Maybe(static_cast(y().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(5LL)))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -12539,28 +12918,47 @@ class GenericOrConditionView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_y().Known()) return false; - if (has_y().ValueOrDefault() && !y().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !y().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Or(::emboss::support::Equal((x().Ok() ? ::emboss::support::Maybe(static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(5LL))), ::emboss::support::Equal((y().Ok() ? ::emboss::support::Maybe(static_cast(y().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(5LL)))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -13243,32 +13641,54 @@ class GenericChoiceConditionView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_field().Known()) return false; - if (has_field().ValueOrDefault() && !field().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !field().Ok()) return false; + } - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_y().Known()) return false; - if (has_y().ValueOrDefault() && !y().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !y().Ok()) return false; + } - if (!has_xyc().Known()) return false; - if (has_xyc().ValueOrDefault() && !xyc().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Equal(::emboss::support::Choice(::emboss::support::Equal((field().Ok() ? ::emboss::support::Maybe(static_cast(field().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(1))), (x().Ok() ? ::emboss::support::Maybe(static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), (y().Ok() ? ::emboss::support::Maybe(static_cast(y().UncheckedRead())) : ::emboss::support::Maybe())), ::emboss::support::Maybe(static_cast(5LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xyc().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -13948,24 +14368,40 @@ class GenericEmbossReservedAnonymousField3View final { bool Ok() const { if (!IsComplete()) return false; - if (!has_has_top().Known()) return false; - if (has_has_top().ValueOrDefault() && !has_top().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !has_top().Ok()) return false; + } - if (!has_has_bottom().Known()) return false; - if (has_has_bottom().ValueOrDefault() && !has_bottom().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !has_bottom().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -14443,28 +14879,48 @@ class GenericContainsBitsView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_emboss_reserved_anonymous_field_3().Known()) return false; - if (has_emboss_reserved_anonymous_field_3().ValueOrDefault() && !emboss_reserved_anonymous_field_3().Ok()) return false; + const auto emboss_reserved_local_ok_subexpr_1 = ::emboss::support::And(::emboss::support::Maybe(true), ::emboss::support::Maybe(true)); + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !emboss_reserved_anonymous_field_3().Ok()) return false; + } - if (!has_has_top().Known()) return false; - if (has_has_top().ValueOrDefault() && !has_top().Ok()) return false; + { + const auto emboss_reserved_local_field_present = emboss_reserved_local_ok_subexpr_1; + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !has_top().Ok()) return false; + } - if (!has_has_bottom().Known()) return false; - if (has_has_bottom().ValueOrDefault() && !has_bottom().Ok()) return false; + { + const auto emboss_reserved_local_field_present = emboss_reserved_local_ok_subexpr_1; + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !has_bottom().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -14920,24 +15376,40 @@ class GenericContainsContainsBitsView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_condition().Known()) return false; - if (has_condition().ValueOrDefault() && !condition().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !condition().Ok()) return false; + } - if (!has_top().Known()) return false; - if (has_top().ValueOrDefault() && !top().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Equal((condition().has_top().Ok() ? ::emboss::support::Maybe(static_cast(condition().has_top().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(1LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !top().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -15455,28 +15927,47 @@ class GenericType0View final { bool Ok() const { if (!IsComplete()) return false; - if (!has_a().Known()) return false; - if (has_a().ValueOrDefault() && !a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a().Ok()) return false; + } - if (!has_b().Known()) return false; - if (has_b().ValueOrDefault() && !b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b().Ok()) return false; + } - if (!has_c().Known()) return false; - if (has_c().ValueOrDefault() && !c().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !c().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -16038,28 +16529,47 @@ class GenericType1View final { bool Ok() const { if (!IsComplete()) return false; - if (!has_a().Known()) return false; - if (has_a().ValueOrDefault() && !a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a().Ok()) return false; + } - if (!has_b().Known()) return false; - if (has_b().ValueOrDefault() && !b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b().Ok()) return false; + } - if (!has_c().Known()) return false; - if (has_c().ValueOrDefault() && !c().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !c().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -16614,28 +17124,48 @@ class GenericConditionalInlineView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_payload_id().Known()) return false; - if (has_payload_id().ValueOrDefault() && !payload_id().Ok()) return false; + const auto emboss_reserved_local_ok_subexpr_1 = payload_id(); + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !payload_id().Ok()) return false; + } - if (!has_type_0().Known()) return false; - if (has_type_0().ValueOrDefault() && !type_0().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Equal((emboss_reserved_local_ok_subexpr_1.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_1.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(0LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !type_0().Ok()) return false; + } - if (!has_type_1().Known()) return false; - if (has_type_1().ValueOrDefault() && !type_1().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Equal((emboss_reserved_local_ok_subexpr_1.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_1.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(1LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !type_1().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -17232,28 +17762,47 @@ class GenericEmbossReservedAnonymousField2View final { bool Ok() const { if (!IsComplete()) return false; - if (!has_low().Known()) return false; - if (has_low().ValueOrDefault() && !low().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !low().Ok()) return false; + } - if (!has_mid().Known()) return false; - if (has_mid().ValueOrDefault() && !mid().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Equal((low().Ok() ? ::emboss::support::Maybe(static_cast(low().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(1LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !mid().Ok()) return false; + } - if (!has_high().Known()) return false; - if (has_high().ValueOrDefault() && !high().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !high().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -17808,36 +18357,62 @@ class GenericConditionalAnonymousView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + const auto emboss_reserved_local_ok_subexpr_1 = has_emboss_reserved_anonymous_field_2(); + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_emboss_reserved_anonymous_field_2().Known()) return false; - if (has_emboss_reserved_anonymous_field_2().ValueOrDefault() && !emboss_reserved_anonymous_field_2().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::GreaterThan((x().Ok() ? ::emboss::support::Maybe(static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(10LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !emboss_reserved_anonymous_field_2().Ok()) return false; + } - if (!has_low().Known()) return false; - if (has_low().ValueOrDefault() && !low().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::And(emboss_reserved_local_ok_subexpr_1, ::emboss::support::Maybe(true)); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !low().Ok()) return false; + } - if (!has_mid().Known()) return false; - if (has_mid().ValueOrDefault() && !mid().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::And(emboss_reserved_local_ok_subexpr_1, emboss_reserved_anonymous_field_2().has_mid()); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !mid().Ok()) return false; + } - if (!has_high().Known()) return false; - if (has_high().ValueOrDefault() && !high().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::And(emboss_reserved_local_ok_subexpr_1, ::emboss::support::Maybe(true)); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !high().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -18450,20 +19025,33 @@ class GenericEmbossReservedAnonymousField1View final { bool Ok() const { if (!IsComplete()) return false; - if (!has_enabled().Known()) return false; - if (has_enabled().ValueOrDefault() && !enabled().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !enabled().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -18864,28 +19452,47 @@ class GenericConditionalOnFlagView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_emboss_reserved_anonymous_field_1().Known()) return false; - if (has_emboss_reserved_anonymous_field_1().ValueOrDefault() && !emboss_reserved_anonymous_field_1().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !emboss_reserved_anonymous_field_1().Ok()) return false; + } - if (!has_enabled().Known()) return false; - if (has_enabled().ValueOrDefault() && !enabled().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::And(::emboss::support::Maybe(true), ::emboss::support::Maybe(true)); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !enabled().Ok()) return false; + } - if (!has_value().Known()) return false; - if (has_value().ValueOrDefault() && !value().Ok()) return false; + { + const auto emboss_reserved_local_field_present = (enabled().Ok() ? ::emboss::support::Maybe(static_cast(enabled().UncheckedRead())) : ::emboss::support::Maybe()); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !value().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/dynamic_size.emb.h b/testdata/golden_cpp/dynamic_size.emb.h index 8c5f5b5..cfbe3b7 100644 --- a/testdata/golden_cpp/dynamic_size.emb.h +++ b/testdata/golden_cpp/dynamic_size.emb.h @@ -174,36 +174,61 @@ class GenericMessageView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_header_length().Known()) return false; - if (has_header_length().ValueOrDefault() && !header_length().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !header_length().Ok()) return false; + } - if (!has_message_length().Known()) return false; - if (has_message_length().ValueOrDefault() && !message_length().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !message_length().Ok()) return false; + } - if (!has_padding().Known()) return false; - if (has_padding().ValueOrDefault() && !padding().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !padding().Ok()) return false; + } - if (!has_message().Known()) return false; - if (has_message().ValueOrDefault() && !message().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !message().Ok()) return false; + } - if (!has_crc32().Known()) return false; - if (has_crc32().ValueOrDefault() && !crc32().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !crc32().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -962,24 +987,40 @@ class GenericImageView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_size().Known()) return false; - if (has_size().ValueOrDefault() && !size().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !size().Ok()) return false; + } - if (!has_pixels().Known()) return false; - if (has_pixels().ValueOrDefault() && !pixels().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !pixels().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -1509,40 +1550,68 @@ class GenericTwoRegionsView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_b_end().Known()) return false; - if (has_b_end().ValueOrDefault() && !b_end().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b_end().Ok()) return false; + } - if (!has_b_start().Known()) return false; - if (has_b_start().ValueOrDefault() && !b_start().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b_start().Ok()) return false; + } - if (!has_a_size().Known()) return false; - if (has_a_size().ValueOrDefault() && !a_size().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a_size().Ok()) return false; + } - if (!has_a_start().Known()) return false; - if (has_a_start().ValueOrDefault() && !a_start().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a_start().Ok()) return false; + } - if (!has_region_a().Known()) return false; - if (has_region_a().ValueOrDefault() && !region_a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !region_a().Ok()) return false; + } - if (!has_region_b().Known()) return false; - if (has_region_b().ValueOrDefault() && !region_b().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !region_b().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -2381,28 +2450,47 @@ class GenericMultipliedSizeView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_width().Known()) return false; - if (has_width().ValueOrDefault() && !width().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !width().Ok()) return false; + } - if (!has_height().Known()) return false; - if (has_height().ValueOrDefault() && !height().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !height().Ok()) return false; + } - if (!has_data().Known()) return false; - if (has_data().ValueOrDefault() && !data().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !data().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -3006,52 +3094,89 @@ class GenericNegativeTermsInSizesView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_a().Known()) return false; - if (has_a().ValueOrDefault() && !a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a().Ok()) return false; + } - if (!has_b().Known()) return false; - if (has_b().ValueOrDefault() && !b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b().Ok()) return false; + } - if (!has_c().Known()) return false; - if (has_c().ValueOrDefault() && !c().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !c().Ok()) return false; + } - if (!has_a_minus_b().Known()) return false; - if (has_a_minus_b().ValueOrDefault() && !a_minus_b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a_minus_b().Ok()) return false; + } - if (!has_a_minus_2b().Known()) return false; - if (has_a_minus_2b().ValueOrDefault() && !a_minus_2b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a_minus_2b().Ok()) return false; + } - if (!has_a_minus_b_minus_c().Known()) return false; - if (has_a_minus_b_minus_c().ValueOrDefault() && !a_minus_b_minus_c().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a_minus_b_minus_c().Ok()) return false; + } - if (!has_ten_minus_a().Known()) return false; - if (has_ten_minus_a().ValueOrDefault() && !ten_minus_a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !ten_minus_a().Ok()) return false; + } - if (!has_a_minus_2c().Known()) return false; - if (has_a_minus_2c().ValueOrDefault() && !a_minus_2c().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a_minus_2c().Ok()) return false; + } - if (!has_a_minus_c().Known()) return false; - if (has_a_minus_c().ValueOrDefault() && !a_minus_c().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a_minus_c().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -4154,24 +4279,40 @@ class GenericNegativeTermInLocationView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_a().Known()) return false; - if (has_a().ValueOrDefault() && !a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a().Ok()) return false; + } - if (!has_b().Known()) return false; - if (has_b().ValueOrDefault() && !b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -4687,32 +4828,54 @@ class GenericChainedSizeView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_a().Known()) return false; - if (has_a().ValueOrDefault() && !a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a().Ok()) return false; + } - if (!has_b().Known()) return false; - if (has_b().ValueOrDefault() && !b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b().Ok()) return false; + } - if (!has_c().Known()) return false; - if (has_c().ValueOrDefault() && !c().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !c().Ok()) return false; + } - if (!has_d().Known()) return false; - if (has_d().ValueOrDefault() && !d().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !d().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -5388,28 +5551,47 @@ class GenericFinalFieldOverlapsView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_a().Known()) return false; - if (has_a().ValueOrDefault() && !a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a().Ok()) return false; + } - if (!has_b().Known()) return false; - if (has_b().ValueOrDefault() && !b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b().Ok()) return false; + } - if (!has_c().Known()) return false; - if (has_c().ValueOrDefault() && !c().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !c().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -5971,32 +6153,54 @@ class GenericDynamicFinalFieldOverlapsView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_a().Known()) return false; - if (has_a().ValueOrDefault() && !a().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a().Ok()) return false; + } - if (!has_b().Known()) return false; - if (has_b().ValueOrDefault() && !b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b().Ok()) return false; + } - if (!has_c().Known()) return false; - if (has_c().ValueOrDefault() && !c().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !c().Ok()) return false; + } - if (!has_d().Known()) return false; - if (has_d().ValueOrDefault() && !d().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !d().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -6666,24 +6870,40 @@ class GenericDynamicFieldDependsOnLaterFieldView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_a().Known()) return false; - if (has_a().ValueOrDefault() && !a().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a().Ok()) return false; + } - if (!has_b().Known()) return false; - if (has_b().ValueOrDefault() && !b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -7198,28 +7418,47 @@ class GenericDynamicFieldDoesNotAffectSizeView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_a().Known()) return false; - if (has_a().ValueOrDefault() && !a().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a().Ok()) return false; + } - if (!has_b().Known()) return false; - if (has_b().ValueOrDefault() && !b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b().Ok()) return false; + } - if (!has_c().Known()) return false; - if (has_c().ValueOrDefault() && !c().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !c().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/enum.emb.h b/testdata/golden_cpp/enum.emb.h index f056862..1d03fb6 100644 --- a/testdata/golden_cpp/enum.emb.h +++ b/testdata/golden_cpp/enum.emb.h @@ -139,24 +139,40 @@ class GenericConstantsView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_sprocket().Known()) return false; - if (has_sprocket().ValueOrDefault() && !sprocket().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !sprocket().Ok()) return false; + } - if (!has_geegaw().Known()) return false; - if (has_geegaw().ValueOrDefault() && !geegaw().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !geegaw().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -1546,20 +1562,33 @@ class GenericEmbossReservedAnonymousField1View final { bool Ok() const { if (!IsComplete()) return false; - if (!has_wide_kind_in_bits().Known()) return false; - if (has_wide_kind_in_bits().ValueOrDefault() && !wide_kind_in_bits().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !wide_kind_in_bits().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -1961,36 +1990,61 @@ class GenericManifestEntryView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_kind().Known()) return false; - if (has_kind().ValueOrDefault() && !kind().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !kind().Ok()) return false; + } - if (!has_count().Known()) return false; - if (has_count().ValueOrDefault() && !count().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !count().Ok()) return false; + } - if (!has_wide_kind().Known()) return false; - if (has_wide_kind().ValueOrDefault() && !wide_kind().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !wide_kind().Ok()) return false; + } - if (!has_emboss_reserved_anonymous_field_1().Known()) return false; - if (has_emboss_reserved_anonymous_field_1().ValueOrDefault() && !emboss_reserved_anonymous_field_1().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !emboss_reserved_anonymous_field_1().Ok()) return false; + } - if (!has_wide_kind_in_bits().Known()) return false; - if (has_wide_kind_in_bits().ValueOrDefault() && !wide_kind_in_bits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::And(::emboss::support::Maybe(true), ::emboss::support::Maybe(true)); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !wide_kind_in_bits().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -2720,20 +2774,33 @@ class GenericStructContainingEnumView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_bar().Known()) return false; - if (has_bar().ValueOrDefault() && !bar().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !bar().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/enum_case.emb.h b/testdata/golden_cpp/enum_case.emb.h index 5738596..4d6c432 100644 --- a/testdata/golden_cpp/enum_case.emb.h +++ b/testdata/golden_cpp/enum_case.emb.h @@ -334,28 +334,47 @@ class GenericUseKCamelEnumCaseView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_v().Known()) return false; - if (has_v().ValueOrDefault() && !v().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !v().Ok()) return false; + } - if (!has_first().Known()) return false; - if (has_first().ValueOrDefault() && !first().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !first().Ok()) return false; + } - if (!has_v_is_first().Known()) return false; - if (has_v_is_first().ValueOrDefault() && !v_is_first().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !v_is_first().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/explicit_sizes.emb.h b/testdata/golden_cpp/explicit_sizes.emb.h index f8fd46f..8005e47 100644 --- a/testdata/golden_cpp/explicit_sizes.emb.h +++ b/testdata/golden_cpp/explicit_sizes.emb.h @@ -118,28 +118,47 @@ class GenericSizedUIntArraysView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_one_nibble().Known()) return false; - if (has_one_nibble().ValueOrDefault() && !one_nibble().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !one_nibble().Ok()) return false; + } - if (!has_two_nibble().Known()) return false; - if (has_two_nibble().ValueOrDefault() && !two_nibble().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !two_nibble().Ok()) return false; + } - if (!has_four_nibble().Known()) return false; - if (has_four_nibble().ValueOrDefault() && !four_nibble().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !four_nibble().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -712,28 +731,47 @@ class GenericSizedIntArraysView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_one_nibble().Known()) return false; - if (has_one_nibble().ValueOrDefault() && !one_nibble().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !one_nibble().Ok()) return false; + } - if (!has_two_nibble().Known()) return false; - if (has_two_nibble().ValueOrDefault() && !two_nibble().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !two_nibble().Ok()) return false; + } - if (!has_four_nibble().Known()) return false; - if (has_four_nibble().ValueOrDefault() && !four_nibble().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !four_nibble().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -1306,28 +1344,47 @@ class GenericSizedEnumArraysView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_one_nibble().Known()) return false; - if (has_one_nibble().ValueOrDefault() && !one_nibble().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !one_nibble().Ok()) return false; + } - if (!has_two_nibble().Known()) return false; - if (has_two_nibble().ValueOrDefault() && !two_nibble().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !two_nibble().Ok()) return false; + } - if (!has_four_nibble().Known()) return false; - if (has_four_nibble().ValueOrDefault() && !four_nibble().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !four_nibble().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -1901,20 +1958,33 @@ class GenericBitArrayContainerView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_uint_arrays().Known()) return false; - if (has_uint_arrays().ValueOrDefault() && !uint_arrays().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !uint_arrays().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/float.emb.h b/testdata/golden_cpp/float.emb.h index d43d32e..c54aa66 100644 --- a/testdata/golden_cpp/float.emb.h +++ b/testdata/golden_cpp/float.emb.h @@ -99,24 +99,40 @@ class GenericFloatsView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_float_little_endian().Known()) return false; - if (has_float_little_endian().ValueOrDefault() && !float_little_endian().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !float_little_endian().Ok()) return false; + } - if (!has_float_big_endian().Known()) return false; - if (has_float_big_endian().ValueOrDefault() && !float_big_endian().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !float_big_endian().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -599,24 +615,40 @@ class GenericDoublesView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_double_little_endian().Known()) return false; - if (has_double_little_endian().ValueOrDefault() && !double_little_endian().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !double_little_endian().Ok()) return false; + } - if (!has_double_big_endian().Known()) return false; - if (has_double_big_endian().ValueOrDefault() && !double_big_endian().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !double_big_endian().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/imported.emb.h b/testdata/golden_cpp/imported.emb.h index 2217543..ce0cbea 100644 --- a/testdata/golden_cpp/imported.emb.h +++ b/testdata/golden_cpp/imported.emb.h @@ -90,20 +90,33 @@ class GenericInnerView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_value().Known()) return false; - if (has_value().ValueOrDefault() && !value().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !value().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/imported_genfiles.emb.h b/testdata/golden_cpp/imported_genfiles.emb.h index af1ef31..eb26bc9 100644 --- a/testdata/golden_cpp/imported_genfiles.emb.h +++ b/testdata/golden_cpp/imported_genfiles.emb.h @@ -91,20 +91,33 @@ class GenericInnerView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_value().Known()) return false; - if (has_value().ValueOrDefault() && !value().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !value().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/importer.emb.h b/testdata/golden_cpp/importer.emb.h index 75ad2d2..3c54911 100644 --- a/testdata/golden_cpp/importer.emb.h +++ b/testdata/golden_cpp/importer.emb.h @@ -95,24 +95,40 @@ class GenericOuterView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_inner().Known()) return false; - if (has_inner().ValueOrDefault() && !inner().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !inner().Ok()) return false; + } - if (!has_inner_gen().Known()) return false; - if (has_inner_gen().ValueOrDefault() && !inner_gen().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !inner_gen().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/importer2.emb.h b/testdata/golden_cpp/importer2.emb.h index ca22c93..8b99ad6 100644 --- a/testdata/golden_cpp/importer2.emb.h +++ b/testdata/golden_cpp/importer2.emb.h @@ -92,20 +92,33 @@ class GenericOuter2View final { bool Ok() const { if (!IsComplete()) return false; - if (!has_outer().Known()) return false; - if (has_outer().ValueOrDefault() && !outer().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !outer().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/inline_type.emb.h b/testdata/golden_cpp/inline_type.emb.h index 8f89827..0adbce3 100644 --- a/testdata/golden_cpp/inline_type.emb.h +++ b/testdata/golden_cpp/inline_type.emb.h @@ -272,24 +272,40 @@ class GenericFooView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_status().Known()) return false; - if (has_status().ValueOrDefault() && !status().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !status().Ok()) return false; + } - if (!has_secondary_status().Known()) return false; - if (has_secondary_status().ValueOrDefault() && !secondary_status().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !secondary_status().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/int_sizes.emb.h b/testdata/golden_cpp/int_sizes.emb.h index fe697e9..ddb7e4d 100644 --- a/testdata/golden_cpp/int_sizes.emb.h +++ b/testdata/golden_cpp/int_sizes.emb.h @@ -97,48 +97,82 @@ class GenericSizesView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_one_byte().Known()) return false; - if (has_one_byte().ValueOrDefault() && !one_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !one_byte().Ok()) return false; + } - if (!has_two_byte().Known()) return false; - if (has_two_byte().ValueOrDefault() && !two_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !two_byte().Ok()) return false; + } - if (!has_three_byte().Known()) return false; - if (has_three_byte().ValueOrDefault() && !three_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !three_byte().Ok()) return false; + } - if (!has_four_byte().Known()) return false; - if (has_four_byte().ValueOrDefault() && !four_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !four_byte().Ok()) return false; + } - if (!has_five_byte().Known()) return false; - if (has_five_byte().ValueOrDefault() && !five_byte().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !five_byte().Ok()) return false; + } - if (!has_six_byte().Known()) return false; - if (has_six_byte().ValueOrDefault() && !six_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !six_byte().Ok()) return false; + } - if (!has_seven_byte().Known()) return false; - if (has_seven_byte().ValueOrDefault() && !seven_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !seven_byte().Ok()) return false; + } - if (!has_eight_byte().Known()) return false; - if (has_eight_byte().ValueOrDefault() && !eight_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !eight_byte().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/large_array.emb.h b/testdata/golden_cpp/large_array.emb.h index 47b4511..81048d8 100644 --- a/testdata/golden_cpp/large_array.emb.h +++ b/testdata/golden_cpp/large_array.emb.h @@ -91,24 +91,40 @@ class GenericUIntArrayView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_element_count().Known()) return false; - if (has_element_count().ValueOrDefault() && !element_count().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !element_count().Ok()) return false; + } - if (!has_elements().Known()) return false; - if (has_elements().ValueOrDefault() && !elements().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !elements().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/nested_structure.emb.h b/testdata/golden_cpp/nested_structure.emb.h index b953e31..9da33ea 100644 --- a/testdata/golden_cpp/nested_structure.emb.h +++ b/testdata/golden_cpp/nested_structure.emb.h @@ -108,28 +108,47 @@ class GenericContainerView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_weight().Known()) return false; - if (has_weight().ValueOrDefault() && !weight().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !weight().Ok()) return false; + } - if (!has_important_box().Known()) return false; - if (has_important_box().ValueOrDefault() && !important_box().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !important_box().Ok()) return false; + } - if (!has_other_box().Known()) return false; - if (has_other_box().ValueOrDefault() && !other_box().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !other_box().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -685,24 +704,40 @@ class GenericBoxView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_id().Known()) return false; - if (has_id().ValueOrDefault() && !id().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !id().Ok()) return false; + } - if (!has_count().Known()) return false; - if (has_count().ValueOrDefault() && !count().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !count().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -1185,24 +1220,40 @@ class GenericTruckView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_id().Known()) return false; - if (has_id().ValueOrDefault() && !id().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !id().Ok()) return false; + } - if (!has_cargo().Known()) return false; - if (has_cargo().ValueOrDefault() && !cargo().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !cargo().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/next_keyword.emb.h b/testdata/golden_cpp/next_keyword.emb.h index 624c954..eb40049 100644 --- a/testdata/golden_cpp/next_keyword.emb.h +++ b/testdata/golden_cpp/next_keyword.emb.h @@ -93,32 +93,54 @@ class GenericNextKeywordView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_value32().Known()) return false; - if (has_value32().ValueOrDefault() && !value32().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !value32().Ok()) return false; + } - if (!has_value16().Known()) return false; - if (has_value16().ValueOrDefault() && !value16().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !value16().Ok()) return false; + } - if (!has_value8().Known()) return false; - if (has_value8().ValueOrDefault() && !value8().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !value8().Ok()) return false; + } - if (!has_value8_offset().Known()) return false; - if (has_value8_offset().ValueOrDefault() && !value8_offset().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !value8_offset().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/no_enum_traits.emb.h b/testdata/golden_cpp/no_enum_traits.emb.h index 5f97e05..c0aaafa 100644 --- a/testdata/golden_cpp/no_enum_traits.emb.h +++ b/testdata/golden_cpp/no_enum_traits.emb.h @@ -14,10 +14,6 @@ #include "runtime/cpp/emboss_prelude.h" -#include "runtime/cpp/emboss_enum_view.h" - -#include "runtime/cpp/emboss_text_util.h" - /* NOLINTBEGIN */ @@ -38,79 +34,6 @@ enum class Foo : ::std::uint64_t { VALUE = static_cast(10LL), }; -template -class EnumTraits; - -template <> -class EnumTraits final { - public: - static bool TryToGetEnumFromName(const char *emboss_reserved_local_name, - Foo *emboss_reserved_local_result) { - if (emboss_reserved_local_name == nullptr) return false; - if (!strcmp("VALUE", emboss_reserved_local_name)) { - *emboss_reserved_local_result = Foo::VALUE; - return true; - } - - return false; - } - - static const char *TryToGetNameFromEnum( - Foo emboss_reserved_local_value) { - switch (emboss_reserved_local_value) { - case Foo::VALUE: return "VALUE"; - - default: return nullptr; - } - } - - static bool EnumIsKnown(Foo emboss_reserved_local_value) { - switch (emboss_reserved_local_value) { - case Foo::VALUE: return true; - - default: - return false; - } - } - - static ::std::ostream &SendToOstream(::std::ostream &emboss_reserved_local_os, - Foo emboss_reserved_local_value) { - const char *emboss_reserved_local_name = - TryToGetNameFromEnum(emboss_reserved_local_value); - if (emboss_reserved_local_name == nullptr) { - emboss_reserved_local_os - << static_cast::type>( - emboss_reserved_local_value); - } else { - emboss_reserved_local_os << emboss_reserved_local_name; - } - return emboss_reserved_local_os; - } -}; - -static inline bool TryToGetEnumFromName( - const char *emboss_reserved_local_name, - Foo *emboss_reserved_local_result) { - return EnumTraits::TryToGetEnumFromName( - emboss_reserved_local_name, emboss_reserved_local_result); -} - -static inline const char *TryToGetNameFromEnum( - Foo emboss_reserved_local_value) { - return EnumTraits::TryToGetNameFromEnum( - emboss_reserved_local_value); -} - -static inline bool EnumIsKnown(Foo emboss_reserved_local_value) { - return EnumTraits::EnumIsKnown(emboss_reserved_local_value); -} - -static inline ::std::ostream &operator<<( - ::std::ostream &emboss_reserved_local_os, - Foo emboss_reserved_local_value) { - return EnumTraits::SendToOstream(emboss_reserved_local_os, - emboss_reserved_local_value); -} @@ -169,20 +92,33 @@ class GenericBarView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_foo().Known()) return false; - if (has_foo().ValueOrDefault() && !foo().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !foo().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -265,92 +201,6 @@ class GenericBarView final { emboss_reserved_local_other.IntrinsicSizeInBytes().Read()); } - template - bool UpdateFromTextStream(Stream *emboss_reserved_local_stream) const { - ::std::string emboss_reserved_local_brace; - if (!::emboss::support::ReadToken(emboss_reserved_local_stream, - &emboss_reserved_local_brace)) - return false; - if (emboss_reserved_local_brace != "{") return false; - for (;;) { - ::std::string emboss_reserved_local_name; - if (!::emboss::support::ReadToken(emboss_reserved_local_stream, - &emboss_reserved_local_name)) - return false; - if (emboss_reserved_local_name == ",") - if (!::emboss::support::ReadToken(emboss_reserved_local_stream, - &emboss_reserved_local_name)) - return false; - if (emboss_reserved_local_name == "}") return true; - ::std::string emboss_reserved_local_colon; - if (!::emboss::support::ReadToken(emboss_reserved_local_stream, - &emboss_reserved_local_colon)) - return false; - if (emboss_reserved_local_colon != ":") return false; - if (emboss_reserved_local_name == "foo") { - if (!foo().UpdateFromTextStream( - emboss_reserved_local_stream)) { - return false; - } - continue; - } - - return false; - } - } - - template - void WriteToTextStream( - Stream *emboss_reserved_local_stream, - ::emboss::TextOutputOptions emboss_reserved_local_options) const { - ::emboss::TextOutputOptions emboss_reserved_local_field_options = - emboss_reserved_local_options.PlusOneIndent(); - if (emboss_reserved_local_options.multiline()) { - emboss_reserved_local_stream->Write("{\n"); - } else { - emboss_reserved_local_stream->Write("{"); - } - bool emboss_reserved_local_wrote_field = false; - if (has_foo().ValueOr(false)) { - if (!emboss_reserved_local_field_options.allow_partial_output() || - foo().IsAggregate() || foo().Ok()) { - if (emboss_reserved_local_field_options.multiline()) { - emboss_reserved_local_stream->Write( - emboss_reserved_local_field_options.current_indent()); - } else { - if (emboss_reserved_local_wrote_field) { - emboss_reserved_local_stream->Write(","); - } - emboss_reserved_local_stream->Write(" "); - } - emboss_reserved_local_stream->Write("foo: "); - foo().WriteToTextStream(emboss_reserved_local_stream, - emboss_reserved_local_field_options); - emboss_reserved_local_wrote_field = true; - if (emboss_reserved_local_field_options.multiline()) { - emboss_reserved_local_stream->Write("\n"); - } - } else if (emboss_reserved_local_field_options.allow_partial_output() && - emboss_reserved_local_field_options.comments() && - !foo().IsAggregate() && !foo().Ok()) { - if (emboss_reserved_local_field_options.multiline()) { - emboss_reserved_local_stream->Write( - emboss_reserved_local_field_options.current_indent()); - } - emboss_reserved_local_stream->Write("# foo: UNREADABLE\n"); - } - } - - (void)emboss_reserved_local_wrote_field; - if (emboss_reserved_local_options.multiline()) { - emboss_reserved_local_stream->Write( - emboss_reserved_local_options.current_indent()); - emboss_reserved_local_stream->Write("}"); - } else { - emboss_reserved_local_stream->Write(" }"); - } - } - static constexpr bool IsAggregate() { return true; } diff --git a/testdata/golden_cpp/parameters.emb.h b/testdata/golden_cpp/parameters.emb.h index d60f164..b6c33ae 100644 --- a/testdata/golden_cpp/parameters.emb.h +++ b/testdata/golden_cpp/parameters.emb.h @@ -388,32 +388,55 @@ class GenericMultiVersionView final { bool Ok() const { if (!IsComplete()) return false; if (!parameters_initialized_) return false; - if (!has_message_id().Known()) return false; - if (has_message_id().ValueOrDefault() && !message_id().Ok()) return false; + const auto emboss_reserved_local_ok_subexpr_1 = message_id(); + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !message_id().Ok()) return false; + } - if (!has_axes().Known()) return false; - if (has_axes().ValueOrDefault() && !axes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Equal((emboss_reserved_local_ok_subexpr_1.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_1.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(0))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !axes().Ok()) return false; + } - if (!has_config().Known()) return false; - if (has_config().ValueOrDefault() && !config().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Equal((emboss_reserved_local_ok_subexpr_1.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_1.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(1))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !config().Ok()) return false; + } - if (!has_config_vx().Known()) return false; - if (has_config_vx().ValueOrDefault() && !config_vx().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::And(::emboss::support::Equal((product().Ok() ? ::emboss::support::Maybe(static_cast(product().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(23))), ::emboss::support::Equal((emboss_reserved_local_ok_subexpr_1.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_1.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(1)))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !config_vx().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -1129,36 +1152,62 @@ class GenericAxesView final { bool Ok() const { if (!IsComplete()) return false; if (!parameters_initialized_) return false; - if (!has_values().Known()) return false; - if (has_values().ValueOrDefault() && !values().Ok()) return false; + const auto emboss_reserved_local_ok_subexpr_1 = axes(); + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !values().Ok()) return false; + } - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::GreaterThan((emboss_reserved_local_ok_subexpr_1.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_1.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(0LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_y().Known()) return false; - if (has_y().ValueOrDefault() && !y().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::GreaterThan((emboss_reserved_local_ok_subexpr_1.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_1.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(1LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !y().Ok()) return false; + } - if (!has_z().Known()) return false; - if (has_z().ValueOrDefault() && !z().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::GreaterThan((emboss_reserved_local_ok_subexpr_1.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_1.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(2LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !z().Ok()) return false; + } - if (!has_axis_count_plus_one().Known()) return false; - if (has_axis_count_plus_one().ValueOrDefault() && !axis_count_plus_one().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !axis_count_plus_one().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -1961,32 +2010,54 @@ class GenericAxisPairView final { bool Ok() const { if (!IsComplete()) return false; if (!parameters_initialized_) return false; - if (!has_axis_type_a().Known()) return false; - if (has_axis_type_a().ValueOrDefault() && !axis_type_a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !axis_type_a().Ok()) return false; + } - if (!has_axis_a().Known()) return false; - if (has_axis_a().ValueOrDefault() && !axis_a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !axis_a().Ok()) return false; + } - if (!has_axis_type_b().Known()) return false; - if (has_axis_type_b().ValueOrDefault() && !axis_type_b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !axis_type_b().Ok()) return false; + } - if (!has_axis_b().Known()) return false; - if (has_axis_b().ValueOrDefault() && !axis_b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !axis_b().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -2716,24 +2787,40 @@ class GenericAxesEnvelopeView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_axis_count().Known()) return false; - if (has_axis_count().ValueOrDefault() && !axis_count().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !axis_count().Ok()) return false; + } - if (!has_axes().Known()) return false; - if (has_axes().ValueOrDefault() && !axes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !axes().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -3356,36 +3443,62 @@ class GenericAxisView final { bool Ok() const { if (!IsComplete()) return false; if (!parameters_initialized_) return false; - if (!has_value().Known()) return false; - if (has_value().ValueOrDefault() && !value().Ok()) return false; + const auto emboss_reserved_local_ok_subexpr_1 = axis_type(); + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !value().Ok()) return false; + } - if (!has_axis_type().Known()) return false; - if (has_axis_type().ValueOrDefault() && !axis_type().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !axis_type().Ok()) return false; + } - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Equal((emboss_reserved_local_ok_subexpr_1.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_1.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(1))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_y().Known()) return false; - if (has_y().ValueOrDefault() && !y().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Equal((emboss_reserved_local_ok_subexpr_1.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_1.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(2))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !y().Ok()) return false; + } - if (!has_z().Known()) return false; - if (has_z().ValueOrDefault() && !z().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Equal((emboss_reserved_local_ok_subexpr_1.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_1.UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(3))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !z().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -4146,20 +4259,33 @@ class GenericConfigView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_power().Known()) return false; - if (has_power().ValueOrDefault() && !power().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !power().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -4570,20 +4696,33 @@ class GenericEmbossReservedAnonymousField1View final { bool Ok() const { if (!IsComplete()) return false; - if (!has_power().Known()) return false; - if (has_power().ValueOrDefault() && !power().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !power().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -4984,28 +5123,47 @@ class GenericConfigVXView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_emboss_reserved_anonymous_field_1().Known()) return false; - if (has_emboss_reserved_anonymous_field_1().ValueOrDefault() && !emboss_reserved_anonymous_field_1().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !emboss_reserved_anonymous_field_1().Ok()) return false; + } - if (!has_power().Known()) return false; - if (has_power().ValueOrDefault() && !power().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::And(::emboss::support::Maybe(true), ::emboss::support::Maybe(true)); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !power().Ok()) return false; + } - if (!has_gain().Known()) return false; - if (has_gain().ValueOrDefault() && !gain().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !gain().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -5493,20 +5651,33 @@ class GenericStructWithUnusedParameterView final { bool Ok() const { if (!IsComplete()) return false; if (!parameters_initialized_) return false; - if (!has_y().Known()) return false; - if (has_y().ValueOrDefault() && !y().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !y().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -5955,24 +6126,40 @@ class GenericStructContainingStructWithUnusedParameterView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_swup().Known()) return false; - if (has_swup().ValueOrDefault() && !swup().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !swup().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -6454,24 +6641,40 @@ class GenericBiasedValueView final { bool Ok() const { if (!IsComplete()) return false; if (!parameters_initialized_) return false; - if (!has_raw_value().Known()) return false; - if (has_raw_value().ValueOrDefault() && !raw_value().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !raw_value().Ok()) return false; + } - if (!has_value().Known()) return false; - if (has_value().ValueOrDefault() && !value().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !value().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -7006,24 +7209,40 @@ class GenericVirtualFirstFieldWithParamView final { bool Ok() const { if (!IsComplete()) return false; if (!parameters_initialized_) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_value().Known()) return false; - if (has_value().ValueOrDefault() && !value().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !value().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -7518,24 +7737,40 @@ class GenericConstVirtualFirstFieldWithParamView final { bool Ok() const { if (!IsComplete()) return false; if (!parameters_initialized_) return false; - if (!has_value().Known()) return false; - if (has_value().ValueOrDefault() && !value().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !value().Ok()) return false; + } - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -8039,28 +8274,47 @@ class GenericSizedArrayOfBiasedValuesView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_element_count().Known()) return false; - if (has_element_count().ValueOrDefault() && !element_count().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !element_count().Ok()) return false; + } - if (!has_bias().Known()) return false; - if (has_bias().ValueOrDefault() && !bias().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !bias().Ok()) return false; + } - if (!has_values().Known()) return false; - if (has_values().ValueOrDefault() && !values().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !values().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/requires.emb.h b/testdata/golden_cpp/requires.emb.h index 500813b..1d2c250 100644 --- a/testdata/golden_cpp/requires.emb.h +++ b/testdata/golden_cpp/requires.emb.h @@ -192,40 +192,68 @@ class GenericRequiresIntegersView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_zero_through_nine().Known()) return false; - if (has_zero_through_nine().ValueOrDefault() && !zero_through_nine().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !zero_through_nine().Ok()) return false; + } - if (!has_ten_through_twenty().Known()) return false; - if (has_ten_through_twenty().ValueOrDefault() && !ten_through_twenty().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !ten_through_twenty().Ok()) return false; + } - if (!has_disjoint().Known()) return false; - if (has_disjoint().ValueOrDefault() && !disjoint().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !disjoint().Ok()) return false; + } - if (!has_ztn_plus_ttt().Known()) return false; - if (has_ztn_plus_ttt().ValueOrDefault() && !ztn_plus_ttt().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !ztn_plus_ttt().Ok()) return false; + } - if (!has_alias_of_zero_through_nine().Known()) return false; - if (has_alias_of_zero_through_nine().ValueOrDefault() && !alias_of_zero_through_nine().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !alias_of_zero_through_nine().Ok()) return false; + } - if (!has_zero_through_nine_plus_five().Known()) return false; - if (has_zero_through_nine_plus_five().ValueOrDefault() && !zero_through_nine_plus_five().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !zero_through_nine_plus_five().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } if (!(::emboss::support::LessThanOrEqual((zero_through_nine().Ok() ? ::emboss::support::Maybe(static_cast(zero_through_nine().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Difference((ten_through_twenty().Ok() ? ::emboss::support::Maybe(static_cast(ten_through_twenty().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(10LL))))).ValueOr(false)) @@ -1166,32 +1194,54 @@ class GenericEmbossReservedAnonymousField2View final { bool Ok() const { if (!IsComplete()) return false; - if (!has_a().Known()) return false; - if (has_a().ValueOrDefault() && !a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a().Ok()) return false; + } - if (!has_b().Known()) return false; - if (has_b().ValueOrDefault() && !b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b().Ok()) return false; + } - if (!has_must_be_true().Known()) return false; - if (has_must_be_true().ValueOrDefault() && !must_be_true().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !must_be_true().Ok()) return false; + } - if (!has_must_be_false().Known()) return false; - if (has_must_be_false().ValueOrDefault() && !must_be_false().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !must_be_false().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -1823,44 +1873,76 @@ class GenericRequiresBoolsView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_emboss_reserved_anonymous_field_2().Known()) return false; - if (has_emboss_reserved_anonymous_field_2().ValueOrDefault() && !emboss_reserved_anonymous_field_2().Ok()) return false; + const auto emboss_reserved_local_ok_subexpr_1 = ::emboss::support::And(::emboss::support::Maybe(true), ::emboss::support::Maybe(true)); + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !emboss_reserved_anonymous_field_2().Ok()) return false; + } - if (!has_a().Known()) return false; - if (has_a().ValueOrDefault() && !a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = emboss_reserved_local_ok_subexpr_1; + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a().Ok()) return false; + } - if (!has_b().Known()) return false; - if (has_b().ValueOrDefault() && !b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = emboss_reserved_local_ok_subexpr_1; + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b().Ok()) return false; + } - if (!has_must_be_true().Known()) return false; - if (has_must_be_true().ValueOrDefault() && !must_be_true().Ok()) return false; + { + const auto emboss_reserved_local_field_present = emboss_reserved_local_ok_subexpr_1; + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !must_be_true().Ok()) return false; + } - if (!has_must_be_false().Known()) return false; - if (has_must_be_false().ValueOrDefault() && !must_be_false().Ok()) return false; + { + const auto emboss_reserved_local_field_present = emboss_reserved_local_ok_subexpr_1; + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !must_be_false().Ok()) return false; + } - if (!has_b_must_be_false().Known()) return false; - if (has_b_must_be_false().ValueOrDefault() && !b_must_be_false().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b_must_be_false().Ok()) return false; + } - if (!has_alias_of_a_must_be_true().Known()) return false; - if (has_alias_of_a_must_be_true().ValueOrDefault() && !alias_of_a_must_be_true().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !alias_of_a_must_be_true().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } if (!(::emboss::support::Or((a().Ok() ? ::emboss::support::Maybe(static_cast(a().UncheckedRead())) : ::emboss::support::Maybe()), (b().Ok() ? ::emboss::support::Maybe(static_cast(b().UncheckedRead())) : ::emboss::support::Maybe()))).ValueOr(false)) @@ -2741,36 +2823,61 @@ class GenericRequiresEnumsView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_a().Known()) return false; - if (has_a().ValueOrDefault() && !a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a().Ok()) return false; + } - if (!has_b().Known()) return false; - if (has_b().ValueOrDefault() && !b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b().Ok()) return false; + } - if (!has_c().Known()) return false; - if (has_c().ValueOrDefault() && !c().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !c().Ok()) return false; + } - if (!has_filtered_a().Known()) return false; - if (has_filtered_a().ValueOrDefault() && !filtered_a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !filtered_a().Ok()) return false; + } - if (!has_alias_of_a().Known()) return false; - if (has_alias_of_a().ValueOrDefault() && !alias_of_a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !alias_of_a().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } if (!(::emboss::support::Or(::emboss::support::Equal((a().Ok() ? ::emboss::support::Maybe(static_cast(a().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(0))), ::emboss::support::Equal((b().Ok() ? ::emboss::support::Maybe(static_cast(b().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(0))))).ValueOr(false)) @@ -3569,32 +3676,55 @@ class GenericEmbossReservedAnonymousField1View final { bool Ok() const { if (!IsComplete()) return false; - if (!has_a().Known()) return false; - if (has_a().ValueOrDefault() && !a().Ok()) return false; + const auto emboss_reserved_local_ok_subexpr_1 = b_exists(); + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a().Ok()) return false; + } - if (!has_b_exists().Known()) return false; - if (has_b_exists().ValueOrDefault() && !b_exists().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b_exists().Ok()) return false; + } - if (!has_b().Known()) return false; - if (has_b().ValueOrDefault() && !b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = (emboss_reserved_local_ok_subexpr_1.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_1.UncheckedRead())) : ::emboss::support::Maybe()); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b().Ok()) return false; + } - if (!has_b_true().Known()) return false; - if (has_b_true().ValueOrDefault() && !b_true().Ok()) return false; + { + const auto emboss_reserved_local_field_present = (emboss_reserved_local_ok_subexpr_1.Ok() ? ::emboss::support::Maybe(static_cast(emboss_reserved_local_ok_subexpr_1.UncheckedRead())) : ::emboss::support::Maybe()); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b_true().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -4255,36 +4385,62 @@ class GenericRequiresWithOptionalFieldsView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_emboss_reserved_anonymous_field_1().Known()) return false; - if (has_emboss_reserved_anonymous_field_1().ValueOrDefault() && !emboss_reserved_anonymous_field_1().Ok()) return false; + const auto emboss_reserved_local_ok_subexpr_1 = ::emboss::support::And(::emboss::support::Maybe(true), ::emboss::support::Maybe(true)); + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !emboss_reserved_anonymous_field_1().Ok()) return false; + } - if (!has_a().Known()) return false; - if (has_a().ValueOrDefault() && !a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = emboss_reserved_local_ok_subexpr_1; + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a().Ok()) return false; + } - if (!has_b_exists().Known()) return false; - if (has_b_exists().ValueOrDefault() && !b_exists().Ok()) return false; + { + const auto emboss_reserved_local_field_present = emboss_reserved_local_ok_subexpr_1; + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b_exists().Ok()) return false; + } - if (!has_b().Known()) return false; - if (has_b().ValueOrDefault() && !b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::And(::emboss::support::Maybe(true), emboss_reserved_anonymous_field_1().has_b()); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b().Ok()) return false; + } - if (!has_b_true().Known()) return false; - if (has_b_true().ValueOrDefault() && !b_true().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::And(::emboss::support::Maybe(true), emboss_reserved_anonymous_field_1().has_b_true()); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b_true().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } if (!(::emboss::support::Or((a().Ok() ? ::emboss::support::Maybe(static_cast(a().UncheckedRead())) : ::emboss::support::Maybe()), (b().Ok() ? ::emboss::support::Maybe(static_cast(b().UncheckedRead())) : ::emboss::support::Maybe()))).ValueOr(false)) @@ -4847,20 +5003,33 @@ class GenericElementView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -5261,20 +5430,33 @@ class GenericRequiresInArrayElementsView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_xs().Known()) return false; - if (has_xs().ValueOrDefault() && !xs().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xs().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/start_size_range.emb.h b/testdata/golden_cpp/start_size_range.emb.h index d9f0166..f4f3c71 100644 --- a/testdata/golden_cpp/start_size_range.emb.h +++ b/testdata/golden_cpp/start_size_range.emb.h @@ -93,32 +93,54 @@ class GenericStartSizeView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_size().Known()) return false; - if (has_size().ValueOrDefault() && !size().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !size().Ok()) return false; + } - if (!has_start_size_constants().Known()) return false; - if (has_start_size_constants().ValueOrDefault() && !start_size_constants().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !start_size_constants().Ok()) return false; + } - if (!has_payload().Known()) return false; - if (has_payload().ValueOrDefault() && !payload().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !payload().Ok()) return false; + } - if (!has_counter().Known()) return false; - if (has_counter().ValueOrDefault() && !counter().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !counter().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/subtypes.emb.h b/testdata/golden_cpp/subtypes.emb.h index 860d554..5177de1 100644 --- a/testdata/golden_cpp/subtypes.emb.h +++ b/testdata/golden_cpp/subtypes.emb.h @@ -226,28 +226,47 @@ class GenericInInView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_outer_offset().Known()) return false; - if (has_outer_offset().ValueOrDefault() && !outer_offset().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !outer_offset().Ok()) return false; + } - if (!has_field_enum().Known()) return false; - if (has_field_enum().ValueOrDefault() && !field_enum().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !field_enum().Ok()) return false; + } - if (!has_in_2().Known()) return false; - if (has_in_2().ValueOrDefault() && !in_2().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !in_2().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -778,40 +797,68 @@ class GenericInView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_in_in_1().Known()) return false; - if (has_in_in_1().ValueOrDefault() && !in_in_1().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !in_in_1().Ok()) return false; + } - if (!has_in_in_2().Known()) return false; - if (has_in_in_2().ValueOrDefault() && !in_in_2().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !in_in_2().Ok()) return false; + } - if (!has_in_in_in_1().Known()) return false; - if (has_in_in_in_1().ValueOrDefault() && !in_in_in_1().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !in_in_in_1().Ok()) return false; + } - if (!has_in_2().Known()) return false; - if (has_in_2().ValueOrDefault() && !in_2().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !in_2().Ok()) return false; + } - if (!has_name_collision().Known()) return false; - if (has_name_collision().ValueOrDefault() && !name_collision().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !name_collision().Ok()) return false; + } - if (!has_name_collision_check().Known()) return false; - if (has_name_collision_check().ValueOrDefault() && !name_collision_check().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !name_collision_check().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -1627,20 +1674,33 @@ class GenericIn2View final { bool Ok() const { if (!IsComplete()) return false; - if (!has_field_byte().Known()) return false; - if (has_field_byte().ValueOrDefault() && !field_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !field_byte().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -2041,48 +2101,82 @@ class GenericOutView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_in_1().Known()) return false; - if (has_in_1().ValueOrDefault() && !in_1().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !in_1().Ok()) return false; + } - if (!has_in_2().Known()) return false; - if (has_in_2().ValueOrDefault() && !in_2().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !in_2().Ok()) return false; + } - if (!has_in_in_1().Known()) return false; - if (has_in_in_1().ValueOrDefault() && !in_in_1().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !in_in_1().Ok()) return false; + } - if (!has_in_in_2().Known()) return false; - if (has_in_in_2().ValueOrDefault() && !in_in_2().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !in_in_2().Ok()) return false; + } - if (!has_in_in_in_1().Known()) return false; - if (has_in_in_in_1().ValueOrDefault() && !in_in_in_1().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !in_in_in_1().Ok()) return false; + } - if (!has_in_in_in_2().Known()) return false; - if (has_in_in_in_2().ValueOrDefault() && !in_in_in_2().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !in_in_in_2().Ok()) return false; + } - if (!has_name_collision().Known()) return false; - if (has_name_collision().ValueOrDefault() && !name_collision().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !name_collision().Ok()) return false; + } - if (!has_nested_constant_check().Known()) return false; - if (has_nested_constant_check().ValueOrDefault() && !nested_constant_check().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !nested_constant_check().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/text_format.emb.h b/testdata/golden_cpp/text_format.emb.h index 46f257d..5103a11 100644 --- a/testdata/golden_cpp/text_format.emb.h +++ b/testdata/golden_cpp/text_format.emb.h @@ -107,24 +107,40 @@ class GenericVanillaView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_a().Known()) return false; - if (has_a().ValueOrDefault() && !a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a().Ok()) return false; + } - if (!has_b().Known()) return false; - if (has_b().ValueOrDefault() && !b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -608,28 +624,47 @@ class GenericStructWithSkippedFieldsView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_a().Known()) return false; - if (has_a().ValueOrDefault() && !a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a().Ok()) return false; + } - if (!has_b().Known()) return false; - if (has_b().ValueOrDefault() && !b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b().Ok()) return false; + } - if (!has_c().Known()) return false; - if (has_c().ValueOrDefault() && !c().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !c().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -1160,28 +1195,47 @@ class GenericStructWithSkippedStructureFieldsView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_a().Known()) return false; - if (has_a().ValueOrDefault() && !a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a().Ok()) return false; + } - if (!has_b().Known()) return false; - if (has_b().ValueOrDefault() && !b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b().Ok()) return false; + } - if (!has_c().Known()) return false; - if (has_c().ValueOrDefault() && !c().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !c().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/uint_sizes.emb.h b/testdata/golden_cpp/uint_sizes.emb.h index df5eb3f..60c8780 100644 --- a/testdata/golden_cpp/uint_sizes.emb.h +++ b/testdata/golden_cpp/uint_sizes.emb.h @@ -149,48 +149,82 @@ class GenericSizesView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_one_byte().Known()) return false; - if (has_one_byte().ValueOrDefault() && !one_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !one_byte().Ok()) return false; + } - if (!has_two_byte().Known()) return false; - if (has_two_byte().ValueOrDefault() && !two_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !two_byte().Ok()) return false; + } - if (!has_three_byte().Known()) return false; - if (has_three_byte().ValueOrDefault() && !three_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !three_byte().Ok()) return false; + } - if (!has_four_byte().Known()) return false; - if (has_four_byte().ValueOrDefault() && !four_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !four_byte().Ok()) return false; + } - if (!has_five_byte().Known()) return false; - if (has_five_byte().ValueOrDefault() && !five_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !five_byte().Ok()) return false; + } - if (!has_six_byte().Known()) return false; - if (has_six_byte().ValueOrDefault() && !six_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !six_byte().Ok()) return false; + } - if (!has_seven_byte().Known()) return false; - if (has_seven_byte().ValueOrDefault() && !seven_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !seven_byte().Ok()) return false; + } - if (!has_eight_byte().Known()) return false; - if (has_eight_byte().ValueOrDefault() && !eight_byte().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !eight_byte().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -1141,48 +1175,82 @@ class GenericBigEndianSizesView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_one_byte().Known()) return false; - if (has_one_byte().ValueOrDefault() && !one_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !one_byte().Ok()) return false; + } - if (!has_two_byte().Known()) return false; - if (has_two_byte().ValueOrDefault() && !two_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !two_byte().Ok()) return false; + } - if (!has_three_byte().Known()) return false; - if (has_three_byte().ValueOrDefault() && !three_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !three_byte().Ok()) return false; + } - if (!has_four_byte().Known()) return false; - if (has_four_byte().ValueOrDefault() && !four_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !four_byte().Ok()) return false; + } - if (!has_five_byte().Known()) return false; - if (has_five_byte().ValueOrDefault() && !five_byte().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !five_byte().Ok()) return false; + } - if (!has_six_byte().Known()) return false; - if (has_six_byte().ValueOrDefault() && !six_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !six_byte().Ok()) return false; + } - if (!has_seven_byte().Known()) return false; - if (has_seven_byte().ValueOrDefault() && !seven_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !seven_byte().Ok()) return false; + } - if (!has_eight_byte().Known()) return false; - if (has_eight_byte().ValueOrDefault() && !eight_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !eight_byte().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -2133,48 +2201,82 @@ class GenericAlternatingEndianSizesView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_one_byte().Known()) return false; - if (has_one_byte().ValueOrDefault() && !one_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !one_byte().Ok()) return false; + } - if (!has_two_byte().Known()) return false; - if (has_two_byte().ValueOrDefault() && !two_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !two_byte().Ok()) return false; + } - if (!has_three_byte().Known()) return false; - if (has_three_byte().ValueOrDefault() && !three_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !three_byte().Ok()) return false; + } - if (!has_four_byte().Known()) return false; - if (has_four_byte().ValueOrDefault() && !four_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !four_byte().Ok()) return false; + } - if (!has_five_byte().Known()) return false; - if (has_five_byte().ValueOrDefault() && !five_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !five_byte().Ok()) return false; + } - if (!has_six_byte().Known()) return false; - if (has_six_byte().ValueOrDefault() && !six_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !six_byte().Ok()) return false; + } - if (!has_seven_byte().Known()) return false; - if (has_seven_byte().ValueOrDefault() && !seven_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !seven_byte().Ok()) return false; + } - if (!has_eight_byte().Known()) return false; - if (has_eight_byte().ValueOrDefault() && !eight_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !eight_byte().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -3125,48 +3227,82 @@ class GenericEnumSizesView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_one_byte().Known()) return false; - if (has_one_byte().ValueOrDefault() && !one_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !one_byte().Ok()) return false; + } - if (!has_two_byte().Known()) return false; - if (has_two_byte().ValueOrDefault() && !two_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !two_byte().Ok()) return false; + } - if (!has_three_byte().Known()) return false; - if (has_three_byte().ValueOrDefault() && !three_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !three_byte().Ok()) return false; + } - if (!has_four_byte().Known()) return false; - if (has_four_byte().ValueOrDefault() && !four_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !four_byte().Ok()) return false; + } - if (!has_five_byte().Known()) return false; - if (has_five_byte().ValueOrDefault() && !five_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !five_byte().Ok()) return false; + } - if (!has_six_byte().Known()) return false; - if (has_six_byte().ValueOrDefault() && !six_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !six_byte().Ok()) return false; + } - if (!has_seven_byte().Known()) return false; - if (has_seven_byte().ValueOrDefault() && !seven_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !seven_byte().Ok()) return false; + } - if (!has_eight_byte().Known()) return false; - if (has_eight_byte().ValueOrDefault() && !eight_byte().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !eight_byte().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -4126,20 +4262,33 @@ class GenericEmbossReservedAnonymousField1View final { bool Ok() const { if (!IsComplete()) return false; - if (!has_three_and_a_half_byte().Known()) return false; - if (has_three_and_a_half_byte().ValueOrDefault() && !three_and_a_half_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !three_and_a_half_byte().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -4541,36 +4690,61 @@ class GenericExplicitlySizedEnumSizesView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_one_byte().Known()) return false; - if (has_one_byte().ValueOrDefault() && !one_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !one_byte().Ok()) return false; + } - if (!has_two_byte().Known()) return false; - if (has_two_byte().ValueOrDefault() && !two_byte().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !two_byte().Ok()) return false; + } - if (!has_three_byte().Known()) return false; - if (has_three_byte().ValueOrDefault() && !three_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !three_byte().Ok()) return false; + } - if (!has_emboss_reserved_anonymous_field_1().Known()) return false; - if (has_emboss_reserved_anonymous_field_1().ValueOrDefault() && !emboss_reserved_anonymous_field_1().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !emboss_reserved_anonymous_field_1().Ok()) return false; + } - if (!has_three_and_a_half_byte().Known()) return false; - if (has_three_and_a_half_byte().ValueOrDefault() && !three_and_a_half_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::And(::emboss::support::Maybe(true), ::emboss::support::Maybe(true)); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !three_and_a_half_byte().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -5515,48 +5689,82 @@ class GenericArraySizesView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_one_byte().Known()) return false; - if (has_one_byte().ValueOrDefault() && !one_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !one_byte().Ok()) return false; + } - if (!has_two_byte().Known()) return false; - if (has_two_byte().ValueOrDefault() && !two_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !two_byte().Ok()) return false; + } - if (!has_three_byte().Known()) return false; - if (has_three_byte().ValueOrDefault() && !three_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !three_byte().Ok()) return false; + } - if (!has_four_byte().Known()) return false; - if (has_four_byte().ValueOrDefault() && !four_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !four_byte().Ok()) return false; + } - if (!has_five_byte().Known()) return false; - if (has_five_byte().ValueOrDefault() && !five_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !five_byte().Ok()) return false; + } - if (!has_six_byte().Known()) return false; - if (has_six_byte().ValueOrDefault() && !six_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !six_byte().Ok()) return false; + } - if (!has_seven_byte().Known()) return false; - if (has_seven_byte().ValueOrDefault() && !seven_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !seven_byte().Ok()) return false; + } - if (!has_eight_byte().Known()) return false; - if (has_eight_byte().ValueOrDefault() && !eight_byte().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !eight_byte().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } diff --git a/testdata/golden_cpp/virtual_field.emb.h b/testdata/golden_cpp/virtual_field.emb.h index 140020a..d2544ed 100644 --- a/testdata/golden_cpp/virtual_field.emb.h +++ b/testdata/golden_cpp/virtual_field.emb.h @@ -253,56 +253,96 @@ class GenericStructureWithConstantsView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_ten().Known()) return false; - if (has_ten().ValueOrDefault() && !ten().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !ten().Ok()) return false; + } - if (!has_twenty().Known()) return false; - if (has_twenty().ValueOrDefault() && !twenty().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !twenty().Ok()) return false; + } - if (!has_four_billion().Known()) return false; - if (has_four_billion().ValueOrDefault() && !four_billion().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !four_billion().Ok()) return false; + } - if (!has_ten_billion().Known()) return false; - if (has_ten_billion().ValueOrDefault() && !ten_billion().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !ten_billion().Ok()) return false; + } - if (!has_minus_ten_billion().Known()) return false; - if (has_minus_ten_billion().ValueOrDefault() && !minus_ten_billion().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !minus_ten_billion().Ok()) return false; + } - if (!has_value().Known()) return false; - if (has_value().ValueOrDefault() && !value().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !value().Ok()) return false; + } - if (!has_alias_of_value().Known()) return false; - if (has_alias_of_value().ValueOrDefault() && !alias_of_value().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !alias_of_value().Ok()) return false; + } - if (!has_alias_of_alias_of_value().Known()) return false; - if (has_alias_of_alias_of_value().ValueOrDefault() && !alias_of_alias_of_value().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !alias_of_alias_of_value().Ok()) return false; + } - if (!has_alias_of_ten().Known()) return false; - if (has_alias_of_ten().ValueOrDefault() && !alias_of_ten().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !alias_of_ten().Ok()) return false; + } - if (!has_alias_of_alias_of_ten().Known()) return false; - if (has_alias_of_alias_of_ten().ValueOrDefault() && !alias_of_alias_of_ten().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !alias_of_alias_of_ten().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -1181,44 +1221,75 @@ class GenericStructureWithComputedValuesView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_value().Known()) return false; - if (has_value().ValueOrDefault() && !value().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !value().Ok()) return false; + } - if (!has_doubled().Known()) return false; - if (has_doubled().ValueOrDefault() && !doubled().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !doubled().Ok()) return false; + } - if (!has_plus_ten().Known()) return false; - if (has_plus_ten().ValueOrDefault() && !plus_ten().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !plus_ten().Ok()) return false; + } - if (!has_value2().Known()) return false; - if (has_value2().ValueOrDefault() && !value2().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !value2().Ok()) return false; + } - if (!has_signed_doubled().Known()) return false; - if (has_signed_doubled().ValueOrDefault() && !signed_doubled().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !signed_doubled().Ok()) return false; + } - if (!has_signed_plus_ten().Known()) return false; - if (has_signed_plus_ten().ValueOrDefault() && !signed_plus_ten().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !signed_plus_ten().Ok()) return false; + } - if (!has_product().Known()) return false; - if (has_product().ValueOrDefault() && !product().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !product().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -2211,28 +2282,47 @@ class GenericStructureWithConditionalValueView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_two_x().Known()) return false; - if (has_two_x().ValueOrDefault() && !two_x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::LessThan((x().Ok() ? ::emboss::support::Maybe(static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(2147483648ULL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !two_x().Ok()) return false; + } - if (!has_x_plus_one().Known()) return false; - if (has_x_plus_one().ValueOrDefault() && !x_plus_one().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x_plus_one().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -2851,28 +2941,47 @@ class GenericStructureWithValueInConditionView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_two_x().Known()) return false; - if (has_two_x().ValueOrDefault() && !two_x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !two_x().Ok()) return false; + } - if (!has_if_two_x_lt_100().Known()) return false; - if (has_if_two_x_lt_100().ValueOrDefault() && !if_two_x_lt_100().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::LessThan((two_x().Ok() ? ::emboss::support::Maybe(static_cast(two_x().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(100LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !if_two_x_lt_100().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -3470,32 +3579,54 @@ class GenericStructureWithValuesInLocationView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_two_x().Known()) return false; - if (has_two_x().ValueOrDefault() && !two_x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !two_x().Ok()) return false; + } - if (!has_offset_two_x().Known()) return false; - if (has_offset_two_x().ValueOrDefault() && !offset_two_x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !offset_two_x().Ok()) return false; + } - if (!has_size_two_x().Known()) return false; - if (has_size_two_x().ValueOrDefault() && !size_two_x().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !size_two_x().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -4170,24 +4301,40 @@ class GenericStructureWithBoolValueView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_x_is_ten().Known()) return false; - if (has_x_is_ten().ValueOrDefault() && !x_is_ten().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x_is_ten().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -4763,24 +4910,40 @@ class GenericStructureWithEnumValueView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_x_size().Known()) return false; - if (has_x_size().ValueOrDefault() && !x_size().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x_size().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -5271,28 +5434,47 @@ class GenericStructureWithBitsWithValueView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_b().Known()) return false; - if (has_b().ValueOrDefault() && !b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b().Ok()) return false; + } - if (!has_alias_of_b_sum().Known()) return false; - if (has_alias_of_b_sum().ValueOrDefault() && !alias_of_b_sum().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !alias_of_b_sum().Ok()) return false; + } - if (!has_alias_of_b_a().Known()) return false; - if (has_alias_of_b_a().ValueOrDefault() && !alias_of_b_a().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !alias_of_b_a().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -5824,28 +6006,47 @@ class GenericBitsWithValueView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_a().Known()) return false; - if (has_a().ValueOrDefault() && !a().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a().Ok()) return false; + } - if (!has_b().Known()) return false; - if (has_b().ValueOrDefault() && !b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !b().Ok()) return false; + } - if (!has_sum().Known()) return false; - if (has_sum().ValueOrDefault() && !sum().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !sum().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -6413,24 +6614,40 @@ class GenericStructureUsingForeignConstantsView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_one_hundred().Known()) return false; - if (has_one_hundred().ValueOrDefault() && !one_hundred().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !one_hundred().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -6896,24 +7113,40 @@ class GenericHeaderView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_size().Known()) return false; - if (has_size().ValueOrDefault() && !size().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !size().Ok()) return false; + } - if (!has_message_id().Known()) return false; - if (has_message_id().ValueOrDefault() && !message_id().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !message_id().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -7391,28 +7624,47 @@ class GenericSubfieldOfAliasView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_header().Known()) return false; - if (has_header().ValueOrDefault() && !header().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !header().Ok()) return false; + } - if (!has_h().Known()) return false; - if (has_h().ValueOrDefault() && !h().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !h().Ok()) return false; + } - if (!has_size().Known()) return false; - if (has_size().ValueOrDefault() && !size().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !size().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -7907,28 +8159,47 @@ class GenericRestrictedAliasView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_a_b().Known()) return false; - if (has_a_b().ValueOrDefault() && !a_b().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a_b().Ok()) return false; + } - if (!has_alias_switch().Known()) return false; - if (has_alias_switch().ValueOrDefault() && !alias_switch().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !alias_switch().Ok()) return false; + } - if (!has_a_b_alias().Known()) return false; - if (has_a_b_alias().ValueOrDefault() && !a_b_alias().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::GreaterThan((alias_switch().Ok() ? ::emboss::support::Maybe(static_cast(alias_switch().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(10LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !a_b_alias().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -8461,24 +8732,40 @@ class GenericXView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_v().Known()) return false; - if (has_v().ValueOrDefault() && !v().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !v().Ok()) return false; + } - if (!has_y().Known()) return false; - if (has_y().ValueOrDefault() && !y().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::GreaterThan((v().Ok() ? ::emboss::support::Maybe(static_cast(v().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(10LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !y().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -8986,32 +9273,54 @@ class GenericHasFieldView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_z().Known()) return false; - if (has_z().ValueOrDefault() && !z().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !z().Ok()) return false; + } - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::GreaterThan((z().Ok() ? ::emboss::support::Maybe(static_cast(z().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(10LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_y().Known()) return false; - if (has_y().ValueOrDefault() && !y().Ok()) return false; + { + const auto emboss_reserved_local_field_present = x().has_y(); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !y().Ok()) return false; + } - if (!has_x_has_y().Known()) return false; - if (has_x_has_y().ValueOrDefault() && !x_has_y().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = has_x(); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x_has_y().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -9649,28 +9958,47 @@ class GenericVirtualUnconditionallyUsesConditionalView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_xc().Known()) return false; - if (has_xc().ValueOrDefault() && !xc().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Equal((x().Ok() ? ::emboss::support::Maybe(static_cast(x().UncheckedRead())) : ::emboss::support::Maybe()), ::emboss::support::Maybe(static_cast(0LL))); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !xc().Ok()) return false; + } - if (!has_x_nor_xc().Known()) return false; - if (has_x_nor_xc().ValueOrDefault() && !x_nor_xc().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x_nor_xc().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -10275,24 +10603,40 @@ class GenericRView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_q().Known()) return false; - if (has_q().ValueOrDefault() && !q().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !q().Ok()) return false; + } - if (!has_IntrinsicSizeInBits().Known()) return false; - if (has_IntrinsicSizeInBits().ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBits().Ok()) return false; + } - if (!has_q_plus_bit_size().Known()) return false; - if (has_q_plus_bit_size().ValueOrDefault() && !q_plus_bit_size().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !q_plus_bit_size().Ok()) return false; + } - if (!has_MaxSizeInBits().Known()) return false; - if (has_MaxSizeInBits().ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBits().Ok()) return false; + } - if (!has_MinSizeInBits().Known()) return false; - if (has_MinSizeInBits().ValueOrDefault() && !MinSizeInBits().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBits().Ok()) return false; + } @@ -10776,24 +11120,40 @@ class GenericUsesSizeView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_r().Known()) return false; - if (has_r().ValueOrDefault() && !r().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !r().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_r_q_plus_byte_size().Known()) return false; - if (has_r_q_plus_byte_size().ValueOrDefault() && !r_q_plus_byte_size().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !r_q_plus_byte_size().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -11280,24 +11640,40 @@ class GenericUsesExternalSizeView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_y().Known()) return false; - if (has_y().ValueOrDefault() && !y().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !y().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } @@ -11780,40 +12156,68 @@ class GenericImplicitWriteBackView final { bool Ok() const { if (!IsComplete()) return false; - if (!has_x().Known()) return false; - if (has_x().ValueOrDefault() && !x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x().Ok()) return false; + } - if (!has_x_plus_ten().Known()) return false; - if (has_x_plus_ten().ValueOrDefault() && !x_plus_ten().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x_plus_ten().Ok()) return false; + } - if (!has_ten_plus_x().Known()) return false; - if (has_ten_plus_x().ValueOrDefault() && !ten_plus_x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !ten_plus_x().Ok()) return false; + } - if (!has_x_minus_ten().Known()) return false; - if (has_x_minus_ten().ValueOrDefault() && !x_minus_ten().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !x_minus_ten().Ok()) return false; + } - if (!has_ten_minus_x().Known()) return false; - if (has_ten_minus_x().ValueOrDefault() && !ten_minus_x().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !ten_minus_x().Ok()) return false; + } - if (!has_ten_minus_x_plus_ten().Known()) return false; - if (has_ten_minus_x_plus_ten().ValueOrDefault() && !ten_minus_x_plus_ten().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !ten_minus_x_plus_ten().Ok()) return false; + } - if (!has_IntrinsicSizeInBytes().Known()) return false; - if (has_IntrinsicSizeInBytes().ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !IntrinsicSizeInBytes().Ok()) return false; + } - if (!has_MaxSizeInBytes().Known()) return false; - if (has_MaxSizeInBytes().ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MaxSizeInBytes().Ok()) return false; + } - if (!has_MinSizeInBytes().Known()) return false; - if (has_MinSizeInBytes().ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + + { + const auto emboss_reserved_local_field_present = ::emboss::support::Maybe(true); + if (!emboss_reserved_local_field_present.Known()) return false; + if (emboss_reserved_local_field_present.ValueOrDefault() && !MinSizeInBytes().Ok()) return false; + } From d1f447bf0265214db54be71e6c35232122295cce Mon Sep 17 00:00:00 2001 From: Aaron Webster Date: Wed, 3 Dec 2025 11:32:07 -0800 Subject: [PATCH 8/9] Fix repeated --import_dirs in cpp_golden_test --- compiler/back_end/cpp/build_defs.bzl | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/compiler/back_end/cpp/build_defs.bzl b/compiler/back_end/cpp/build_defs.bzl index 3775466..1a18716 100644 --- a/compiler/back_end/cpp/build_defs.bzl +++ b/compiler/back_end/cpp/build_defs.bzl @@ -56,6 +56,11 @@ def cpp_golden_test(name, emb_file, golden_file, import_dirs = [], extra_args = import_dirs: A list of import directories. extra_args: A list of extra arguments to pass to the compiler. """ + unique_import_dirs = [] + for d in import_dirs: + if d not in unique_import_dirs: + unique_import_dirs.append(d) + py_test( name = name, main = ":run_one_golden_test.py", @@ -66,13 +71,13 @@ def cpp_golden_test(name, emb_file, golden_file, import_dirs = [], extra_args = "$(location :emboss_codegen_cpp)", "$(location %s)" % emb_file, "$(location %s)" % golden_file, - ] + ["--import-dir=" + d for d in import_dirs] + extra_args, + ] + ["--import-dir=" + d for d in unique_import_dirs] + extra_args, data = [ "//compiler/front_end:emboss_front_end", ":emboss_codegen_cpp", emb_file, golden_file, "//testdata:test_embs", - ] + import_dirs, + ] + unique_import_dirs, deps = [":one_golden_test_lib"], ) From f81827b1a932bcac20634206ca196a600a381d1c Mon Sep 17 00:00:00 2001 From: Aaron Webster Date: Wed, 3 Dec 2025 11:36:03 -0800 Subject: [PATCH 9/9] Format python files with black --- compiler/util/parser_types.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/util/parser_types.py b/compiler/util/parser_types.py index a3ef34d..89cb186 100644 --- a/compiler/util/parser_types.py +++ b/compiler/util/parser_types.py @@ -15,7 +15,7 @@ """Types related to the LR(1) parser. This module contains types used by the LR(1) parser, which are also used in -other parts of the compiler: +other parts of the compiler: SourcePosition: a position (zero-width) within a source file. SourceLocation: a span within a source file.