From 6a484c48c5a7943119c65be5288e9c811eae6601 Mon Sep 17 00:00:00 2001
From: Tim Kuehn <timothy.j.kuehn@gmail.com>
Date: Mon, 11 Jan 2016 22:54:53 -0800
Subject: [PATCH] Obfuscate types internal to the generated module to reduce
 risk of collision with imports.

We don't support imports in the macro yet, but this commit will prevent problems when we do.
---
 src/macros.rs | 42 +++++++++++++++++-------------------------
 1 file changed, 17 insertions(+), 25 deletions(-)

diff --git a/src/macros.rs b/src/macros.rs
index 3fa6959..7ee6123 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -8,14 +8,14 @@ macro_rules! request_fns {
     ($fn_name:ident( $( $arg:ident : $in_:ty ),* ) -> $out:ty) => (
         pub fn $fn_name(&self, $($arg: $in_),*) -> $crate::Result<$out> {
             let reply = try!((self.0).rpc(&request_variant!($fn_name $($arg),*)));
-            let Reply::$fn_name(reply) = reply;
+            let __Reply::$fn_name(reply) = reply;
             Ok(reply)
         }
     );
     ($( $fn_name:ident( $( $arg:ident : $in_:ty ),* ) -> $out:ty)*) => ( $(
         pub fn $fn_name(&self, $($arg: $in_),*) -> $crate::Result<$out> {
             let reply = try!((self.0).rpc(&request_variant!($fn_name $($arg),*)));
-            if let Reply::$fn_name(reply) = reply {
+            if let __Reply::$fn_name(reply) = reply {
                 Ok(reply)
             } else {
                 Err($crate::Error::InternalError)
@@ -30,7 +30,7 @@ macro_rules! define_request {
     ($(@($($finished:tt)*))* --) => (as_item!(
             #[allow(non_camel_case_types)]
             #[derive(Debug, Serialize, Deserialize)]
-            enum Request { $($($finished)*),* }
+            enum __Request { $($($finished)*),* }
     ););
     ($(@$finished:tt)* -- $name:ident() $($req:tt)*) =>
         (define_request!($(@$finished)* @($name) -- $($req)*););
@@ -42,8 +42,8 @@ macro_rules! define_request {
 // Required because enum variants with no fields can't be suffixed by parens
 #[macro_export]
 macro_rules! request_variant {
-    ($x:ident) => (Request::$x);
-    ($x:ident $($y:ident),+) => (Request::$x($($y),+));
+    ($x:ident) => (__Request::$x);
+    ($x:ident $($y:ident),+) => (__Request::$x($($y),+));
 }
 
 // The main macro that creates RPC services.
@@ -52,13 +52,6 @@ macro_rules! rpc_service { ($server:ident:
     $( $fn_name:ident( $( $arg:ident : $in_:ty ),* ) -> $out:ty;)*) => {
         #[doc="A module containing an rpc service and client stub."]
         pub mod $server {
-            use std::net::ToSocketAddrs;
-            use std::sync::Arc;
-            use $crate::protocol::{
-                self,
-                ServeHandle,
-                serve_async,
-            };
 
             #[doc="The provided RPC service."]
             pub trait Service: Send + Sync {
@@ -71,49 +64,49 @@ macro_rules! rpc_service { ($server:ident:
 
             #[allow(non_camel_case_types)]
             #[derive(Debug, Serialize, Deserialize)]
-            enum Reply {
+            enum __Reply {
                 $(
                     $fn_name($out),
                 )*
             }
 
             #[doc="The client stub that makes RPC calls to the server."]
-            pub struct Client(protocol::Client<Request, Reply>);
+            pub struct Client($crate::protocol::Client<__Request, __Reply>);
 
             impl Client {
                 #[doc="Create a new client that connects to the given address."]
                 pub fn new<A>(addr: A) -> $crate::Result<Self>
-                    where A: ToSocketAddrs,
+                    where A: ::std::net::ToSocketAddrs,
                 {
-                    let inner = try!(protocol::Client::new(addr));
+                    let inner = try!($crate::protocol::Client::new(addr));
                     Ok(Client(inner))
                 }
 
                 request_fns!($($fn_name($($arg: $in_),*) -> $out)*);
             }
 
-            struct Server<S: 'static + Service>(S);
+            struct __Server<S: 'static + Service>(S);
 
-            impl<S> protocol::Serve<Request, Reply> for Server<S>
+            impl<S> $crate::protocol::Serve<__Request, __Reply> for __Server<S>
                 where S: 'static + Service
             {
-                fn serve(&self, request: Request) -> Reply {
+                fn serve(&self, request: __Request) -> __Reply {
                     match request {
                         $(
                             request_variant!($fn_name $($arg),*) =>
-                                Reply::$fn_name((self.0).$fn_name($($arg),*)),
+                                __Reply::$fn_name((self.0).$fn_name($($arg),*)),
                          )*
                     }
                 }
             }
 
             #[doc="Start a running service."]
-            pub fn serve<A, S>(addr: A, service: S) -> $crate::Result<ServeHandle>
-                where A: ToSocketAddrs,
+            pub fn serve<A, S>(addr: A, service: S) -> $crate::Result<$crate::protocol::ServeHandle>
+                where A: ::std::net::ToSocketAddrs,
                       S: 'static + Service
             {
-                let server = Arc::new(Server(service));
-                Ok(try!(serve_async(addr, server)))
+                let server = ::std::sync::Arc::new(__Server(service));
+                Ok(try!($crate::protocol::serve_async(addr, server)))
             }
         }
     }
@@ -122,7 +115,6 @@ macro_rules! rpc_service { ($server:ident:
 #[cfg(test)]
 #[allow(dead_code)]
 mod test {
-
     rpc_service!(my_server:
         hello(foo: super::Foo) -> super::Foo;