ci: enable standard ROS lint checks

Signed-off-by: Esteve Fernandez <esteve@apache.org>

Author: esteve

rosidl_generator_rs/CMakeLists.txt

@@ -24,11 +24,6 @@ if(BUILD_TESTING)
     APPEND_ENV PYTHONPATH=${CMAKE_CURRENT_SOURCE_DIR}
   )
 
-  # The Python sources are checked by Ruff in CI. Copyright and docstring
-  # linters are noisy for template files in this generator package.
-  set(ament_cmake_copyright_FOUND TRUE)
-  set(ament_cmake_flake8_FOUND TRUE)
-  set(ament_cmake_pep257_FOUND TRUE)
   ament_lint_auto_find_test_dependencies()
 endif()
 

rosidl_generator_rs/bin/rosidl_generator_rs

@@ -1,4 +1,19 @@
 #!/usr/bin/env python3
+# Copyright 2018-2026 Esteve Fernandez <esteve@apache.org>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Command line entry point for the Rust ROS interface generator."""
 
 import argparse
 import os
@@ -16,13 +31,16 @@ except ImportError:
         raise
     from importlib.machinery import SourceFileLoader
 
-    loader = SourceFileLoader('rosidl_generator_rs', rosidl_generator_rs_module)
+    loader = SourceFileLoader(
+        'rosidl_generator_rs', rosidl_generator_rs_module)
     rosidl_generator_rs = loader.load_module()
     generate_rs = rosidl_generator_rs.generate_rs
 
 
 def main(argv=sys.argv[1:]):
-    parser = argparse.ArgumentParser(description='Generate the Rust ROS interfaces.')
+    """Run the generator command line interface."""
+    parser = argparse.ArgumentParser(
+        description='Generate the Rust ROS interfaces.')
     parser.add_argument(
         '--generator-arguments-file',
         required=True,

rosidl_generator_rs/cmake/custom_command.cmake

@@ -1,4 +1,4 @@
-# Copyright 2017 Esteve Fernandez <esteve@apache.org>
+# Copyright 2018-2026 Esteve Fernandez <esteve@apache.org>
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

rosidl_generator_rs/cmake/register_rs.cmake

@@ -1,4 +1,4 @@
-# Copyright 2016-2017 Esteve Fernandez <esteve@apache.org>
+# Copyright 2018-2026 Esteve Fernandez <esteve@apache.org>
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

rosidl_generator_rs/cmake/rosidl_generator_rs_generate_interfaces.cmake

@@ -1,4 +1,4 @@
-# Copyright 2016-2017 Esteve Fernandez <esteve@apache.org>
+# Copyright 2018-2026 Esteve Fernandez <esteve@apache.org>
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

rosidl_generator_rs/package.xml

@@ -10,7 +10,7 @@
 
   <buildtool_depend>ament_cmake</buildtool_depend>
   <buildtool_depend>ros_environment</buildtool_depend>
-  
+
   <!-- <buildtool_depend>rosidl_runtime_rs</buildtool_depend> -->
 
   <buildtool_export_depend>ament_cmake</buildtool_export_depend>
@@ -29,6 +29,9 @@
 
   <test_depend>ament_cmake_gtest</test_depend>
   <test_depend>ament_cmake_pytest</test_depend>
+  <test_depend>ament_cmake_copyright</test_depend>
+  <test_depend>ament_cmake_flake8</test_depend>
+  <test_depend>ament_cmake_pep257</test_depend>
   <test_depend>ament_lint_auto</test_depend>
   <test_depend>ament_lint_common</test_depend>
   <test_depend condition="humble >= $ROS_DISTRO">rosidl_cmake</test_depend>

rosidl_generator_rs/rosidl_generator_rs/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2016-2017 Esteve Fernandez <esteve@apache.org>
+# Copyright 2018-2026 Esteve Fernandez <esteve@apache.org>
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+"""Generate Rust code for ROS interfaces."""
+
 import os
 import pathlib
 
@@ -55,12 +57,15 @@ def _removesuffix(s, suffix):
 
 package_name = ""
 
+
 # Taken from http://stackoverflow.com/a/6425628
 def convert_lower_case_underscore_to_camel_case(word):
+    """Convert a lower-case underscore name to CamelCase."""
     return ''.join(x.capitalize() or '_' for x in word.split('_'))
 
 
 def generate_rs(generator_arguments_file, typesupport_impls):
+    """Generate Rust code from rosidl generator arguments."""
     args = rosidl_pycommon.read_generator_arguments(generator_arguments_file)
 
     global package_name
@@ -215,30 +220,38 @@ def generate_rs(generator_arguments_file, typesupport_impls):
 
     return 0
 
+
 def get_rs_name(name):
+    """Return the Rust-safe spelling of a ROS field name."""
     keywords = [
         # strict keywords
-        'as', 'break', 'const', 'continue', 'crate', 'else', 'enum', 'extern', 'false', 'fn', 'for', 'if', 'for',
-        'impl', 'in', 'let', 'loop', 'match', 'mod', 'move', 'mut', 'pub', 'ref', 'return', 'self', 'Self', 'static',
-        'struct', 'super', 'trait', 'true', 'type', 'unsafe', 'use', 'where', 'while',
+        'as', 'break', 'const', 'continue', 'crate', 'else', 'enum',
+        'extern', 'false', 'fn', 'for', 'if', 'for', 'impl', 'in', 'let',
+        'loop', 'match', 'mod', 'move', 'mut', 'pub', 'ref', 'return',
+        'self', 'Self', 'static', 'struct', 'super', 'trait', 'true',
+        'type', 'unsafe', 'use', 'where', 'while',
         # Edition 2024+
         'gen',
         # Edition 2018+
         'async', 'await', 'dyn',
         # Reserved
-        'abstract', 'become', 'box', 'do', 'final', 'macro', 'override', 'priv', 'typeof', 'unsized', 'virtual',
+        'abstract', 'become', 'box', 'do', 'final', 'macro', 'override',
+        'priv', 'typeof', 'unsized', 'virtual',
         'yield', 'try'
     ]
     # If the field name is a reserved keyword in Rust append an underscore
     return name if name not in keywords else name + '_'
 
+
 def escape_string(s):
+    """Escape a string literal for generated Rust code."""
     s = s.replace('\\', '\\\\')
     s = s.replace("'", "\\'")
     return s
 
 
 def value_to_rs(type_, value):
+    """Convert a rosidl default value to a Rust expression."""
     assert type_.is_primitive_type()
     assert value is not None
 
@@ -253,6 +266,7 @@ def value_to_rs(type_, value):
 
 
 def primitive_value_to_rs(type_, value):
+    """Convert a primitive rosidl value to a Rust expression."""
     assert type_.is_primitive_type()
     assert value is not None
 
@@ -285,6 +299,7 @@ def primitive_value_to_rs(type_, value):
 
 
 def constant_value_to_rs(type_, value):
+    """Convert a rosidl constant value to a Rust expression."""
     assert value is not None
 
     if isinstance(type_, BasicType):
@@ -321,14 +336,20 @@ def constant_value_to_rs(type_, value):
 
 
 def pre_field_serde(type_):
+    """Return serde attributes needed before a generated Rust field."""
     if isinstance(type_, Array) and type_.size > 32:
-        return '#[cfg_attr(feature = "serde", serde(with = "serde_big_array::BigArray"))]\n    '
+        return (
+            '#[cfg_attr(feature = "serde", '
+            'serde(with = "serde_big_array::BigArray"))]\n    '
+        )
     else:
         return ''
 
 
 def make_get_rs_type(idiomatic):
+    """Create a function that converts rosidl types to Rust type names."""
     def get_rs_type(type_, current_idiomatic, desired_idiomatic):
+        """Convert a rosidl type to a Rust type name."""
         if isinstance(type_, BasicType):
             if type_.typename == 'boolean':
                 return 'bool'
@@ -359,22 +380,41 @@ def get_rs_type(type_, current_idiomatic, desired_idiomatic):
             elif type_.typename == 'uint64':
                 return 'u64'
         elif isinstance(type_, BoundedString):
-            return 'rosidl_runtime_rs::BoundedString<{}>'.format(type_.maximum_size)
+            return 'rosidl_runtime_rs::BoundedString<{}>'.format(
+                type_.maximum_size)
         elif isinstance(type_, BoundedWString):
-            return 'rosidl_runtime_rs::BoundedWString<{}>'.format(type_.maximum_size)
+            return 'rosidl_runtime_rs::BoundedWString<{}>'.format(
+                type_.maximum_size)
         elif isinstance(type_, UnboundedString):
-            return 'std::string::String' if current_idiomatic and desired_idiomatic else 'rosidl_runtime_rs::String'
+            if current_idiomatic and desired_idiomatic:
+                return 'std::string::String'
+            return 'rosidl_runtime_rs::String'
         elif isinstance(type_, UnboundedWString):
-            return 'std::string::String' if current_idiomatic and desired_idiomatic else 'rosidl_runtime_rs::WString'
+            if current_idiomatic and desired_idiomatic:
+                return 'std::string::String'
+            return 'rosidl_runtime_rs::WString'
         elif isinstance(type_, Array):
-            return f'[{get_rs_type(type_.value_type, current_idiomatic, desired_idiomatic)}; {type_.size}]'
+            nested_type = get_rs_type(
+                type_.value_type, current_idiomatic, desired_idiomatic)
+            return f'[{nested_type}; {type_.size}]'
         elif isinstance(type_, UnboundedSequence):
-            container_type = 'Vec' if current_idiomatic and desired_idiomatic else 'rosidl_runtime_rs::Sequence'
-            return f'{container_type}<{get_rs_type(type_.value_type, current_idiomatic, desired_idiomatic)}>'
+            if current_idiomatic and desired_idiomatic:
+                container_type = 'Vec'
+            else:
+                container_type = 'rosidl_runtime_rs::Sequence'
+            nested_type = get_rs_type(
+                type_.value_type, current_idiomatic, desired_idiomatic)
+            return f'{container_type}<{nested_type}>'
         elif isinstance(type_, BoundedSequence):
-            # BoundedSequences can be in the idiomatic API, but the containing type cannot be from the
-            # idiomatic API because we do not implement SequenceAlloc for idiomatic types.
-            return f'rosidl_runtime_rs::BoundedSequence<{get_rs_type(type_.value_type, current_idiomatic, False)}, {type_.maximum_size}>'
+            # BoundedSequences can be in the idiomatic API, but the
+            # containing type cannot be from the idiomatic API because we do
+            # not implement SequenceAlloc for idiomatic types.
+            nested_type = get_rs_type(
+                type_.value_type, current_idiomatic, False)
+            return (
+                'rosidl_runtime_rs::BoundedSequence<'
+                f'{nested_type}, {type_.maximum_size}>'
+            )
         elif isinstance(type_, NamespacedType):
             # All types should be referencable like this
             # `super::msg::rmw::Foo` (From idiomatic modules)
@@ -384,8 +424,9 @@ def get_rs_type(type_, current_idiomatic, desired_idiomatic):
 
             symbol = f'{prefix}{"::".join(type_.namespaced_name()[1:])}'
 
-            # This symbol is coming from an external crate (or needs a `use` statement).
-            # So it should not be relative (i.e., no `super::`) and should have the top level
+            # This symbol is coming from an external crate (or needs a `use`
+            # statement). So it should not be relative (i.e., no `super::`)
+            # and should have the top level
             # package name (i.e., `builtin_interfaces::`)
             top_level_package = type_.namespaces[0]
             if top_level_package != package_name:
@@ -400,6 +441,7 @@ def get_rs_type(type_, current_idiomatic, desired_idiomatic):
 
         assert False, "unknown type '%s'" % type_.typename
 
-    # Start out by assuming all calls have matching current and desired idiomatic values.
-    # (i.e. symbols within the `...::rmw` scope want other values in the `...::rmw` scope).
+    # Start out by assuming all calls have matching current and desired
+    # idiomatic values. Symbols within the `...::rmw` scope want other values
+    # in the `...::rmw` scope.
     return lambda _type: get_rs_type(_type, idiomatic, idiomatic)

rosidl_generator_rs/test/test_keyword_escaping.py

@@ -1,10 +1,29 @@
+#!/usr/bin/env python3
+# Copyright 2018-2026 Esteve Fernandez <esteve@apache.org>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Tests for Rust keyword escaping."""
+
 from rosidl_generator_rs import get_rs_name
 
 
 def test_rust_keywords_are_escaped():
+    """Check that Rust keywords get a trailing underscore."""
     for keyword in ("try", "type", "const", "async", "match"):
         assert get_rs_name(keyword) == f"{keyword}_"
 
 
 def test_non_keyword_names_are_unchanged():
+    """Check that non-keyword names are unchanged."""
     assert get_rs_name("plain_field") == "plain_field"