From 5a37497a2282960576ff68e4f8471e418e9a4760 Mon Sep 17 00:00:00 2001
From: Stephen Chung <Stephen.Chung@intexact.com>
Date: Tue, 22 Sep 2020 21:29:44 +0800
Subject: [PATCH] Flatten type groups and types in parentheses.

---
 codegen/src/rhai_module.rs  | 18 ++++++++++++++----
 src/packages/string_more.rs |  2 +-
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/codegen/src/rhai_module.rs b/codegen/src/rhai_module.rs
index c25c9484..2ebfb930 100644
--- a/codegen/src/rhai_module.rs
+++ b/codegen/src/rhai_module.rs
@@ -85,12 +85,22 @@ pub(crate) fn generate_body(
             .map(|fnarg| match fnarg {
                 syn::FnArg::Receiver(_) => panic!("internal error: receiver fn outside impl!?"),
                 syn::FnArg::Typed(syn::PatType { ref ty, .. }) => {
-                    let arg_type = match ty.as_ref() {
+                    fn flatten_groups(ty: &syn::Type) -> &syn::Type {
+                        match ty {
+                            syn::Type::Group(syn::TypeGroup { ref elem, .. })
+                            | syn::Type::Paren(syn::TypeParen { ref elem, .. }) => {
+                                flatten_groups(elem.as_ref())
+                            }
+                            _ => ty,
+                        }
+                    }
+
+                    let arg_type = match flatten_groups(ty.as_ref()) {
                         syn::Type::Reference(syn::TypeReference {
                             mutability: None,
                             ref elem,
                             ..
-                        }) => match elem.as_ref() {
+                        }) => match flatten_groups(elem.as_ref()) {
                             syn::Type::Path(ref p) if p.path == str_type_path => {
                                 syn::parse2::<syn::Type>(quote! {
                                 ImmutableString })
@@ -107,11 +117,11 @@ pub(crate) fn generate_body(
                             mutability: Some(_),
                             ref elem,
                             ..
-                        }) => match elem.as_ref() {
+                        }) => match flatten_groups(elem.as_ref()) {
                             syn::Type::Path(ref p) => syn::parse2::<syn::Type>(quote! {
                             #p })
                             .unwrap(),
-                            _ => panic!("internal error: non-string shared reference!?"),
+                            _ => panic!("internal error: invalid mutable reference!?"),
                         },
                         t => t.clone(),
                     };
diff --git a/src/packages/string_more.rs b/src/packages/string_more.rs
index 218f2dd8..fe6235d1 100644
--- a/src/packages/string_more.rs
+++ b/src/packages/string_more.rs
@@ -40,7 +40,7 @@ macro_rules! gen_concat_functions {
 
 macro_rules! reg_functions {
     ($mod_name:ident += $root:ident ; $($arg_type:ident),+) => { $(
-        combine_with_exported_module!($mod_name, "strings_merge", $root::$arg_type::functions);
+        combine_with_exported_module!($mod_name, "strings_concat", $root::$arg_type::functions);
     )* }
 }