Correct handling of raw identifiers async-graphql#195

sunli829 · sunli829 · commit 98e431fed046 · 2020-07-02T10:25:20.000+08:00
diff --git a/async-graphql-derive/src/enum.rs b/async-graphql-derive/src/enum.rs
@@ -3,6 +3,7 @@ use crate::utils::{get_crate_name, get_rustdoc};
 use inflector::Inflector;
 use proc_macro::TokenStream;
 use quote::quote;
+use syn::ext::IdentExt;
 use syn::{Data, DeriveInput, Error, Result};
 
 pub fn generate(enum_args: &args::Enum, input: &DeriveInput) -> Result<TokenStream> {
@@ -47,7 +48,7 @@ pub fn generate(enum_args: &args::Enum, input: &DeriveInput) -> Result<TokenStre
         let gql_item_name = item_args
             .name
             .take()
-            .unwrap_or_else(|| variant.ident.to_string().to_screaming_snake_case());
+            .unwrap_or_else(|| variant.ident.unraw().to_string().to_screaming_snake_case());
         let item_deprecation = item_args
             .deprecation
             .as_ref()
diff --git a/async-graphql-derive/src/input_object.rs b/async-graphql-derive/src/input_object.rs
@@ -3,6 +3,7 @@ use crate::utils::{get_crate_name, get_rustdoc};
 use inflector::Inflector;
 use proc_macro::TokenStream;
 use quote::quote;
+use syn::ext::IdentExt;
 use syn::{Data, DeriveInput, Error, Result};
 
 pub fn generate(object_args: &args::InputObject, input: &DeriveInput) -> Result<TokenStream> {
@@ -53,7 +54,7 @@ pub fn generate(object_args: &args::InputObject, input: &DeriveInput) -> Result<
         let validator = &field_args.validator;
         let name = field_args
             .name
-            .unwrap_or_else(|| ident.to_string().to_camel_case());
+            .unwrap_or_else(|| ident.unraw().to_string().to_camel_case());
         let desc = field_args
             .desc
             .as_ref()
diff --git a/async-graphql-derive/src/object.rs b/async-graphql-derive/src/object.rs
@@ -4,6 +4,7 @@ use crate::utils::{feature_block, get_crate_name, get_param_getter_ident, get_ru
 use inflector::Inflector;
 use proc_macro::TokenStream;
 use quote::quote;
+use syn::ext::IdentExt;
 use syn::{Block, Error, FnArg, ImplItem, ItemImpl, Pat, Result, ReturnType, Type, TypeReference};
 
 pub fn generate(object_args: &args::Object, item_impl: &mut ItemImpl) -> Result<TokenStream> {
@@ -127,7 +128,7 @@ pub fn generate(object_args: &args::Object, item_impl: &mut ItemImpl) -> Result<
                     let is_key = all_key || *key;
                     let name = name
                         .clone()
-                        .unwrap_or_else(|| ident.ident.to_string().to_camel_case());
+                        .unwrap_or_else(|| ident.ident.unraw().to_string().to_camel_case());
 
                     if is_key {
                         if !keys_str.is_empty() {
@@ -208,7 +209,7 @@ pub fn generate(object_args: &args::Object, item_impl: &mut ItemImpl) -> Result<
                 let field_name = field
                     .name
                     .clone()
-                    .unwrap_or_else(|| method.sig.ident.to_string().to_camel_case());
+                    .unwrap_or_else(|| method.sig.ident.unraw().to_string().to_camel_case());
                 let field_desc = field
                     .desc
                     .as_ref()
@@ -317,7 +318,7 @@ pub fn generate(object_args: &args::Object, item_impl: &mut ItemImpl) -> Result<
                 {
                     let name = name
                         .clone()
-                        .unwrap_or_else(|| ident.ident.to_string().to_camel_case());
+                        .unwrap_or_else(|| ident.ident.unraw().to_string().to_camel_case());
                     let desc = desc
                         .as_ref()
                         .map(|s| quote! {Some(#s)})
@@ -488,6 +489,7 @@ pub fn generate(object_args: &args::Object, item_impl: &mut ItemImpl) -> Result<
         }
 
         #[allow(clippy::all, clippy::pedantic)]
+        #[allow(unused_braces, unused_variables)]
         #[#crate_name::async_trait::async_trait]
         impl#generics #crate_name::ObjectType for #self_ty #where_clause {
             async fn resolve_field(&self, ctx: &#crate_name::Context<'_>) -> #crate_name::Result<#crate_name::serde_json::Value> {
@@ -498,7 +500,6 @@ pub fn generate(object_args: &args::Object, item_impl: &mut ItemImpl) -> Result<
                 }.into_error(ctx.position()))
             }
 
-            #[allow(unused_variables)]
             async fn find_entity(&self, ctx: &#crate_name::Context<'_>, params: &#crate_name::Value) -> #crate_name::Result<#crate_name::serde_json::Value> {
                 let params = match params {
                     #crate_name::Value::Object(params) => params,
diff --git a/async-graphql-derive/src/simple_object.rs b/async-graphql-derive/src/simple_object.rs
@@ -3,6 +3,7 @@ use crate::utils::{feature_block, get_crate_name, get_rustdoc};
 use inflector::Inflector;
 use proc_macro::TokenStream;
 use quote::quote;
+use syn::ext::IdentExt;
 use syn::{Data, DeriveInput, Error, Fields, Result};
 
 pub fn generate(object_args: &args::Object, input: &DeriveInput) -> Result<TokenStream> {
@@ -39,10 +40,14 @@ pub fn generate(object_args: &args::Object, input: &DeriveInput) -> Result<Token
     if let Some(fields) = fields {
         for item in &fields.named {
             if let Some(field) = args::Field::parse(&crate_name, &item.attrs)? {
-                let field_name = field
-                    .name
-                    .clone()
-                    .unwrap_or_else(|| item.ident.as_ref().unwrap().to_string().to_camel_case());
+                let field_name = field.name.clone().unwrap_or_else(|| {
+                    item.ident
+                        .as_ref()
+                        .unwrap()
+                        .unraw()
+                        .to_string()
+                        .to_camel_case()
+                });
                 let field_desc = field
                     .desc
                     .as_ref()
diff --git a/async-graphql-derive/src/subscription.rs b/async-graphql-derive/src/subscription.rs
@@ -4,6 +4,7 @@ use crate::utils::{feature_block, get_crate_name, get_param_getter_ident, get_ru
 use inflector::Inflector;
 use proc_macro::TokenStream;
 use quote::quote;
+use syn::ext::IdentExt;
 use syn::{
     Block, Error, FnArg, ImplItem, ItemImpl, Pat, Result, ReturnType, Type, TypeImplTrait,
     TypeReference,
@@ -47,7 +48,7 @@ pub fn generate(object_args: &args::Object, item_impl: &mut ItemImpl) -> Result<
                 let field_name = field
                     .name
                     .clone()
-                    .unwrap_or_else(|| method.sig.ident.to_string().to_camel_case());
+                    .unwrap_or_else(|| method.sig.ident.unraw().to_string().to_camel_case());
                 let field_desc = field
                     .desc
                     .as_ref()
@@ -149,7 +150,7 @@ pub fn generate(object_args: &args::Object, item_impl: &mut ItemImpl) -> Result<
                 {
                     let name = name
                         .clone()
-                        .unwrap_or_else(|| ident.ident.to_string().to_camel_case());
+                        .unwrap_or_else(|| ident.ident.unraw().to_string().to_camel_case());
                     let desc = desc
                         .as_ref()
                         .map(|s| quote! {Some(#s)})
diff --git a/tests/raw_ident.rs b/tests/raw_ident.rs
@@ -0,0 +1,79 @@
+use async_graphql::*;
+use futures::{Stream, StreamExt};
+
+#[async_std::test]
+pub async fn test_input_value_custom_error() {
+    #[Enum]
+    #[allow(non_camel_case_types)]
+    enum MyEnum {
+        r#type,
+    }
+
+    #[SimpleObject]
+    struct MyObject {
+        r#i32: i32,
+    }
+
+    #[InputObject]
+    struct MyInputObject {
+        r#i32: i32,
+    }
+
+    struct Query;
+
+    #[Object]
+    impl Query {
+        async fn r#type(&self, r#i32: i32) -> i32 {
+            r#i32
+        }
+
+        async fn obj(&self, obj: MyInputObject) -> MyObject {
+            MyObject { r#i32: obj.r#i32 }
+        }
+
+        async fn enum_value(&self, value: MyEnum) -> MyEnum {
+            value
+        }
+    }
+
+    struct SubscriptionRoot;
+
+    #[Subscription]
+    impl SubscriptionRoot {
+        async fn r#type(&self) -> impl Stream<Item = i32> {
+            futures::stream::iter(0..10)
+        }
+    }
+
+    let schema = Schema::new(Query, EmptyMutation, SubscriptionRoot);
+    let query = r#"
+        {
+            type(i32: 99)
+            obj(obj: { i32: 88} ) { i32 }
+            enumValue(value: TYPE)
+        }"#;
+    assert_eq!(
+        QueryBuilder::new(query)
+            .execute(&schema)
+            .await
+            .unwrap()
+            .data,
+        serde_json::json!({
+            "type": 99,
+            "obj": { "i32": 88 },
+            "enumValue": "TYPE",
+        })
+    );
+
+    let mut stream = schema
+        .create_subscription_stream("subscription { type }", None, Default::default(), None)
+        .await
+        .unwrap();
+    for i in 0..10 {
+        assert_eq!(
+            Some(Ok(serde_json::json!({ "type": i }))),
+            stream.next().await
+        );
+    }
+    assert!(stream.next().await.is_none());
+}
