Enforce static parameter types

rclcpp/include/rclcpp/node.hpp

@@ -305,16 +305,58 @@ class Node : public std::enable_shared_from_this<Node>
    *   name is invalid.
    * \throws rclcpp::exceptions::InvalidParameterValueException if initial
    *   value fails to be set.
+   * \throws rclcpp::exceptions::InvalidParameterTypeException
+   *   if the type of the default value or override is wrong.
    */
   RCLCPP_PUBLIC
   const rclcpp::ParameterValue &
   declare_parameter(
     const std::string & name,
-    const rclcpp::ParameterValue & default_value = rclcpp::ParameterValue(),
+    const rclcpp::ParameterValue & default_value,
     const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor =
     rcl_interfaces::msg::ParameterDescriptor(),
     bool ignore_override = false);
 
+  /// Declare and initialize a parameter, return the effective value.
+  /**
+   * Same as the previous one, but a default value is not provided and the user
+   * must provide a parameter override of the correct type.
+   *
+   * \param[in] name The name of the parameter.
+   * \param[in] type Desired type of the parameter, which will enforced at runtime.
+   * \param[in] parameter_descriptor An optional, custom description for
+   *   the parameter.
+   * \param[in] ignore_override When `true`, the parameter override is ignored.
+   *    Default to `false`.
+   * \return A const reference to the value of the parameter.
+   * \throws Same as the previous overload taking a default value.
+   * \throws rclcpp::exceptions::InvalidParameterTypeException
+   *   if an override is not provided or the provided override is of the wrong type.
+   */
+  RCLCPP_PUBLIC
+  const rclcpp::ParameterValue &
+  declare_parameter(
+    const std::string & name,
+    rclcpp::ParameterType type,
+    const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor =
+    rcl_interfaces::msg::ParameterDescriptor{},
+    bool ignore_override = false);
+
+  [[deprecated(
+    "declare_parameter() with only a name is deprecated and will be deleted in the future.\n" \
+    "If you want to declare a parameter that won't change of type without a default value use:\n" \
+    "`node->declare_parameter<ParameterT>(name)`, where e.g. ParameterT=int64_t.\n\n" \
+    "If you want to declare a parameter that can dynamically change of type use:\n" \
+    "```\n" \
+    "rcl_interfaces::msg::ParameterDescriptor descriptor;\n" \
+    "descriptor.dynamic_typing = true;\n" \
+    "node->declare_parameter(name, rclcpp::ParameterValue{}, descriptor);" \
+    "```"
+  )]]
+  RCLCPP_PUBLIC
+  const rclcpp::ParameterValue &
+  declare_parameter(const std::string & name);
+
   /// Declare and initialize a parameter with a type.
   /**
    * See the non-templated declare_parameter() on this class for details.
@@ -345,6 +387,18 @@ class Node : public std::enable_shared_from_this<Node>
     rcl_interfaces::msg::ParameterDescriptor(),
     bool ignore_override = false);
 
+  /// Declare and initialize a parameter with a type.
+  /**
+   * See the non-templated declare_parameter() on this class for details.
+   */
+  template<typename ParameterT>
+  auto
+  declare_parameter(
+    const std::string & name,
+    const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor =
+    rcl_interfaces::msg::ParameterDescriptor(),
+    bool ignore_override = false);
+
   /// Declare and initialize several parameters with the same namespace and type.
   /**
    * For each key in the map, a parameter with a name of "namespace.key"

rclcpp/include/rclcpp/node_impl.hpp

@@ -172,6 +172,23 @@ Node::declare_parameter(
   }
 }
 
+template<typename ParameterT>
+auto
+Node::declare_parameter(
+  const std::string & name,
+  const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor,
+  bool ignore_override)
+{
+  // get advantage of parameter value template magic to get
+  // the correct rclcpp::ParameterType from ParameterT
+  rclcpp::ParameterValue value{ParameterT{}};
+  return this->declare_parameter(
+    name,
+    value.get_type(),
+    parameter_descriptor,
+    ignore_override).get<ParameterT>();
+}
+
 template<typename ParameterT>
 std::vector<ParameterT>
 Node::declare_parameters(

rclcpp/include/rclcpp/node_interfaces/node_parameters.hpp

@@ -103,13 +103,42 @@ class NodeParameters : public NodeParametersInterface
   virtual
   ~NodeParameters();
 
+// This is overriding a deprecated method, so we need to ignore the deprecation warning here.
+// Users of the method will still get a warning!
+#ifndef _WIN32
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#else
+# pragma warning(push)
+# pragma warning(disable: 4996)
+#endif
+  [[deprecated(RCLCPP_INTERNAL_NODE_PARAMETERS_INTERFACE_DEPTRECATE_DECLARE)]]
+  RCLCPP_PUBLIC
+  const rclcpp::ParameterValue &
+  declare_parameter(const std::string & name) override;
+#ifndef _WIN32
+# pragma GCC diagnostic pop
+#else
+# pragma warning(pop)
+#endif
+
   RCLCPP_PUBLIC
   const rclcpp::ParameterValue &
   declare_parameter(
     const std::string & name,
     const rclcpp::ParameterValue & default_value,
-    const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor,
-    bool ignore_override) override;
+    const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor =
+    rcl_interfaces::msg::ParameterDescriptor{},
+    bool ignore_override = false) override;
+
+  RCLCPP_PUBLIC
+  const rclcpp::ParameterValue &
+  declare_parameter(
+    const std::string & name,
+    rclcpp::ParameterType type,
+    const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor =
+    rcl_interfaces::msg::ParameterDescriptor(),
+    bool ignore_override = false) override;
 
   RCLCPP_PUBLIC
   void

rclcpp/include/rclcpp/node_interfaces/node_parameters_interface.hpp

@@ -45,6 +45,17 @@ struct OnSetParametersCallbackHandle
   OnParametersSetCallbackType callback;
 };
 
+#define RCLCPP_INTERNAL_NODE_PARAMETERS_INTERFACE_DEPTRECATE_DECLARE \
+  "declare_parameter() with only a name is deprecated and will be deleted in the future.\n" \
+  "If you want to declare a parameter that won't change of type without a default value use:\n" \
+  "`node_params->declare_parameter(name, type)`, with e.g. type=rclcpp::PARAMETER_INTEGER.\n\n" \
+  "If you want to declare a parameter that can dynamically change of type use:\n" \
+  "```\n" \
+  "rcl_interfaces::msg::ParameterDescriptor descriptor;\n" \
+  "descriptor.dynamic_typing = true;\n" \
+  "node_params->declare_parameter(name, rclcpp::ParameterValue{}, descriptor);" \
+  "```"
+
 /// Pure virtual interface class for the NodeParameters part of the Node API.
 class NodeParametersInterface
 {
@@ -55,6 +66,15 @@ class NodeParametersInterface
   virtual
   ~NodeParametersInterface() = default;
 
+  /// Declare a parameter.
+  /**
+   * \sa rclcpp::Node::declare_parameter
+   */
+  [[deprecated(RCLCPP_INTERNAL_NODE_PARAMETERS_INTERFACE_DEPTRECATE_DECLARE)]]
+  virtual
+  const rclcpp::ParameterValue &
+  declare_parameter(const std::string & name) = 0;
+
   /// Declare and initialize a parameter.
   /**
    * \sa rclcpp::Node::declare_parameter
@@ -64,7 +84,21 @@ class NodeParametersInterface
   const rclcpp::ParameterValue &
   declare_parameter(
     const std::string & name,
-    const rclcpp::ParameterValue & default_value = rclcpp::ParameterValue(),
+    const rclcpp::ParameterValue & default_value,
+    const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor =
+    rcl_interfaces::msg::ParameterDescriptor(),
+    bool ignore_override = false) = 0;
+
+  /// Declare a parameter.
+  /**
+   * \sa rclcpp::Node::declare_parameter
+   */
+  RCLCPP_PUBLIC
+  virtual
+  const rclcpp::ParameterValue &
+  declare_parameter(
+    const std::string & name,
+    rclcpp::ParameterType type,
     const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor =
     rcl_interfaces::msg::ParameterDescriptor(),
     bool ignore_override = false) = 0;

rclcpp/include/rclcpp/parameter_value.hpp

@@ -32,6 +32,8 @@ namespace rclcpp
 enum ParameterType : uint8_t
 {
   PARAMETER_NOT_SET = rcl_interfaces::msg::ParameterType::PARAMETER_NOT_SET,
+  /// Special value, only used to declare a dynamically typed parameter.
+  /// Not valid as a parameter type.
   PARAMETER_BOOL = rcl_interfaces::msg::ParameterType::PARAMETER_BOOL,
   PARAMETER_INTEGER = rcl_interfaces::msg::ParameterType::PARAMETER_INTEGER,
   PARAMETER_DOUBLE = rcl_interfaces::msg::ParameterType::PARAMETER_DOUBLE,

rclcpp/src/rclcpp/node.cpp

@@ -219,6 +219,24 @@ Node::create_callback_group(
   return node_base_->create_callback_group(group_type, automatically_add_to_executor_with_node);
 }
 
+const rclcpp::ParameterValue &
+Node::declare_parameter(const std::string & name)
+{
+#ifndef _WIN32
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#else
+# pragma warning(push)
+# pragma warning(disable: 4996)
+#endif
+  return this->node_parameters_->declare_parameter(name);
+#ifndef _WIN32
+# pragma GCC diagnostic pop
+#else
+# pragma warning(pop)
+#endif
+}
+
 const rclcpp::ParameterValue &
 Node::declare_parameter(
   const std::string & name,
@@ -233,6 +251,20 @@ Node::declare_parameter(
     ignore_override);
 }
 
+const rclcpp::ParameterValue &
+Node::declare_parameter(
+  const std::string & name,
+  rclcpp::ParameterType type,
+  const rcl_interfaces::msg::ParameterDescriptor & parameter_descriptor,
+  bool ignore_override)
+{
+  return this->node_parameters_->declare_parameter(
+    name,
+    type,
+    parameter_descriptor,
+    ignore_override);
+}
+
 void
 Node::undeclare_parameter(const std::string & name)
 {