Fix codegen and macro edge cases

sea-orm-macros/src/derives/active_enum.rs

@@ -556,7 +556,7 @@ impl ActiveEnum {
                 impl std::convert::TryFrom<&str> for #ident {
                     type Error = sea_orm::DbErr;
 
-                    fn try_from(source: &str) -> std::result::Result<Self, Self::Error> {
+                    fn try_from(source: &str) -> std::result::Result<Self, sea_orm::DbErr> {
                         match source {
                             #( #variant_values => Ok(Self::#variant_idents), )*
                             _ => Err(sea_orm::DbErr::Type(format!(

sea-orm-macros/src/derives/from_query_result.rs

@@ -47,7 +47,7 @@ impl ToTokens for TryFromQueryResultCheck<'_> {
                     .to_owned()
                     .unwrap_or_else(|| ident.unraw().to_string());
                 tokens.extend(quote! {
-                    let #ident = match row.try_get_nullable(pre, #name) {
+                    let #ident = match __sea_orm_row.try_get_nullable(__sea_orm_pre, #name) {
                         Err(v @ sea_orm::TryGetError::DbErr(_)) => {
                             return Err(v);
                         }
@@ -62,16 +62,16 @@ impl ToTokens for TryFromQueryResultCheck<'_> {
             }
             ItemType::Nested { prefix } => {
                 let prefix = match (self.0, prefix) {
-                    (_, Some(p)) => quote! { &format!("{pre}{}", #p) },
+                    (_, Some(p)) => quote! { &format!("{}{}", __sea_orm_pre, #p) },
                     (true, None) => {
                         let name = ident.unraw().to_string();
-                        quote! { &format!("{pre}{}_", #name) }
+                        quote! { &format!("{}{}_", __sea_orm_pre, #name) }
                     }
-                    (false, None) => quote! { pre },
+                    (false, None) => quote! { __sea_orm_pre },
                 };
 
                 tokens.extend(quote! {
-                    let #ident = match sea_orm::FromQueryResult::from_query_result_nullable(row, #prefix) {
+                    let #ident = match sea_orm::FromQueryResult::from_query_result_nullable(__sea_orm_row, #prefix) {
                         Err(v @ sea_orm::TryGetError::DbErr(_)) => {
                             return Err(v);
                         }
@@ -223,11 +223,11 @@ impl DeriveFromQueryResult {
         quote!(
             #[automatically_derived]
             impl #impl_generics sea_orm::FromQueryResult for #ident #ty_generics #where_clause {
-                fn from_query_result(row: &sea_orm::QueryResult, pre: &str) -> std::result::Result<Self, sea_orm::DbErr> {
-                    Ok(Self::from_query_result_nullable(row, pre)?)
+                fn from_query_result(__sea_orm_row: &sea_orm::QueryResult, __sea_orm_pre: &str) -> std::result::Result<Self, sea_orm::DbErr> {
+                    Ok(Self::from_query_result_nullable(__sea_orm_row, __sea_orm_pre)?)
                 }
 
-                fn from_query_result_nullable(row: &sea_orm::QueryResult, pre: &str) -> std::result::Result<Self, sea_orm::TryGetError> {
+                fn from_query_result_nullable(__sea_orm_row: &sea_orm::QueryResult, __sea_orm_pre: &str) -> std::result::Result<Self, sea_orm::TryGetError> {
                     #(#ident_try_init)*
 
                     Ok(Self {

sea-orm-macros/src/derives/model.rs

@@ -125,8 +125,8 @@ impl DeriveModel {
             } else {
                 let reader = quote! {
                     let #field_ident =
-                        row.try_get_nullable::<Option<#field_type>>(
-                            pre,
+                        __sea_orm_row.try_get_nullable::<Option<#field_type>>(
+                            __sea_orm_pre,
                             sea_orm::IdenStatic::as_str(
                                 &<<Self as sea_orm::ModelTrait>::Entity
                                     as sea_orm::entity::EntityTrait>::Column::#column_ident
@@ -169,11 +169,11 @@ impl DeriveModel {
         quote!(
             #[automatically_derived]
             impl sea_orm::FromQueryResult for #ident {
-                fn from_query_result(row: &sea_orm::QueryResult, pre: &str) -> std::result::Result<Self, sea_orm::DbErr> {
-                    Self::from_query_result_nullable(row, pre).map_err(Into::into)
+                fn from_query_result(__sea_orm_row: &sea_orm::QueryResult, __sea_orm_pre: &str) -> std::result::Result<Self, sea_orm::DbErr> {
+                    Self::from_query_result_nullable(__sea_orm_row, __sea_orm_pre).map_err(Into::into)
                 }
 
-                fn from_query_result_nullable(row: &sea_orm::QueryResult, pre: &str) -> std::result::Result<Self, sea_orm::TryGetError> {
+                fn from_query_result_nullable(__sea_orm_row: &sea_orm::QueryResult, __sea_orm_pre: &str) -> std::result::Result<Self, sea_orm::TryGetError> {
                     #(#field_readers)*
 
                     if #all_null_check {

sea-orm-macros/tests/derive_active_enum_test.rs

@@ -74,6 +74,13 @@ pub enum TestEnum3 {
     HelloWorld,
 }
 
+#[derive(Debug, EnumIter, DeriveActiveEnum, Eq, PartialEq)]
+#[sea_orm(rs_type = "String", db_type = "Enum", enum_name = "error_variant")]
+enum ErrorVariantEnum {
+    #[sea_orm(string_value = "error")]
+    Error,
+}
+
 #[test]
 fn derive_active_enum_value() {
     assert_eq!(TestEnum::DefaultVariant.to_value(), "defaultVariant");
@@ -96,6 +103,14 @@ fn derive_active_enum_value() {
     assert_eq!(TestEnum::CustomStringValue.to_value(), "CuStOmStRiNgVaLuE");
 }
 
+#[test]
+fn derive_active_enum_with_error_variant() {
+    assert_eq!(
+        <ErrorVariantEnum as TryFrom<&str>>::try_from("error"),
+        Ok(ErrorVariantEnum::Error)
+    );
+}
+
 #[test]
 fn derive_active_enum_from_value() {
     assert_eq!(

sea-orm-macros/tests/derive_entity_model_column_name_test.rs

@@ -56,3 +56,29 @@ fn test_column_names() {
         Column::from_str("lAsTnAmE").expect("column from str should recognize column_name attr");
     assert!(matches!(col, Column::LastName));
 }
+
+#[allow(dead_code)]
+mod query_parameter_name_collisions {
+    use sea_orm::entity::prelude::*;
+    use sea_orm_macros::{DeriveEntityModel, FromQueryResult};
+
+    #[derive(FromQueryResult)]
+    struct QueryResultProjection {
+        row: String,
+        pre: String,
+    }
+
+    #[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+    #[sea_orm(table_name = "query_parameter_name_collision")]
+    pub struct Model {
+        #[sea_orm(primary_key)]
+        id: i32,
+        row: String,
+        pre: String,
+    }
+
+    #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+    pub enum Relation {}
+
+    impl ActiveModelBehavior for ActiveModel {}
+}