[Rust] fix: add location prefix to prevent parameter name collisions (#21611)

* [Rust] fix: add location prefix to prevent parameter name collisions when escaping parameter names

* chore: update samples

* [Rust] fix: do not use locationSuffix if useSingleRequestParameter feature is enabled

Author: andershausding

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/RustClientCodegen.java

@@ -639,13 +639,29 @@ public void postProcessParameter(CodegenParameter parameter) {
         super.postProcessParameter(parameter);
         // in order to avoid name conflicts, we map parameters inside the functions
         String inFunctionIdentifier = "";
+        String locationSuffix = "";
+
+        // Determine parameter location using the boolean flags in case of parameters with the same name but in different locations
+        if (parameter.isPathParam) {
+            locationSuffix = "path_";
+        } else if (parameter.isQueryParam) {
+            locationSuffix = "query_";
+        } else if (parameter.isHeaderParam) {
+            locationSuffix = "header_";
+        } else if (parameter.isBodyParam) {
+            locationSuffix = "body_";
+        } else if (parameter.isCookieParam) {
+            locationSuffix = "cookie_";
+        } else if (parameter.isFormParam) {
+            locationSuffix = "form_";
+        }
         if (this.useSingleRequestParameter) {
             inFunctionIdentifier = "params." + parameter.paramName;
         } else {
             if (parameter.paramName.startsWith("r#")) {
-                inFunctionIdentifier = "p_" + parameter.paramName.substring(2);
+                inFunctionIdentifier = "p_" + locationSuffix + parameter.paramName.substring(2);
             } else {
-                inFunctionIdentifier = "p_" + parameter.paramName;
+                inFunctionIdentifier = "p_" + locationSuffix + parameter.paramName;
             }
         }
         if (!parameter.vendorExtensions.containsKey(this.VENDOR_EXTENSION_PARAM_IDENTIFIER)) { // allow to overwrite this value

samples/client/others/rust/reqwest/api-with-ref-param/src/apis/default_api.rs

@@ -25,9 +25,9 @@ pub enum DemoColorGetError {
 
 pub async fn demo_color_get(configuration: &configuration::Configuration, color: models::Color) -> Result<(), Error<DemoColorGetError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_color = color;
+    let p_path_color = color;
 
-    let uri_str = format!("{}/demo/{color}", configuration.base_path, color=p_color.to_string());
+    let uri_str = format!("{}/demo/{color}", configuration.base_path, color=p_path_color.to_string());
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {

samples/client/others/rust/reqwest/composed-oneof/src/apis/default_api.rs

@@ -32,15 +32,15 @@ pub enum GetStateError {
 
 pub fn create_state(configuration: &configuration::Configuration, create_state_request: models::CreateStateRequest) -> Result<(), Error<CreateStateError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_create_state_request = create_state_request;
+    let p_body_create_state_request = create_state_request;
 
     let uri_str = format!("{}/state", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
-    req_builder = req_builder.json(&p_create_state_request);
+    req_builder = req_builder.json(&p_body_create_state_request);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;

samples/client/others/rust/reqwest/oneOf-array-map/src/apis/default_api.rs

@@ -66,15 +66,15 @@ pub fn root_get(configuration: &configuration::Configuration, ) -> Result<models
 
 pub fn test(configuration: &configuration::Configuration, body: Option<serde_json::Value>) -> Result<(), Error<TestError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_body = body;
+    let p_body_body = body;
 
     let uri_str = format!("{}/", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
-    req_builder = req_builder.json(&p_body);
+    req_builder = req_builder.json(&p_body_body);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;

samples/client/others/rust/reqwest/oneOf/src/apis/bar_api.rs

@@ -25,15 +25,15 @@ pub enum CreateBarError {
 
 pub fn create_bar(configuration: &configuration::Configuration, bar_create: models::BarCreate) -> Result<models::Bar, Error<CreateBarError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_bar_create = bar_create;
+    let p_body_bar_create = bar_create;
 
     let uri_str = format!("{}/bar", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
-    req_builder = req_builder.json(&p_bar_create);
+    req_builder = req_builder.json(&p_body_bar_create);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;

samples/client/others/rust/reqwest/oneOf/src/apis/foo_api.rs

@@ -32,15 +32,15 @@ pub enum GetAllFoosError {
 
 pub fn create_foo(configuration: &configuration::Configuration, foo: Option<models::Foo>) -> Result<models::FooRefOrValue, Error<CreateFooError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_foo = foo;
+    let p_body_foo = foo;
 
     let uri_str = format!("{}/foo", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
-    req_builder = req_builder.json(&p_foo);
+    req_builder = req_builder.json(&p_body_foo);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;

samples/client/petstore/rust/reqwest/name-mapping/src/apis/fake_api.rs

@@ -25,23 +25,23 @@ pub enum GetParameterNameMappingError {
 
 pub fn get_parameter_name_mapping(configuration: &configuration::Configuration, underscore_type: i64, r#type: &str, type_with_underscore: &str, dash_type: &str, http_debug_option: &str) -> Result<(), Error<GetParameterNameMappingError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_underscore_type = underscore_type;
-    let p_type = r#type;
-    let p_type_with_underscore = type_with_underscore;
-    let p_dash_type = dash_type;
-    let p_http_debug_option = http_debug_option;
+    let p_header_underscore_type = underscore_type;
+    let p_query_type = r#type;
+    let p_header_type_with_underscore = type_with_underscore;
+    let p_header_dash_type = dash_type;
+    let p_query_http_debug_option = http_debug_option;
 
     let uri_str = format!("{}/fake/parameter-name-mapping", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
-    req_builder = req_builder.query(&[("type", &p_type.to_string())]);
-    req_builder = req_builder.query(&[("http_debug_option", &p_http_debug_option.to_string())]);
+    req_builder = req_builder.query(&[("type", &p_query_type.to_string())]);
+    req_builder = req_builder.query(&[("http_debug_option", &p_query_http_debug_option.to_string())]);
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
-    req_builder = req_builder.header("_type", p_underscore_type.to_string());
-    req_builder = req_builder.header("type_", p_type_with_underscore.to_string());
-    req_builder = req_builder.header("-type", p_dash_type.to_string());
+    req_builder = req_builder.header("_type", p_header_underscore_type.to_string());
+    req_builder = req_builder.header("type_", p_header_type_with_underscore.to_string());
+    req_builder = req_builder.header("-type", p_header_dash_type.to_string());
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;

samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/fake_api.rs

@@ -28,27 +28,27 @@ pub enum TestNullableRequiredParamError {
 /// 
 pub fn test_nullable_required_param(configuration: &configuration::Configuration, user_name: &str, dummy_required_nullable_param: Option<&str>, any_type: &str, uppercase: Option<&str>, content: Option<&str>) -> Result<(), Error<TestNullableRequiredParamError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_user_name = user_name;
-    let p_dummy_required_nullable_param = dummy_required_nullable_param;
-    let p_any_type = any_type;
-    let p_uppercase = uppercase;
-    let p_content = content;
+    let p_path_user_name = user_name;
+    let p_header_dummy_required_nullable_param = dummy_required_nullable_param;
+    let p_query_any_type = any_type;
+    let p_header_uppercase = uppercase;
+    let p_query_content = content;
 
-    let uri_str = format!("{}/fake/user/{user_name}", configuration.base_path, user_name=crate::apis::urlencode(p_user_name));
+    let uri_str = format!("{}/fake/user/{user_name}", configuration.base_path, user_name=crate::apis::urlencode(p_path_user_name));
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
-    if let Some(ref param_value) = p_content {
+    if let Some(ref param_value) = p_query_content {
         req_builder = req_builder.query(&[("content", &param_value.to_string())]);
     }
-    req_builder = req_builder.query(&[("anyType", &p_any_type.to_string())]);
+    req_builder = req_builder.query(&[("anyType", &p_query_any_type.to_string())]);
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
-    match p_dummy_required_nullable_param {
+    match p_header_dummy_required_nullable_param {
         Some(param_value) => { req_builder = req_builder.header("dummy_required_nullable_param", param_value.to_string()); },
         None => { req_builder = req_builder.header("dummy_required_nullable_param", ""); },
     }
-    if let Some(param_value) = p_uppercase {
+    if let Some(param_value) = p_header_uppercase {
         req_builder = req_builder.header("UPPERCASE", param_value.to_string());
     }