From 1860efade20ec840f501e46f396b526cac3a7c6c Mon Sep 17 00:00:00 2001
From: andershausding <anders.hausding@siemens.com>
Date: Tue, 12 Aug 2025 14:54:09 +0200
Subject: [PATCH] [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
---
 .../codegen/languages/RustClientCodegen.java  | 20 +++++-
 .../src/apis/default_api.rs                   |  4 +-
 .../composed-oneof/src/apis/default_api.rs    |  4 +-
 .../oneOf-array-map/src/apis/default_api.rs   |  4 +-
 .../rust/reqwest/oneOf/src/apis/bar_api.rs    |  4 +-
 .../rust/reqwest/oneOf/src/apis/foo_api.rs    |  4 +-
 .../reqwest/name-mapping/src/apis/fake_api.rs | 20 +++---
 .../src/apis/fake_api.rs                      | 20 +++---
 .../src/apis/pet_api.rs                       | 72 +++++++++----------
 .../src/apis/store_api.rs                     | 12 ++--
 .../src/apis/testing_api.rs                   |  4 +-
 .../src/apis/user_api.rs                      | 44 ++++++------
 .../src/apis/fake_api.rs                      | 20 +++---
 .../src/apis/pet_api.rs                       | 68 +++++++++---------
 .../src/apis/store_api.rs                     | 12 ++--
 .../src/apis/testing_api.rs                   |  4 +-
 .../src/apis/user_api.rs                      | 36 +++++-----
 .../reqwest/petstore/src/apis/fake_api.rs     | 20 +++---
 .../rust/reqwest/petstore/src/apis/pet_api.rs | 68 +++++++++---------
 .../reqwest/petstore/src/apis/store_api.rs    | 12 ++--
 .../reqwest/petstore/src/apis/testing_api.rs  |  4 +-
 .../reqwest/petstore/src/apis/user_api.rs     | 36 +++++-----
 22 files changed, 254 insertions(+), 238 deletions(-)

diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/RustClientCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/RustClientCodegen.java
index 5ce20d8fb8b..c0b7584592a 100644
--- a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/RustClientCodegen.java
+++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/RustClientCodegen.java
@@ -639,13 +639,29 @@ public class RustClientCodegen extends AbstractRustCodegen implements CodegenCon
         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
diff --git a/samples/client/others/rust/reqwest/api-with-ref-param/src/apis/default_api.rs b/samples/client/others/rust/reqwest/api-with-ref-param/src/apis/default_api.rs
index 5f0e129882a..4016966325f 100644
--- a/samples/client/others/rust/reqwest/api-with-ref-param/src/apis/default_api.rs
+++ b/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 {
diff --git a/samples/client/others/rust/reqwest/composed-oneof/src/apis/default_api.rs b/samples/client/others/rust/reqwest/composed-oneof/src/apis/default_api.rs
index cc749951d6e..41edefc4de1 100644
--- a/samples/client/others/rust/reqwest/composed-oneof/src/apis/default_api.rs
+++ b/samples/client/others/rust/reqwest/composed-oneof/src/apis/default_api.rs
@@ -32,7 +32,7 @@ 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);
@@ -40,7 +40,7 @@ pub fn create_state(configuration: &configuration::Configuration, create_state_r
     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)?;
diff --git a/samples/client/others/rust/reqwest/oneOf-array-map/src/apis/default_api.rs b/samples/client/others/rust/reqwest/oneOf-array-map/src/apis/default_api.rs
index b5fb8c4fd94..6ee816baeea 100644
--- a/samples/client/others/rust/reqwest/oneOf-array-map/src/apis/default_api.rs
+++ b/samples/client/others/rust/reqwest/oneOf-array-map/src/apis/default_api.rs
@@ -66,7 +66,7 @@ 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);
@@ -74,7 +74,7 @@ pub fn test(configuration: &configuration::Configuration, body: Option<serde_jso
     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)?;
diff --git a/samples/client/others/rust/reqwest/oneOf/src/apis/bar_api.rs b/samples/client/others/rust/reqwest/oneOf/src/apis/bar_api.rs
index 797ac77c279..76f80248497 100644
--- a/samples/client/others/rust/reqwest/oneOf/src/apis/bar_api.rs
+++ b/samples/client/others/rust/reqwest/oneOf/src/apis/bar_api.rs
@@ -25,7 +25,7 @@ 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);
@@ -33,7 +33,7 @@ pub fn create_bar(configuration: &configuration::Configuration, bar_create: mode
     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)?;
diff --git a/samples/client/others/rust/reqwest/oneOf/src/apis/foo_api.rs b/samples/client/others/rust/reqwest/oneOf/src/apis/foo_api.rs
index d71a4e6a152..13fae1ef05b 100644
--- a/samples/client/others/rust/reqwest/oneOf/src/apis/foo_api.rs
+++ b/samples/client/others/rust/reqwest/oneOf/src/apis/foo_api.rs
@@ -32,7 +32,7 @@ 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);
@@ -40,7 +40,7 @@ pub fn create_foo(configuration: &configuration::Configuration, foo: Option<mode
     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)?;
diff --git a/samples/client/petstore/rust/reqwest/name-mapping/src/apis/fake_api.rs b/samples/client/petstore/rust/reqwest/name-mapping/src/apis/fake_api.rs
index 156ab2a1a59..9a3e3fca5a2 100644
--- a/samples/client/petstore/rust/reqwest/name-mapping/src/apis/fake_api.rs
+++ b/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)?;
diff --git a/samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/fake_api.rs b/samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/fake_api.rs
index a364dafd0e7..ca15d542e25 100644
--- a/samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/fake_api.rs
+++ b/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());
     }
 
diff --git a/samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/pet_api.rs b/samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/pet_api.rs
index bbb32324718..d075b93b211 100644
--- a/samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/pet_api.rs
+++ b/samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/pet_api.rs
@@ -101,7 +101,7 @@ pub enum UploadFileError {
 /// This is the description for the addPet operation
 pub fn add_pet(configuration: &configuration::Configuration, pet: models::Pet) -> Result<models::Pet, Error<AddPetError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_pet = pet;
+    let p_body_pet = pet;
 
     let uri_str = format!("{}/pet", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -110,7 +110,7 @@ pub fn add_pet(configuration: &configuration::Configuration, pet: models::Pet) -
         let new_headers = match aws_v4_key.sign(
 	    &uri_str,
 	    "POST",
-	    &serde_json::to_string(&p_pet).expect("param should serialize to string"),
+	    &serde_json::to_string(&p_body_pet).expect("param should serialize to string"),
 	    ) {
 	      Ok(new_headers) => new_headers,
 	      Err(err) => return Err(Error::AWSV4SignatureError(err)),
@@ -125,7 +125,7 @@ pub fn add_pet(configuration: &configuration::Configuration, pet: models::Pet) -
     if let Some(ref token) = configuration.oauth_access_token {
         req_builder = req_builder.bearer_auth(token.to_owned());
     };
-    req_builder = req_builder.json(&p_pet);
+    req_builder = req_builder.json(&p_body_pet);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
@@ -155,10 +155,10 @@ pub fn add_pet(configuration: &configuration::Configuration, pet: models::Pet) -
 /// 
 pub fn delete_pet(configuration: &configuration::Configuration, pet_id: i64, api_key: Option<&str>) -> Result<(), Error<DeletePetError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_pet_id = pet_id;
-    let p_api_key = api_key;
+    let p_path_pet_id = pet_id;
+    let p_header_api_key = api_key;
 
-    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_pet_id);
+    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_path_pet_id);
     let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
 
     if let Some(ref aws_v4_key) = configuration.aws_v4_key {
@@ -177,7 +177,7 @@ pub fn delete_pet(configuration: &configuration::Configuration, pet_id: i64, api
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
-    if let Some(param_value) = p_api_key {
+    if let Some(param_value) = p_header_api_key {
         req_builder = req_builder.header("api_key", param_value.to_string());
     }
     if let Some(ref token) = configuration.oauth_access_token {
@@ -201,17 +201,17 @@ pub fn delete_pet(configuration: &configuration::Configuration, pet_id: i64, api
 /// Multiple status values can be provided with comma separated strings. This is also a multi-line description to test rust doc comments 
 pub fn find_pets_by_status(configuration: &configuration::Configuration, status: Vec<String>, r#type: Option<Vec<String>>) -> Result<Vec<models::Pet>, Error<FindPetsByStatusError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_status = status;
-    let p_type = r#type;
+    let p_query_status = status;
+    let p_query_type = r#type;
 
     let uri_str = format!("{}/pet/findByStatus", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     req_builder = match "csv" {
-        "multi" => req_builder.query(&p_status.into_iter().map(|p| ("status".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
-        _ => req_builder.query(&[("status", &p_status.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
+        "multi" => req_builder.query(&p_query_status.into_iter().map(|p| ("status".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
+        _ => req_builder.query(&[("status", &p_query_status.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
     };
-    if let Some(ref param_value) = p_type {
+    if let Some(ref param_value) = p_query_type {
         req_builder = match "csv" {
             "multi" => req_builder.query(&param_value.into_iter().map(|p| ("type".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
             _ => req_builder.query(&[("type", &param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
@@ -265,14 +265,14 @@ pub fn find_pets_by_status(configuration: &configuration::Configuration, status:
 /// Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
 pub fn find_pets_by_tags(configuration: &configuration::Configuration, tags: Vec<String>) -> Result<Vec<models::Pet>, Error<FindPetsByTagsError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_tags = tags;
+    let p_query_tags = tags;
 
     let uri_str = format!("{}/pet/findByTags", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     req_builder = match "csv" {
-        "multi" => req_builder.query(&p_tags.into_iter().map(|p| ("tags".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
-        _ => req_builder.query(&[("tags", &p_tags.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
+        "multi" => req_builder.query(&p_query_tags.into_iter().map(|p| ("tags".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
+        _ => req_builder.query(&[("tags", &p_query_tags.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
     };
     if let Some(ref aws_v4_key) = configuration.aws_v4_key {
         let new_headers = match aws_v4_key.sign(
@@ -322,9 +322,9 @@ pub fn find_pets_by_tags(configuration: &configuration::Configuration, tags: Vec
 /// Returns a single pet
 pub fn get_pet_by_id(configuration: &configuration::Configuration, pet_id: i64) -> Result<models::Pet, Error<GetPetByIdError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_pet_id = pet_id;
+    let p_path_pet_id = pet_id;
 
-    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_pet_id);
+    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_path_pet_id);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref aws_v4_key) = configuration.aws_v4_key {
@@ -380,12 +380,12 @@ pub fn get_pet_by_id(configuration: &configuration::Configuration, pet_id: i64)
 /// Returns a list of pets
 pub fn pets_explode_post(configuration: &configuration::Configuration, page_explode: Option<models::Page>) -> Result<Vec<models::Pet>, Error<PetsExplodePostError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_page_explode = page_explode;
+    let p_query_page_explode = page_explode;
 
     let uri_str = format!("{}/pets/explode", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
 
-    if let Some(ref param_value) = p_page_explode {
+    if let Some(ref param_value) = p_query_page_explode {
         req_builder = req_builder.query(&param_value);
     }
     if let Some(ref user_agent) = configuration.user_agent {
@@ -420,12 +420,12 @@ pub fn pets_explode_post(configuration: &configuration::Configuration, page_expl
 /// Returns a list of pets
 pub fn pets_post(configuration: &configuration::Configuration, page: Option<models::Page>) -> Result<Vec<models::Pet>, Error<PetsPostError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_page = page;
+    let p_query_page = page;
 
     let uri_str = format!("{}/pets", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
 
-    if let Some(ref param_value) = p_page {
+    if let Some(ref param_value) = p_query_page {
         req_builder = req_builder.query(&[("page", &serde_json::to_string(param_value)?)]);
     }
     if let Some(ref user_agent) = configuration.user_agent {
@@ -460,7 +460,7 @@ pub fn pets_post(configuration: &configuration::Configuration, page: Option<mode
 /// 
 pub fn update_pet(configuration: &configuration::Configuration, pet: models::Pet) -> Result<models::Pet, Error<UpdatePetError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_pet = pet;
+    let p_body_pet = pet;
 
     let uri_str = format!("{}/pet", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
@@ -469,7 +469,7 @@ pub fn update_pet(configuration: &configuration::Configuration, pet: models::Pet
         let new_headers = match aws_v4_key.sign(
 	    &uri_str,
 	    "PUT",
-	    &serde_json::to_string(&p_pet).expect("param should serialize to string"),
+	    &serde_json::to_string(&p_body_pet).expect("param should serialize to string"),
 	    ) {
 	      Ok(new_headers) => new_headers,
 	      Err(err) => return Err(Error::AWSV4SignatureError(err)),
@@ -484,7 +484,7 @@ pub fn update_pet(configuration: &configuration::Configuration, pet: models::Pet
     if let Some(ref token) = configuration.oauth_access_token {
         req_builder = req_builder.bearer_auth(token.to_owned());
     };
-    req_builder = req_builder.json(&p_pet);
+    req_builder = req_builder.json(&p_body_pet);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
@@ -514,11 +514,11 @@ pub fn update_pet(configuration: &configuration::Configuration, pet: models::Pet
 /// 
 pub fn update_pet_with_form(configuration: &configuration::Configuration, pet_id: i64, name: Option<&str>, status: Option<&str>) -> Result<(), Error<UpdatePetWithFormError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_pet_id = pet_id;
-    let p_name = name;
-    let p_status = status;
+    let p_path_pet_id = pet_id;
+    let p_form_name = name;
+    let p_form_status = status;
 
-    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_pet_id);
+    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_path_pet_id);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref aws_v4_key) = configuration.aws_v4_key {
@@ -541,10 +541,10 @@ pub fn update_pet_with_form(configuration: &configuration::Configuration, pet_id
         req_builder = req_builder.bearer_auth(token.to_owned());
     };
     let mut multipart_form_params = std::collections::HashMap::new();
-    if let Some(param_value) = p_name {
+    if let Some(param_value) = p_form_name {
         multipart_form_params.insert("name", param_value.to_string());
     }
-    if let Some(param_value) = p_status {
+    if let Some(param_value) = p_form_status {
         multipart_form_params.insert("status", param_value.to_string());
     }
     req_builder = req_builder.form(&multipart_form_params);
@@ -566,11 +566,11 @@ pub fn update_pet_with_form(configuration: &configuration::Configuration, pet_id
 /// 
 pub fn upload_file(configuration: &configuration::Configuration, pet_id: i64, additional_metadata: Option<&str>, file: Option<std::path::PathBuf>) -> Result<models::ApiResponse, Error<UploadFileError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_pet_id = pet_id;
-    let p_additional_metadata = additional_metadata;
-    let p_file = file;
+    let p_path_pet_id = pet_id;
+    let p_form_additional_metadata = additional_metadata;
+    let p_form_file = file;
 
-    let uri_str = format!("{}/pet/{petId}/uploadImage", configuration.base_path, petId=p_pet_id);
+    let uri_str = format!("{}/pet/{petId}/uploadImage", configuration.base_path, petId=p_path_pet_id);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref aws_v4_key) = configuration.aws_v4_key {
@@ -593,10 +593,10 @@ pub fn upload_file(configuration: &configuration::Configuration, pet_id: i64, ad
         req_builder = req_builder.bearer_auth(token.to_owned());
     };
     let mut multipart_form = reqwest::blocking::multipart::Form::new();
-    if let Some(param_value) = p_additional_metadata {
+    if let Some(param_value) = p_form_additional_metadata {
         multipart_form = multipart_form.text("additionalMetadata", param_value.to_string());
     }
-    if let Some(param_value) = p_file {
+    if let Some(param_value) = p_form_file {
         multipart_form = multipart_form.file("file", param_value)?;
     }
     req_builder = req_builder.multipart(multipart_form);
diff --git a/samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/store_api.rs b/samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/store_api.rs
index 78dcac90360..7d3cf153117 100644
--- a/samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/store_api.rs
+++ b/samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/store_api.rs
@@ -52,9 +52,9 @@ pub enum PlaceOrderError {
 /// For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
 pub fn delete_order(configuration: &configuration::Configuration, order_id: &str) -> Result<(), Error<DeleteOrderError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_order_id = order_id;
+    let p_path_order_id = order_id;
 
-    let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=crate::apis::urlencode(p_order_id));
+    let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=crate::apis::urlencode(p_path_order_id));
     let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -134,9 +134,9 @@ pub fn get_inventory(configuration: &configuration::Configuration, ) -> Result<s
 /// For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions
 pub fn get_order_by_id(configuration: &configuration::Configuration, order_id: i64) -> Result<models::Order, Error<GetOrderByIdError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_order_id = order_id;
+    let p_path_order_id = order_id;
 
-    let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=p_order_id);
+    let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=p_path_order_id);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -171,7 +171,7 @@ pub fn get_order_by_id(configuration: &configuration::Configuration, order_id: i
 /// 
 pub fn place_order(configuration: &configuration::Configuration, order: models::Order) -> Result<models::Order, Error<PlaceOrderError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_order = order;
+    let p_body_order = order;
 
     let uri_str = format!("{}/store/order", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -179,7 +179,7 @@ pub fn place_order(configuration: &configuration::Configuration, order: models::
     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_order);
+    req_builder = req_builder.json(&p_body_order);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
diff --git a/samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/testing_api.rs b/samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/testing_api.rs
index 682abb33921..464779523d3 100644
--- a/samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/testing_api.rs
+++ b/samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/testing_api.rs
@@ -39,7 +39,7 @@ pub enum TestsTypeTestingGetError {
 
 pub fn tests_all_of_with_one_model_get(configuration: &configuration::Configuration, person: models::Person) -> Result<String, Error<TestsAllOfWithOneModelGetError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_person = person;
+    let p_body_person = person;
 
     let uri_str = format!("{}/tests/allOfWithOneModel", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
@@ -47,7 +47,7 @@ pub fn tests_all_of_with_one_model_get(configuration: &configuration::Configurat
     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_person);
+    req_builder = req_builder.json(&p_body_person);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
diff --git a/samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/user_api.rs b/samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/user_api.rs
index da93971ba23..ca5355a7f08 100644
--- a/samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/user_api.rs
+++ b/samples/client/petstore/rust/reqwest/petstore-awsv4signature/src/apis/user_api.rs
@@ -86,7 +86,7 @@ pub enum UpdateUserError {
 /// This can only be done by the logged in user.
 pub fn create_user(configuration: &configuration::Configuration, user: models::User) -> Result<(), Error<CreateUserError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_user = user;
+    let p_body_user = user;
 
     let uri_str = format!("{}/user", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -95,7 +95,7 @@ pub fn create_user(configuration: &configuration::Configuration, user: models::U
         let new_headers = match aws_v4_key.sign(
 	    &uri_str,
 	    "POST",
-	    &serde_json::to_string(&p_user).expect("param should serialize to string"),
+	    &serde_json::to_string(&p_body_user).expect("param should serialize to string"),
 	    ) {
 	      Ok(new_headers) => new_headers,
 	      Err(err) => return Err(Error::AWSV4SignatureError(err)),
@@ -115,7 +115,7 @@ pub fn create_user(configuration: &configuration::Configuration, user: models::U
         };
         req_builder = req_builder.header("api_key", value);
     };
-    req_builder = req_builder.json(&p_user);
+    req_builder = req_builder.json(&p_body_user);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
@@ -134,7 +134,7 @@ pub fn create_user(configuration: &configuration::Configuration, user: models::U
 /// 
 pub fn create_users_with_array_input(configuration: &configuration::Configuration, user: Vec<models::User>) -> Result<(), Error<CreateUsersWithArrayInputError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_user = user;
+    let p_body_user = user;
 
     let uri_str = format!("{}/user/createWithArray", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -143,7 +143,7 @@ pub fn create_users_with_array_input(configuration: &configuration::Configuratio
         let new_headers = match aws_v4_key.sign(
 	    &uri_str,
 	    "POST",
-	    &serde_json::to_string(&p_user).expect("param should serialize to string"),
+	    &serde_json::to_string(&p_body_user).expect("param should serialize to string"),
 	    ) {
 	      Ok(new_headers) => new_headers,
 	      Err(err) => return Err(Error::AWSV4SignatureError(err)),
@@ -163,7 +163,7 @@ pub fn create_users_with_array_input(configuration: &configuration::Configuratio
         };
         req_builder = req_builder.header("api_key", value);
     };
-    req_builder = req_builder.json(&p_user);
+    req_builder = req_builder.json(&p_body_user);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
@@ -182,7 +182,7 @@ pub fn create_users_with_array_input(configuration: &configuration::Configuratio
 /// 
 pub fn create_users_with_list_input(configuration: &configuration::Configuration, user: Vec<models::User>) -> Result<(), Error<CreateUsersWithListInputError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_user = user;
+    let p_body_user = user;
 
     let uri_str = format!("{}/user/createWithList", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -191,7 +191,7 @@ pub fn create_users_with_list_input(configuration: &configuration::Configuration
         let new_headers = match aws_v4_key.sign(
 	    &uri_str,
 	    "POST",
-	    &serde_json::to_string(&p_user).expect("param should serialize to string"),
+	    &serde_json::to_string(&p_body_user).expect("param should serialize to string"),
 	    ) {
 	      Ok(new_headers) => new_headers,
 	      Err(err) => return Err(Error::AWSV4SignatureError(err)),
@@ -211,7 +211,7 @@ pub fn create_users_with_list_input(configuration: &configuration::Configuration
         };
         req_builder = req_builder.header("api_key", value);
     };
-    req_builder = req_builder.json(&p_user);
+    req_builder = req_builder.json(&p_body_user);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
@@ -230,9 +230,9 @@ pub fn create_users_with_list_input(configuration: &configuration::Configuration
 /// This can only be done by the logged in user.
 pub fn delete_user(configuration: &configuration::Configuration, username: &str) -> Result<(), Error<DeleteUserError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_username = username;
+    let p_path_username = username;
 
-    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_username));
+    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_path_username));
     let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
 
     if let Some(ref aws_v4_key) = configuration.aws_v4_key {
@@ -277,9 +277,9 @@ pub fn delete_user(configuration: &configuration::Configuration, username: &str)
 /// 
 pub fn get_user_by_name(configuration: &configuration::Configuration, username: &str) -> Result<models::User, Error<GetUserByNameError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_username = username;
+    let p_path_username = username;
 
-    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_username));
+    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_path_username));
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -314,14 +314,14 @@ pub fn get_user_by_name(configuration: &configuration::Configuration, username:
 /// 
 pub fn login_user(configuration: &configuration::Configuration, username: &str, password: &str) -> Result<String, Error<LoginUserError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_username = username;
-    let p_password = password;
+    let p_query_username = username;
+    let p_query_password = password;
 
     let uri_str = format!("{}/user/login", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
-    req_builder = req_builder.query(&[("username", &p_username.to_string())]);
-    req_builder = req_builder.query(&[("password", &p_password.to_string())]);
+    req_builder = req_builder.query(&[("username", &p_query_username.to_string())]);
+    req_builder = req_builder.query(&[("password", &p_query_password.to_string())]);
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
@@ -399,17 +399,17 @@ pub fn logout_user(configuration: &configuration::Configuration, ) -> Result<(),
 /// This can only be done by the logged in user.
 pub fn update_user(configuration: &configuration::Configuration, username: &str, user: models::User) -> Result<(), Error<UpdateUserError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_username = username;
-    let p_user = user;
+    let p_path_username = username;
+    let p_body_user = user;
 
-    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_username));
+    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_path_username));
     let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
 
     if let Some(ref aws_v4_key) = configuration.aws_v4_key {
         let new_headers = match aws_v4_key.sign(
 	    &uri_str,
 	    "PUT",
-	    &serde_json::to_string(&p_user).expect("param should serialize to string"),
+	    &serde_json::to_string(&p_body_user).expect("param should serialize to string"),
 	    ) {
 	      Ok(new_headers) => new_headers,
 	      Err(err) => return Err(Error::AWSV4SignatureError(err)),
@@ -429,7 +429,7 @@ pub fn update_user(configuration: &configuration::Configuration, username: &str,
         };
         req_builder = req_builder.header("api_key", value);
     };
-    req_builder = req_builder.json(&p_user);
+    req_builder = req_builder.json(&p_body_user);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
diff --git a/samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/fake_api.rs b/samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/fake_api.rs
index a364dafd0e7..ca15d542e25 100644
--- a/samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/fake_api.rs
+++ b/samples/client/petstore/rust/reqwest/petstore-model-name-prefix/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());
     }
 
diff --git a/samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/pet_api.rs b/samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/pet_api.rs
index 02d62130d23..e8b2edc5573 100644
--- a/samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/pet_api.rs
+++ b/samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/pet_api.rs
@@ -101,7 +101,7 @@ pub enum UploadFileError {
 /// This is the description for the addPet operation
 pub fn add_pet(configuration: &configuration::Configuration, foo_pet: models::FooPet) -> Result<models::FooPet, Error<AddPetError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_foo_pet = foo_pet;
+    let p_body_foo_pet = foo_pet;
 
     let uri_str = format!("{}/pet", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -112,7 +112,7 @@ pub fn add_pet(configuration: &configuration::Configuration, foo_pet: models::Fo
     if let Some(ref token) = configuration.oauth_access_token {
         req_builder = req_builder.bearer_auth(token.to_owned());
     };
-    req_builder = req_builder.json(&p_foo_pet);
+    req_builder = req_builder.json(&p_body_foo_pet);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
@@ -142,16 +142,16 @@ pub fn add_pet(configuration: &configuration::Configuration, foo_pet: models::Fo
 /// 
 pub fn delete_pet(configuration: &configuration::Configuration, pet_id: i64, api_key: Option<&str>) -> Result<(), Error<DeletePetError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_pet_id = pet_id;
-    let p_api_key = api_key;
+    let p_path_pet_id = pet_id;
+    let p_header_api_key = api_key;
 
-    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_pet_id);
+    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_path_pet_id);
     let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
-    if let Some(param_value) = p_api_key {
+    if let Some(param_value) = p_header_api_key {
         req_builder = req_builder.header("api_key", param_value.to_string());
     }
     if let Some(ref token) = configuration.oauth_access_token {
@@ -175,17 +175,17 @@ pub fn delete_pet(configuration: &configuration::Configuration, pet_id: i64, api
 /// Multiple status values can be provided with comma separated strings. This is also a multi-line description to test rust doc comments 
 pub fn find_pets_by_status(configuration: &configuration::Configuration, status: Vec<String>, r#type: Option<Vec<String>>) -> Result<Vec<models::FooPet>, Error<FindPetsByStatusError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_status = status;
-    let p_type = r#type;
+    let p_query_status = status;
+    let p_query_type = r#type;
 
     let uri_str = format!("{}/pet/findByStatus", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     req_builder = match "csv" {
-        "multi" => req_builder.query(&p_status.into_iter().map(|p| ("status".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
-        _ => req_builder.query(&[("status", &p_status.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
+        "multi" => req_builder.query(&p_query_status.into_iter().map(|p| ("status".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
+        _ => req_builder.query(&[("status", &p_query_status.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
     };
-    if let Some(ref param_value) = p_type {
+    if let Some(ref param_value) = p_query_type {
         req_builder = match "csv" {
             "multi" => req_builder.query(&param_value.into_iter().map(|p| ("type".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
             _ => req_builder.query(&[("type", &param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
@@ -226,14 +226,14 @@ pub fn find_pets_by_status(configuration: &configuration::Configuration, status:
 /// Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
 pub fn find_pets_by_tags(configuration: &configuration::Configuration, tags: Vec<String>) -> Result<Vec<models::FooPet>, Error<FindPetsByTagsError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_tags = tags;
+    let p_query_tags = tags;
 
     let uri_str = format!("{}/pet/findByTags", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     req_builder = match "csv" {
-        "multi" => req_builder.query(&p_tags.into_iter().map(|p| ("tags".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
-        _ => req_builder.query(&[("tags", &p_tags.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
+        "multi" => req_builder.query(&p_query_tags.into_iter().map(|p| ("tags".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
+        _ => req_builder.query(&[("tags", &p_query_tags.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
     };
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
@@ -270,9 +270,9 @@ pub fn find_pets_by_tags(configuration: &configuration::Configuration, tags: Vec
 /// Returns a single pet
 pub fn get_pet_by_id(configuration: &configuration::Configuration, pet_id: i64) -> Result<models::FooPet, Error<GetPetByIdError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_pet_id = pet_id;
+    let p_path_pet_id = pet_id;
 
-    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_pet_id);
+    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_path_pet_id);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -315,12 +315,12 @@ pub fn get_pet_by_id(configuration: &configuration::Configuration, pet_id: i64)
 /// Returns a list of pets
 pub fn pets_explode_post(configuration: &configuration::Configuration, page_explode: Option<models::FooPage>) -> Result<Vec<models::FooPet>, Error<PetsExplodePostError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_page_explode = page_explode;
+    let p_query_page_explode = page_explode;
 
     let uri_str = format!("{}/pets/explode", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
 
-    if let Some(ref param_value) = p_page_explode {
+    if let Some(ref param_value) = p_query_page_explode {
         req_builder = req_builder.query(&param_value);
     }
     if let Some(ref user_agent) = configuration.user_agent {
@@ -355,12 +355,12 @@ pub fn pets_explode_post(configuration: &configuration::Configuration, page_expl
 /// Returns a list of pets
 pub fn pets_post(configuration: &configuration::Configuration, page: Option<models::FooPage>) -> Result<Vec<models::FooPet>, Error<PetsPostError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_page = page;
+    let p_query_page = page;
 
     let uri_str = format!("{}/pets", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
 
-    if let Some(ref param_value) = p_page {
+    if let Some(ref param_value) = p_query_page {
         req_builder = req_builder.query(&[("page", &serde_json::to_string(param_value)?)]);
     }
     if let Some(ref user_agent) = configuration.user_agent {
@@ -395,7 +395,7 @@ pub fn pets_post(configuration: &configuration::Configuration, page: Option<mode
 /// 
 pub fn update_pet(configuration: &configuration::Configuration, foo_pet: models::FooPet) -> Result<models::FooPet, Error<UpdatePetError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_foo_pet = foo_pet;
+    let p_body_foo_pet = foo_pet;
 
     let uri_str = format!("{}/pet", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
@@ -406,7 +406,7 @@ pub fn update_pet(configuration: &configuration::Configuration, foo_pet: models:
     if let Some(ref token) = configuration.oauth_access_token {
         req_builder = req_builder.bearer_auth(token.to_owned());
     };
-    req_builder = req_builder.json(&p_foo_pet);
+    req_builder = req_builder.json(&p_body_foo_pet);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
@@ -436,11 +436,11 @@ pub fn update_pet(configuration: &configuration::Configuration, foo_pet: models:
 /// 
 pub fn update_pet_with_form(configuration: &configuration::Configuration, pet_id: i64, name: Option<&str>, status: Option<&str>) -> Result<(), Error<UpdatePetWithFormError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_pet_id = pet_id;
-    let p_name = name;
-    let p_status = status;
+    let p_path_pet_id = pet_id;
+    let p_form_name = name;
+    let p_form_status = status;
 
-    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_pet_id);
+    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_path_pet_id);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -450,10 +450,10 @@ pub fn update_pet_with_form(configuration: &configuration::Configuration, pet_id
         req_builder = req_builder.bearer_auth(token.to_owned());
     };
     let mut multipart_form_params = std::collections::HashMap::new();
-    if let Some(param_value) = p_name {
+    if let Some(param_value) = p_form_name {
         multipart_form_params.insert("name", param_value.to_string());
     }
-    if let Some(param_value) = p_status {
+    if let Some(param_value) = p_form_status {
         multipart_form_params.insert("status", param_value.to_string());
     }
     req_builder = req_builder.form(&multipart_form_params);
@@ -475,11 +475,11 @@ pub fn update_pet_with_form(configuration: &configuration::Configuration, pet_id
 /// 
 pub fn upload_file(configuration: &configuration::Configuration, pet_id: i64, additional_metadata: Option<&str>, file: Option<std::path::PathBuf>) -> Result<models::FooApiResponse, Error<UploadFileError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_pet_id = pet_id;
-    let p_additional_metadata = additional_metadata;
-    let p_file = file;
+    let p_path_pet_id = pet_id;
+    let p_form_additional_metadata = additional_metadata;
+    let p_form_file = file;
 
-    let uri_str = format!("{}/pet/{petId}/uploadImage", configuration.base_path, petId=p_pet_id);
+    let uri_str = format!("{}/pet/{petId}/uploadImage", configuration.base_path, petId=p_path_pet_id);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -489,10 +489,10 @@ pub fn upload_file(configuration: &configuration::Configuration, pet_id: i64, ad
         req_builder = req_builder.bearer_auth(token.to_owned());
     };
     let mut multipart_form = reqwest::blocking::multipart::Form::new();
-    if let Some(param_value) = p_additional_metadata {
+    if let Some(param_value) = p_form_additional_metadata {
         multipart_form = multipart_form.text("additionalMetadata", param_value.to_string());
     }
-    if let Some(param_value) = p_file {
+    if let Some(param_value) = p_form_file {
         multipart_form = multipart_form.file("file", param_value)?;
     }
     req_builder = req_builder.multipart(multipart_form);
diff --git a/samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/store_api.rs b/samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/store_api.rs
index d6cdf8ae950..1347ba10a19 100644
--- a/samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/store_api.rs
+++ b/samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/store_api.rs
@@ -52,9 +52,9 @@ pub enum PlaceOrderError {
 /// For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
 pub fn delete_order(configuration: &configuration::Configuration, order_id: &str) -> Result<(), Error<DeleteOrderError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_order_id = order_id;
+    let p_path_order_id = order_id;
 
-    let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=crate::apis::urlencode(p_order_id));
+    let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=crate::apis::urlencode(p_path_order_id));
     let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -121,9 +121,9 @@ pub fn get_inventory(configuration: &configuration::Configuration, ) -> Result<s
 /// For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions
 pub fn get_order_by_id(configuration: &configuration::Configuration, order_id: i64) -> Result<models::FooOrder, Error<GetOrderByIdError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_order_id = order_id;
+    let p_path_order_id = order_id;
 
-    let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=p_order_id);
+    let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=p_path_order_id);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -158,7 +158,7 @@ pub fn get_order_by_id(configuration: &configuration::Configuration, order_id: i
 /// 
 pub fn place_order(configuration: &configuration::Configuration, foo_order: models::FooOrder) -> Result<models::FooOrder, Error<PlaceOrderError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_foo_order = foo_order;
+    let p_body_foo_order = foo_order;
 
     let uri_str = format!("{}/store/order", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -166,7 +166,7 @@ pub fn place_order(configuration: &configuration::Configuration, foo_order: mode
     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_order);
+    req_builder = req_builder.json(&p_body_foo_order);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
diff --git a/samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/testing_api.rs b/samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/testing_api.rs
index 186924c77f4..4486a14b263 100644
--- a/samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/testing_api.rs
+++ b/samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/testing_api.rs
@@ -39,7 +39,7 @@ pub enum TestsTypeTestingGetError {
 
 pub fn tests_all_of_with_one_model_get(configuration: &configuration::Configuration, foo_person: models::FooPerson) -> Result<String, Error<TestsAllOfWithOneModelGetError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_foo_person = foo_person;
+    let p_body_foo_person = foo_person;
 
     let uri_str = format!("{}/tests/allOfWithOneModel", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
@@ -47,7 +47,7 @@ pub fn tests_all_of_with_one_model_get(configuration: &configuration::Configurat
     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_person);
+    req_builder = req_builder.json(&p_body_foo_person);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
diff --git a/samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/user_api.rs b/samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/user_api.rs
index b50ce1caaab..14bd39560e3 100644
--- a/samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/user_api.rs
+++ b/samples/client/petstore/rust/reqwest/petstore-model-name-prefix/src/apis/user_api.rs
@@ -86,7 +86,7 @@ pub enum UpdateUserError {
 /// This can only be done by the logged in user.
 pub fn create_user(configuration: &configuration::Configuration, foo_user: models::FooUser) -> Result<(), Error<CreateUserError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_foo_user = foo_user;
+    let p_body_foo_user = foo_user;
 
     let uri_str = format!("{}/user", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -102,7 +102,7 @@ pub fn create_user(configuration: &configuration::Configuration, foo_user: model
         };
         req_builder = req_builder.header("api_key", value);
     };
-    req_builder = req_builder.json(&p_foo_user);
+    req_builder = req_builder.json(&p_body_foo_user);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
@@ -121,7 +121,7 @@ pub fn create_user(configuration: &configuration::Configuration, foo_user: model
 /// 
 pub fn create_users_with_array_input(configuration: &configuration::Configuration, user: Vec<models::FooUser>) -> Result<(), Error<CreateUsersWithArrayInputError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_user = user;
+    let p_body_user = user;
 
     let uri_str = format!("{}/user/createWithArray", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -137,7 +137,7 @@ pub fn create_users_with_array_input(configuration: &configuration::Configuratio
         };
         req_builder = req_builder.header("api_key", value);
     };
-    req_builder = req_builder.json(&p_user);
+    req_builder = req_builder.json(&p_body_user);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
@@ -156,7 +156,7 @@ pub fn create_users_with_array_input(configuration: &configuration::Configuratio
 /// 
 pub fn create_users_with_list_input(configuration: &configuration::Configuration, user: Vec<models::FooUser>) -> Result<(), Error<CreateUsersWithListInputError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_user = user;
+    let p_body_user = user;
 
     let uri_str = format!("{}/user/createWithList", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -172,7 +172,7 @@ pub fn create_users_with_list_input(configuration: &configuration::Configuration
         };
         req_builder = req_builder.header("api_key", value);
     };
-    req_builder = req_builder.json(&p_user);
+    req_builder = req_builder.json(&p_body_user);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
@@ -191,9 +191,9 @@ pub fn create_users_with_list_input(configuration: &configuration::Configuration
 /// This can only be done by the logged in user.
 pub fn delete_user(configuration: &configuration::Configuration, username: &str) -> Result<(), Error<DeleteUserError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_username = username;
+    let p_path_username = username;
 
-    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_username));
+    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_path_username));
     let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -225,9 +225,9 @@ pub fn delete_user(configuration: &configuration::Configuration, username: &str)
 /// 
 pub fn get_user_by_name(configuration: &configuration::Configuration, username: &str) -> Result<models::FooUser, Error<GetUserByNameError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_username = username;
+    let p_path_username = username;
 
-    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_username));
+    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_path_username));
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -262,14 +262,14 @@ pub fn get_user_by_name(configuration: &configuration::Configuration, username:
 /// 
 pub fn login_user(configuration: &configuration::Configuration, username: &str, password: &str) -> Result<String, Error<LoginUserError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_username = username;
-    let p_password = password;
+    let p_query_username = username;
+    let p_query_password = password;
 
     let uri_str = format!("{}/user/login", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
-    req_builder = req_builder.query(&[("username", &p_username.to_string())]);
-    req_builder = req_builder.query(&[("password", &p_password.to_string())]);
+    req_builder = req_builder.query(&[("username", &p_query_username.to_string())]);
+    req_builder = req_builder.query(&[("password", &p_query_password.to_string())]);
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
@@ -334,10 +334,10 @@ pub fn logout_user(configuration: &configuration::Configuration, ) -> Result<(),
 /// This can only be done by the logged in user.
 pub fn update_user(configuration: &configuration::Configuration, username: &str, foo_user: models::FooUser) -> Result<(), Error<UpdateUserError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_username = username;
-    let p_foo_user = foo_user;
+    let p_path_username = username;
+    let p_body_foo_user = foo_user;
 
-    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_username));
+    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_path_username));
     let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -351,7 +351,7 @@ pub fn update_user(configuration: &configuration::Configuration, username: &str,
         };
         req_builder = req_builder.header("api_key", value);
     };
-    req_builder = req_builder.json(&p_foo_user);
+    req_builder = req_builder.json(&p_body_foo_user);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
diff --git a/samples/client/petstore/rust/reqwest/petstore/src/apis/fake_api.rs b/samples/client/petstore/rust/reqwest/petstore/src/apis/fake_api.rs
index a364dafd0e7..ca15d542e25 100644
--- a/samples/client/petstore/rust/reqwest/petstore/src/apis/fake_api.rs
+++ b/samples/client/petstore/rust/reqwest/petstore/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());
     }
 
diff --git a/samples/client/petstore/rust/reqwest/petstore/src/apis/pet_api.rs b/samples/client/petstore/rust/reqwest/petstore/src/apis/pet_api.rs
index 2d432bf3044..77a70ebe47d 100644
--- a/samples/client/petstore/rust/reqwest/petstore/src/apis/pet_api.rs
+++ b/samples/client/petstore/rust/reqwest/petstore/src/apis/pet_api.rs
@@ -101,7 +101,7 @@ pub enum UploadFileError {
 /// This is the description for the addPet operation
 pub fn add_pet(configuration: &configuration::Configuration, pet: models::Pet) -> Result<models::Pet, Error<AddPetError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_pet = pet;
+    let p_body_pet = pet;
 
     let uri_str = format!("{}/pet", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -112,7 +112,7 @@ pub fn add_pet(configuration: &configuration::Configuration, pet: models::Pet) -
     if let Some(ref token) = configuration.oauth_access_token {
         req_builder = req_builder.bearer_auth(token.to_owned());
     };
-    req_builder = req_builder.json(&p_pet);
+    req_builder = req_builder.json(&p_body_pet);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
@@ -142,16 +142,16 @@ pub fn add_pet(configuration: &configuration::Configuration, pet: models::Pet) -
 /// 
 pub fn delete_pet(configuration: &configuration::Configuration, pet_id: i64, api_key: Option<&str>) -> Result<(), Error<DeletePetError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_pet_id = pet_id;
-    let p_api_key = api_key;
+    let p_path_pet_id = pet_id;
+    let p_header_api_key = api_key;
 
-    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_pet_id);
+    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_path_pet_id);
     let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
-    if let Some(param_value) = p_api_key {
+    if let Some(param_value) = p_header_api_key {
         req_builder = req_builder.header("api_key", param_value.to_string());
     }
     if let Some(ref token) = configuration.oauth_access_token {
@@ -175,17 +175,17 @@ pub fn delete_pet(configuration: &configuration::Configuration, pet_id: i64, api
 /// Multiple status values can be provided with comma separated strings. This is also a multi-line description to test rust doc comments 
 pub fn find_pets_by_status(configuration: &configuration::Configuration, status: Vec<String>, r#type: Option<Vec<String>>) -> Result<Vec<models::Pet>, Error<FindPetsByStatusError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_status = status;
-    let p_type = r#type;
+    let p_query_status = status;
+    let p_query_type = r#type;
 
     let uri_str = format!("{}/pet/findByStatus", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     req_builder = match "csv" {
-        "multi" => req_builder.query(&p_status.into_iter().map(|p| ("status".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
-        _ => req_builder.query(&[("status", &p_status.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
+        "multi" => req_builder.query(&p_query_status.into_iter().map(|p| ("status".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
+        _ => req_builder.query(&[("status", &p_query_status.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
     };
-    if let Some(ref param_value) = p_type {
+    if let Some(ref param_value) = p_query_type {
         req_builder = match "csv" {
             "multi" => req_builder.query(&param_value.into_iter().map(|p| ("type".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
             _ => req_builder.query(&[("type", &param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
@@ -226,14 +226,14 @@ pub fn find_pets_by_status(configuration: &configuration::Configuration, status:
 /// Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
 pub fn find_pets_by_tags(configuration: &configuration::Configuration, tags: Vec<String>) -> Result<Vec<models::Pet>, Error<FindPetsByTagsError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_tags = tags;
+    let p_query_tags = tags;
 
     let uri_str = format!("{}/pet/findByTags", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     req_builder = match "csv" {
-        "multi" => req_builder.query(&p_tags.into_iter().map(|p| ("tags".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
-        _ => req_builder.query(&[("tags", &p_tags.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
+        "multi" => req_builder.query(&p_query_tags.into_iter().map(|p| ("tags".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
+        _ => req_builder.query(&[("tags", &p_query_tags.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
     };
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
@@ -270,9 +270,9 @@ pub fn find_pets_by_tags(configuration: &configuration::Configuration, tags: Vec
 /// Returns a single pet
 pub fn get_pet_by_id(configuration: &configuration::Configuration, pet_id: i64) -> Result<models::Pet, Error<GetPetByIdError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_pet_id = pet_id;
+    let p_path_pet_id = pet_id;
 
-    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_pet_id);
+    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_path_pet_id);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -315,12 +315,12 @@ pub fn get_pet_by_id(configuration: &configuration::Configuration, pet_id: i64)
 /// Returns a list of pets
 pub fn pets_explode_post(configuration: &configuration::Configuration, page_explode: Option<models::Page>) -> Result<Vec<models::Pet>, Error<PetsExplodePostError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_page_explode = page_explode;
+    let p_query_page_explode = page_explode;
 
     let uri_str = format!("{}/pets/explode", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
 
-    if let Some(ref param_value) = p_page_explode {
+    if let Some(ref param_value) = p_query_page_explode {
         req_builder = req_builder.query(&param_value);
     }
     if let Some(ref user_agent) = configuration.user_agent {
@@ -355,12 +355,12 @@ pub fn pets_explode_post(configuration: &configuration::Configuration, page_expl
 /// Returns a list of pets
 pub fn pets_post(configuration: &configuration::Configuration, page: Option<models::Page>) -> Result<Vec<models::Pet>, Error<PetsPostError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_page = page;
+    let p_query_page = page;
 
     let uri_str = format!("{}/pets", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
 
-    if let Some(ref param_value) = p_page {
+    if let Some(ref param_value) = p_query_page {
         req_builder = req_builder.query(&[("page", &serde_json::to_string(param_value)?)]);
     }
     if let Some(ref user_agent) = configuration.user_agent {
@@ -395,7 +395,7 @@ pub fn pets_post(configuration: &configuration::Configuration, page: Option<mode
 /// 
 pub fn update_pet(configuration: &configuration::Configuration, pet: models::Pet) -> Result<models::Pet, Error<UpdatePetError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_pet = pet;
+    let p_body_pet = pet;
 
     let uri_str = format!("{}/pet", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
@@ -406,7 +406,7 @@ pub fn update_pet(configuration: &configuration::Configuration, pet: models::Pet
     if let Some(ref token) = configuration.oauth_access_token {
         req_builder = req_builder.bearer_auth(token.to_owned());
     };
-    req_builder = req_builder.json(&p_pet);
+    req_builder = req_builder.json(&p_body_pet);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
@@ -436,11 +436,11 @@ pub fn update_pet(configuration: &configuration::Configuration, pet: models::Pet
 /// 
 pub fn update_pet_with_form(configuration: &configuration::Configuration, pet_id: i64, name: Option<&str>, status: Option<&str>) -> Result<(), Error<UpdatePetWithFormError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_pet_id = pet_id;
-    let p_name = name;
-    let p_status = status;
+    let p_path_pet_id = pet_id;
+    let p_form_name = name;
+    let p_form_status = status;
 
-    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_pet_id);
+    let uri_str = format!("{}/pet/{petId}", configuration.base_path, petId=p_path_pet_id);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -450,10 +450,10 @@ pub fn update_pet_with_form(configuration: &configuration::Configuration, pet_id
         req_builder = req_builder.bearer_auth(token.to_owned());
     };
     let mut multipart_form_params = std::collections::HashMap::new();
-    if let Some(param_value) = p_name {
+    if let Some(param_value) = p_form_name {
         multipart_form_params.insert("name", param_value.to_string());
     }
-    if let Some(param_value) = p_status {
+    if let Some(param_value) = p_form_status {
         multipart_form_params.insert("status", param_value.to_string());
     }
     req_builder = req_builder.form(&multipart_form_params);
@@ -475,11 +475,11 @@ pub fn update_pet_with_form(configuration: &configuration::Configuration, pet_id
 /// 
 pub fn upload_file(configuration: &configuration::Configuration, pet_id: i64, additional_metadata: Option<&str>, file: Option<std::path::PathBuf>) -> Result<models::ApiResponse, Error<UploadFileError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_pet_id = pet_id;
-    let p_additional_metadata = additional_metadata;
-    let p_file = file;
+    let p_path_pet_id = pet_id;
+    let p_form_additional_metadata = additional_metadata;
+    let p_form_file = file;
 
-    let uri_str = format!("{}/pet/{petId}/uploadImage", configuration.base_path, petId=p_pet_id);
+    let uri_str = format!("{}/pet/{petId}/uploadImage", configuration.base_path, petId=p_path_pet_id);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -489,10 +489,10 @@ pub fn upload_file(configuration: &configuration::Configuration, pet_id: i64, ad
         req_builder = req_builder.bearer_auth(token.to_owned());
     };
     let mut multipart_form = reqwest::blocking::multipart::Form::new();
-    if let Some(param_value) = p_additional_metadata {
+    if let Some(param_value) = p_form_additional_metadata {
         multipart_form = multipart_form.text("additionalMetadata", param_value.to_string());
     }
-    if let Some(param_value) = p_file {
+    if let Some(param_value) = p_form_file {
         multipart_form = multipart_form.file("file", param_value)?;
     }
     req_builder = req_builder.multipart(multipart_form);
diff --git a/samples/client/petstore/rust/reqwest/petstore/src/apis/store_api.rs b/samples/client/petstore/rust/reqwest/petstore/src/apis/store_api.rs
index ee5e6a5d2d4..47880474490 100644
--- a/samples/client/petstore/rust/reqwest/petstore/src/apis/store_api.rs
+++ b/samples/client/petstore/rust/reqwest/petstore/src/apis/store_api.rs
@@ -52,9 +52,9 @@ pub enum PlaceOrderError {
 /// For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
 pub fn delete_order(configuration: &configuration::Configuration, order_id: &str) -> Result<(), Error<DeleteOrderError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_order_id = order_id;
+    let p_path_order_id = order_id;
 
-    let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=crate::apis::urlencode(p_order_id));
+    let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=crate::apis::urlencode(p_path_order_id));
     let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -121,9 +121,9 @@ pub fn get_inventory(configuration: &configuration::Configuration, ) -> Result<s
 /// For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions
 pub fn get_order_by_id(configuration: &configuration::Configuration, order_id: i64) -> Result<models::Order, Error<GetOrderByIdError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_order_id = order_id;
+    let p_path_order_id = order_id;
 
-    let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=p_order_id);
+    let uri_str = format!("{}/store/order/{orderId}", configuration.base_path, orderId=p_path_order_id);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -158,7 +158,7 @@ pub fn get_order_by_id(configuration: &configuration::Configuration, order_id: i
 /// 
 pub fn place_order(configuration: &configuration::Configuration, order: models::Order) -> Result<models::Order, Error<PlaceOrderError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_order = order;
+    let p_body_order = order;
 
     let uri_str = format!("{}/store/order", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -166,7 +166,7 @@ pub fn place_order(configuration: &configuration::Configuration, order: models::
     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_order);
+    req_builder = req_builder.json(&p_body_order);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
diff --git a/samples/client/petstore/rust/reqwest/petstore/src/apis/testing_api.rs b/samples/client/petstore/rust/reqwest/petstore/src/apis/testing_api.rs
index 682abb33921..464779523d3 100644
--- a/samples/client/petstore/rust/reqwest/petstore/src/apis/testing_api.rs
+++ b/samples/client/petstore/rust/reqwest/petstore/src/apis/testing_api.rs
@@ -39,7 +39,7 @@ pub enum TestsTypeTestingGetError {
 
 pub fn tests_all_of_with_one_model_get(configuration: &configuration::Configuration, person: models::Person) -> Result<String, Error<TestsAllOfWithOneModelGetError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_person = person;
+    let p_body_person = person;
 
     let uri_str = format!("{}/tests/allOfWithOneModel", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
@@ -47,7 +47,7 @@ pub fn tests_all_of_with_one_model_get(configuration: &configuration::Configurat
     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_person);
+    req_builder = req_builder.json(&p_body_person);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
diff --git a/samples/client/petstore/rust/reqwest/petstore/src/apis/user_api.rs b/samples/client/petstore/rust/reqwest/petstore/src/apis/user_api.rs
index db7d7313ece..78bff164512 100644
--- a/samples/client/petstore/rust/reqwest/petstore/src/apis/user_api.rs
+++ b/samples/client/petstore/rust/reqwest/petstore/src/apis/user_api.rs
@@ -86,7 +86,7 @@ pub enum UpdateUserError {
 /// This can only be done by the logged in user.
 pub fn create_user(configuration: &configuration::Configuration, user: models::User) -> Result<(), Error<CreateUserError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_user = user;
+    let p_body_user = user;
 
     let uri_str = format!("{}/user", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -102,7 +102,7 @@ pub fn create_user(configuration: &configuration::Configuration, user: models::U
         };
         req_builder = req_builder.header("api_key", value);
     };
-    req_builder = req_builder.json(&p_user);
+    req_builder = req_builder.json(&p_body_user);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
@@ -121,7 +121,7 @@ pub fn create_user(configuration: &configuration::Configuration, user: models::U
 /// 
 pub fn create_users_with_array_input(configuration: &configuration::Configuration, user: Vec<models::User>) -> Result<(), Error<CreateUsersWithArrayInputError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_user = user;
+    let p_body_user = user;
 
     let uri_str = format!("{}/user/createWithArray", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -137,7 +137,7 @@ pub fn create_users_with_array_input(configuration: &configuration::Configuratio
         };
         req_builder = req_builder.header("api_key", value);
     };
-    req_builder = req_builder.json(&p_user);
+    req_builder = req_builder.json(&p_body_user);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
@@ -156,7 +156,7 @@ pub fn create_users_with_array_input(configuration: &configuration::Configuratio
 /// 
 pub fn create_users_with_list_input(configuration: &configuration::Configuration, user: Vec<models::User>) -> Result<(), Error<CreateUsersWithListInputError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_user = user;
+    let p_body_user = user;
 
     let uri_str = format!("{}/user/createWithList", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);
@@ -172,7 +172,7 @@ pub fn create_users_with_list_input(configuration: &configuration::Configuration
         };
         req_builder = req_builder.header("api_key", value);
     };
-    req_builder = req_builder.json(&p_user);
+    req_builder = req_builder.json(&p_body_user);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;
@@ -191,9 +191,9 @@ pub fn create_users_with_list_input(configuration: &configuration::Configuration
 /// This can only be done by the logged in user.
 pub fn delete_user(configuration: &configuration::Configuration, username: &str) -> Result<(), Error<DeleteUserError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_username = username;
+    let p_path_username = username;
 
-    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_username));
+    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_path_username));
     let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -225,9 +225,9 @@ pub fn delete_user(configuration: &configuration::Configuration, username: &str)
 /// 
 pub fn get_user_by_name(configuration: &configuration::Configuration, username: &str) -> Result<models::User, Error<GetUserByNameError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_username = username;
+    let p_path_username = username;
 
-    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_username));
+    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_path_username));
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -262,14 +262,14 @@ pub fn get_user_by_name(configuration: &configuration::Configuration, username:
 /// 
 pub fn login_user(configuration: &configuration::Configuration, username: &str, password: &str) -> Result<String, Error<LoginUserError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_username = username;
-    let p_password = password;
+    let p_query_username = username;
+    let p_query_password = password;
 
     let uri_str = format!("{}/user/login", configuration.base_path);
     let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);
 
-    req_builder = req_builder.query(&[("username", &p_username.to_string())]);
-    req_builder = req_builder.query(&[("password", &p_password.to_string())]);
+    req_builder = req_builder.query(&[("username", &p_query_username.to_string())]);
+    req_builder = req_builder.query(&[("password", &p_query_password.to_string())]);
     if let Some(ref user_agent) = configuration.user_agent {
         req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
     }
@@ -334,10 +334,10 @@ pub fn logout_user(configuration: &configuration::Configuration, ) -> Result<(),
 /// This can only be done by the logged in user.
 pub fn update_user(configuration: &configuration::Configuration, username: &str, user: models::User) -> Result<(), Error<UpdateUserError>> {
     // add a prefix to parameters to efficiently prevent name collisions
-    let p_username = username;
-    let p_user = user;
+    let p_path_username = username;
+    let p_body_user = user;
 
-    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_username));
+    let uri_str = format!("{}/user/{username}", configuration.base_path, username=crate::apis::urlencode(p_path_username));
     let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);
 
     if let Some(ref user_agent) = configuration.user_agent {
@@ -351,7 +351,7 @@ pub fn update_user(configuration: &configuration::Configuration, username: &str,
         };
         req_builder = req_builder.header("api_key", value);
     };
-    req_builder = req_builder.json(&p_user);
+    req_builder = req_builder.json(&p_body_user);
 
     let req = req_builder.build()?;
     let resp = configuration.client.execute(req)?;