Qualify function names in generated preconditions

This also fixes the code generation for message fields with a sequence
type name equal to the package name.

Ref. #691

CHANGELOG.md

@@ -105,6 +105,7 @@ Generator:
   - Boolean relations containing global variables (#1059)
   - Minimal session (#883)
   - Message aggregates with variables as field values (#1064)
+  - Message fields with a sequence type name equal to the package name
 - Code generation when using non-default prefix (#897)
 - Conversion between message `Structure` and `Context` (#961)
 - Missing reset in assignment to comprehension (#1050)

rflx/generator/common.py

@@ -49,6 +49,7 @@
     Variable,
     WithClause,
 )
+from rflx.const import BUILTINS_PACKAGE
 
 from . import const
 
@@ -689,10 +690,12 @@ def context_cursor_unchanged(
     ]
 
 
-def sufficient_space_for_field_condition(field_name: Name, size: Expr = None) -> Expr:
+def sufficient_space_for_field_condition(
+    message_id: ID, field_name: Name, size: Expr = None
+) -> Expr:
     if size is None:
-        size = Call("Field_Size", [Variable("Ctx"), field_name])
-    return GreaterEqual(Call("Available_Space", [Variable("Ctx"), field_name]), size)
+        size = Call(message_id * "Field_Size", [Variable("Ctx"), field_name])
+    return GreaterEqual(Call(message_id * "Available_Space", [Variable("Ctx"), field_name]), size)
 
 
 def initialize_field_statements(
@@ -788,30 +791,41 @@ def field_bit_location_declarations(field_name: Name) -> Sequence[Declaration]:
 
 
 def field_condition_call(
+    prefix: str,
     message: model.Message,
     field: model.Field,
     value: Expr = None,
     aggregate: Expr = None,
     size: Expr = None,
 ) -> Expr:
+    package = ID(prefix * message.identifier)
     if value is None:
         value = Number(0)
     if aggregate is None:
         aggregate = EMPTY_ARRAY
     if size is None:
-        size = Call("Field_Size", [Variable("Ctx"), Variable(field.affixed_name)])
+        size = Call(
+            package * "Field_Size",
+            [Variable("Ctx"), Variable(package * field.affixed_name)],
+        )
     return Call(
-        "Field_Condition",
+        package * "Field_Condition",
         [
             Variable("Ctx"),
-            Variable(field.affixed_name),
+            Variable(package * field.affixed_name),
             *([value] if has_value_dependent_condition(message) else []),
             *([aggregate] if has_aggregate_dependent_condition(message) else []),
             *([size] if has_size_dependent_condition(message, field) else []),
         ],
     )
 
 
+def to_base_integer(prefix: str, type_package: rid.ID) -> ID:
+    if type_package == BUILTINS_PACKAGE:
+        return ID("To_Base_Integer")
+    return prefix * ID(type_package) * "To_Base_Integer"
+
+
 def ada_type_identifier(type_identifier: rid.ID) -> ID:
     if model.is_builtin_type(type_identifier):
         return ID(type_identifier.name)
@@ -1075,12 +1089,12 @@ def context_cursors_initialization(message: model.Message) -> Expr:
     )
 
 
-def byte_aligned_field(field: model.Field) -> Expr:
+def byte_aligned_field(prefix: str, message: model.Message, field: model.Field) -> Expr:
     return Equal(
         Rem(
             Call(
-                "Field_First",
-                [Variable("Ctx"), Variable(field.affixed_name)],
+                ID(prefix * message.identifier * "Field_First"),
+                [Variable("Ctx"), Variable(ID(prefix * message.identifier * field.affixed_name))],
             ),
             Size(const.TYPES_BYTE),
         ),

rflx/generator/generator.py

@@ -424,65 +424,93 @@ def _create_message(self, message: Message) -> dict[ID, Unit]:
             self._executor.submit(
                 message_generator.create_restricted_initialize_procedure, message
             ),
-            self._executor.submit(message_generator.create_initialized_function, message),
-            self._executor.submit(message_generator.create_reset_procedure, message),
-            self._executor.submit(message_generator.create_restricted_reset_procedure, message),
-            self._executor.submit(message_generator.create_take_buffer_procedure, message),
-            self._executor.submit(message_generator.create_copy_procedure),
-            self._executor.submit(message_generator.create_read_function),
-            self._executor.submit(message_generator.create_generic_read_procedure),
-            self._executor.submit(message_generator.create_generic_write_procedure, message),
+            self._executor.submit(
+                message_generator.create_initialized_function, self._prefix, message
+            ),
+            self._executor.submit(message_generator.create_reset_procedure, self._prefix, message),
+            self._executor.submit(
+                message_generator.create_restricted_reset_procedure, self._prefix, message
+            ),
+            self._executor.submit(
+                message_generator.create_take_buffer_procedure, self._prefix, message
+            ),
+            self._executor.submit(message_generator.create_copy_procedure, self._prefix, message),
+            self._executor.submit(message_generator.create_read_function, self._prefix, message),
+            self._executor.submit(
+                message_generator.create_generic_read_procedure, self._prefix, message
+            ),
+            self._executor.submit(
+                message_generator.create_generic_write_procedure, self._prefix, message
+            ),
             self._executor.submit(message_generator.create_has_buffer_function),
-            self._executor.submit(message_generator.create_buffer_length_function),
+            self._executor.submit(
+                message_generator.create_buffer_length_function, self._prefix, message
+            ),
             self._executor.submit(message_generator.create_size_function),
             self._executor.submit(message_generator.create_byte_size_function),
-            self._executor.submit(message_generator.create_message_last_function),
+            self._executor.submit(
+                message_generator.create_message_last_function, self._prefix, message
+            ),
             self._executor.submit(message_generator.create_written_last_function),
-            self._executor.submit(message_generator.create_data_procedure),
+            self._executor.submit(message_generator.create_data_procedure, self._prefix, message),
             self._executor.submit(
-                message_generator.create_valid_value_function, message, scalar_fields, self._prefix
+                message_generator.create_valid_value_function, self._prefix, message, scalar_fields
             ),
             self._executor.submit(
-                message_generator.create_path_condition_function, message, self._prefix
+                message_generator.create_path_condition_function, self._prefix, message
             ),
             self._executor.submit(
-                message_generator.create_field_condition_function, message, self._prefix
+                message_generator.create_field_condition_function, self._prefix, message
             ),
             self._executor.submit(
                 message_generator.create_field_size_function,
+                self._prefix,
                 message,
                 scalar_fields,
                 composite_fields,
-                self._prefix,
             ),
             self._executor.submit(
-                message_generator.create_field_first_function, message, self._prefix
+                message_generator.create_field_first_function, self._prefix, message
             ),
             self._executor.submit(
-                message_generator.create_field_last_function, scalar_fields, composite_fields
+                message_generator.create_field_last_function,
+                self._prefix,
+                message,
+                scalar_fields,
+                composite_fields,
             ),
             self._executor.submit(message_generator.create_predecessor_function),
             self._executor.submit(
-                message_generator.create_successor_function, message, self._prefix
+                message_generator.create_successor_function, self._prefix, message
             ),
             self._executor.submit(
-                message_generator.create_valid_predecessor_function, message, composite_fields
+                message_generator.create_valid_predecessor_function,
+                message,
+                composite_fields,
             ),
             self._executor.submit(message_generator.create_invalid_successor_function, message),
             self._executor.submit(message_generator.create_valid_next_function),
-            self._executor.submit(message_generator.create_available_space_function),
-            self._executor.submit(message_generator.create_sufficient_buffer_length_function),
+            self._executor.submit(
+                message_generator.create_available_space_function, self._prefix, message
+            ),
+            self._executor.submit(
+                message_generator.create_sufficient_buffer_length_function, self._prefix, message
+            ),
             *(
                 [
                     self._executor.submit(
-                        message_generator.create_equal_function, scalar_fields, composite_fields
+                        message_generator.create_equal_function,
+                        self._prefix,
+                        message,
+                        scalar_fields,
+                        composite_fields,
                     )
                 ]
                 if composite_fields
                 else []
             ),
             self._executor.submit(
-                message_generator.create_reset_dependent_fields_procedure, message
+                message_generator.create_reset_dependent_fields_procedure, self._prefix, message
             ),
             *(
                 [
@@ -514,14 +542,20 @@ def _create_message(self, message: Message) -> dict[ID, Unit]:
             ),
             self._executor.submit(parser_generator.create_valid_message_function, message),
             self._executor.submit(parser_generator.create_incomplete_message_function),
-            self._executor.submit(parser_generator.create_scalar_getter_functions, scalar_fields),
-            self._executor.submit(parser_generator.create_opaque_getter_functions, opaque_fields),
-            self._executor.submit(parser_generator.create_opaque_getter_procedures, opaque_fields),
             self._executor.submit(
-                parser_generator.create_generic_opaque_getter_procedures, opaque_fields
+                parser_generator.create_scalar_getter_functions, message, scalar_fields
+            ),
+            self._executor.submit(
+                parser_generator.create_opaque_getter_functions, message, opaque_fields
+            ),
+            self._executor.submit(
+                parser_generator.create_opaque_getter_procedures, message, opaque_fields
+            ),
+            self._executor.submit(
+                parser_generator.create_generic_opaque_getter_procedures, message, opaque_fields
             ),
             self._executor.submit(serializer_generator.create_valid_size_function, message),
-            self._executor.submit(serializer_generator.create_valid_length_function),
+            self._executor.submit(serializer_generator.create_valid_length_function, message),
             self._executor.submit(
                 serializer_generator.create_set_procedure, message, scalar_fields, composite_fields
             ),
@@ -545,18 +579,18 @@ def _create_message(self, message: Message) -> dict[ID, Unit]:
                 serializer_generator.create_generic_opaque_setter_procedures, message
             ),
             self._executor.submit(
-                message_generator.create_switch_procedures, message, sequence_fields, self._prefix
+                message_generator.create_switch_procedures, self._prefix, message, sequence_fields
             ),
             self._executor.submit(
-                message_generator.create_complete_functions, message, sequence_fields
+                message_generator.create_complete_functions, self._prefix, message, sequence_fields
             ),
             self._executor.submit(
-                message_generator.create_update_procedures, message, sequence_fields
+                message_generator.create_update_procedures, self._prefix, message, sequence_fields
             ),
             self._executor.submit(message_generator.create_cursor_function),
             self._executor.submit(message_generator.create_cursors_function),
             self._executor.submit(message_generator.create_cursors_index_function),
-            self._executor.submit(message_generator.create_structure, message, self._prefix),
+            self._executor.submit(message_generator.create_structure, self._prefix, message),
         ]
 
         for future in futures:
@@ -1003,7 +1037,13 @@ def _create_switch_procedure(
                                         refinement, pdu_context, condition_fields, null_sdu=False
                                     )
                                 ],
-                                Call(contains_function_name(refinement), [Variable(pdu_context)]),
+                                Call(
+                                    self._prefix
+                                    * ID(refinement.package)
+                                    * const.REFINEMENT_PACKAGE
+                                    * contains_function_name(refinement),
+                                    [Variable(pdu_context)],
+                                ),
                             )
                         ),
                         Postcondition(
@@ -1146,7 +1186,13 @@ def _create_copy_refined_field_procedure(
                                         refinement, pdu_context, condition_fields, null_sdu=False
                                     )
                                 ],
-                                Call(contains_function_name(refinement), [Variable(pdu_context)]),
+                                Call(
+                                    self._prefix
+                                    * ID(refinement.package)
+                                    * const.REFINEMENT_PACKAGE
+                                    * contains_function_name(refinement),
+                                    [Variable(pdu_context)],
+                                ),
                                 GreaterEqual(
                                     Add(
                                         Call(