Use borrowed names when constructing Type instances

Author: mhallin

src/ast.rs

@@ -13,19 +13,19 @@ use parser::Spanning;
 /// This enum carries no semantic information and might refer to types that do
 /// not exist.
 #[derive(Clone, Eq, PartialEq, Debug)]
-pub enum Type {
+pub enum Type<'a> {
     /// A nullable named type, e.g. `String`
-    Named(String),
+    Named(&'a str),
     /// A nullable list type, e.g. `[String]`
     ///
     /// The list itself is what's nullable, the containing type might be non-null.
-    List(Box<Type>),
+    List(Box<Type<'a>>),
     /// A non-null named type, e.g. `String!`
-    NonNullNamed(String),
+    NonNullNamed(&'a str),
     /// A non-null list type, e.g. `[String]!`.
     ///
     /// The list itself is what's non-null, the containing type might be null.
-    NonNullList(Box<Type>),
+    NonNullList(Box<Type<'a>>),
 }
 
 /// A JSON-like value that can be passed into the query execution, either
@@ -49,8 +49,8 @@ pub enum InputValue {
 }
 
 #[derive(Clone, PartialEq, Debug)]
-pub struct VariableDefinition {
-    pub var_type: Spanning<Type>,
+pub struct VariableDefinition<'a> {
+    pub var_type: Spanning<Type<'a>>,
     pub default_value: Option<Spanning<InputValue>>,
 }
 
@@ -60,8 +60,8 @@ pub struct Arguments {
 }
 
 #[derive(Clone, PartialEq, Debug)]
-pub struct VariableDefinitions {
-    pub items: Vec<(Spanning<String>, VariableDefinition)>,
+pub struct VariableDefinitions<'a> {
+    pub items: Vec<(Spanning<String>, VariableDefinition<'a>)>,
 }
 
 #[derive(Clone, PartialEq, Debug)]
@@ -122,10 +122,10 @@ pub enum OperationType {
 }
 
 #[derive(Clone, PartialEq, Debug)]
-pub struct Operation {
+pub struct Operation<'a> {
     pub operation_type: OperationType,
     pub name: Option<Spanning<String>>,
-    pub variable_definitions: Option<Spanning<VariableDefinitions>>,
+    pub variable_definitions: Option<Spanning<VariableDefinitions<'a>>>,
     pub directives: Option<Vec<Spanning<Directive>>>,
     pub selection_set: Vec<Selection>,
 }
@@ -139,12 +139,12 @@ pub struct Fragment {
 }
 
 #[derive(Clone, PartialEq, Debug)]
-pub enum Definition {
-    Operation(Spanning<Operation>),
+pub enum Definition<'a> {
+    Operation(Spanning<Operation<'a>>),
     Fragment(Spanning<Fragment>),
 }
 
-pub type Document = Vec<Definition>;
+pub type Document<'a> = Vec<Definition<'a>>;
 
 /// Parse an unstructured input value into a Rust data type.
 ///
@@ -163,7 +163,7 @@ pub trait ToInputValue: Sized {
     fn to(&self) -> InputValue;
 }
 
-impl Type {
+impl<'a> Type<'a> {
     /// Get the name of a named type.
     ///
     /// Only applies to named types; lists will return `None`.
@@ -193,7 +193,7 @@ impl Type {
     }
 }
 
-impl fmt::Display for Type {
+impl<'a> fmt::Display for Type<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Type::Named(ref n) => write!(f, "{}", n),
@@ -447,7 +447,7 @@ impl Arguments {
     }
 }
 
-impl VariableDefinitions {
+impl<'a> VariableDefinitions<'a> {
     pub fn iter(&self) -> slice::Iter<(Spanning<String>, VariableDefinition)> {
         self.items.iter()
     }

src/executor.rs

@@ -19,9 +19,9 @@ use types::base::GraphQLType;
 /// The registry gathers metadata for all types in a schema. It provides
 /// convenience methods to convert types implementing the `GraphQLType` trait
 /// into `Type` instances and automatically registers them.
-pub struct Registry {
+pub struct Registry<'r> {
     /// Currently registered types
-    pub types: HashMap<String, MetaType>,
+    pub types: HashMap<String, MetaType<'r>>,
 }
 
 #[derive(Clone)]
@@ -38,7 +38,7 @@ pub struct Executor<'a, CtxT> where CtxT: 'a {
     fragments: &'a HashMap<&'a str, &'a Fragment>,
     variables: &'a HashMap<String, InputValue>,
     current_selection_set: Option<&'a [Selection]>,
-    schema: &'a SchemaType,
+    schema: &'a SchemaType<'a>,
     context: &'a CtxT,
     errors: &'a RwLock<Vec<ExecutionError>>,
     field_path: FieldPath<'a>,
@@ -353,9 +353,9 @@ pub fn execute_validated_query<'a, QueryT, MutationT, CtxT>(
     Ok((value, errors))
 }
 
-impl Registry {
+impl<'r> Registry<'r> {
     /// Construct a new registry
-    pub fn new(types: HashMap<String, MetaType>) -> Registry {
+    pub fn new(types: HashMap<String, MetaType<'r>>) -> Registry<'r> {
         Registry {
             types: types,
         }
@@ -365,10 +365,10 @@ impl Registry {
     ///
     /// If the registry hasn't seen a type with this name before, it will
     /// construct its metadata and store it.
-    pub fn get_type<T>(&mut self) -> Type where T: GraphQLType {
+    pub fn get_type<T>(&mut self) -> Type<'r> where T: GraphQLType {
         if let Some(name) = T::name() {
             if !self.types.contains_key(name) {
-                self.insert_placeholder(name, Type::NonNullNamed(name.to_owned()));
+                self.insert_placeholder(name, Type::NonNullNamed(name));
                 let meta = T::meta(self);
                 self.types.insert(name.to_owned(), meta);
             }
@@ -380,7 +380,7 @@ impl Registry {
     }
 
     /// Create a field with the provided name
-    pub fn field<T>(&mut self, name: &str) -> Field where T: GraphQLType {
+    pub fn field<T>(&mut self, name: &str) -> Field<'r> where T: GraphQLType {
         Field {
             name: name.to_owned(),
             description: None,
@@ -391,7 +391,7 @@ impl Registry {
     }
 
     #[doc(hidden)]
-    pub fn field_convert<'a, T: IntoResolvable<'a, I, C>, I, C>(&mut self, name: &str) -> Field
+    pub fn field_convert<'a, T: IntoResolvable<'a, I, C>, I, C>(&mut self, name: &str) -> Field<'r>
         where I: GraphQLType
     {
         Field {
@@ -404,7 +404,7 @@ impl Registry {
     }
 
     /// Create an argument with the provided name
-    pub fn arg<T>(&mut self, name: &str) -> Argument where T: GraphQLType + FromInputValue {
+    pub fn arg<T>(&mut self, name: &str) -> Argument<'r> where T: GraphQLType + FromInputValue {
         Argument::new(name, self.get_type::<T>())
     }
 
@@ -417,14 +417,14 @@ impl Registry {
         name: &str,
         value: &T,
     )
-        -> Argument
+        -> Argument<'r>
         where T: GraphQLType + ToInputValue + FromInputValue
     {
         Argument::new(name, self.get_type::<Option<T>>())
             .default_value(value.to())
     }
 
-    fn insert_placeholder(&mut self, name: &str, of_type: Type) {
+    fn insert_placeholder(&mut self, name: &str, of_type: Type<'r>) {
         if !self.types.contains_key(name) {
             self.types.insert(
                 name.to_owned(),
@@ -435,22 +435,21 @@ impl Registry {
     /// Create a scalar meta type
     ///
     /// This expects the type to implement `FromInputValue`.
-    pub fn build_scalar_type<T>(&mut self)
-        -> ScalarMeta
+    pub fn build_scalar_type<T>(&mut self) -> ScalarMeta<'r>
         where T: FromInputValue + GraphQLType
     {
         let name = T::name().expect("Scalar types must be named. Implement name()");
         ScalarMeta::new::<T>(name)
     }
 
     /// Create a list meta type
-    pub fn build_list_type<T: GraphQLType>(&mut self) -> ListMeta {
+    pub fn build_list_type<T: GraphQLType>(&mut self) -> ListMeta<'r> {
         let of_type = self.get_type::<T>();
         ListMeta::new(of_type)
     }
 
     /// Create a nullable meta type
-    pub fn build_nullable_type<T: GraphQLType>(&mut self) -> NullableMeta {
+    pub fn build_nullable_type<T: GraphQLType>(&mut self) -> NullableMeta<'r> {
         let of_type = self.get_type::<T>();
         NullableMeta::new(of_type)
     }
@@ -459,62 +458,51 @@ impl Registry {
     ///
     /// To prevent infinite recursion by enforcing ordering, this returns a
     /// function that needs to be called with the list of fields on the object.
-    pub fn build_object_type<T>(&mut self)
-        -> Box<Fn(&[Field]) -> ObjectMeta>
+    pub fn build_object_type<T>(&mut self, fields: &[Field<'r>]) -> ObjectMeta<'r>
         where T: GraphQLType
     {
         let name = T::name().expect("Object types must be named. Implement name()");
-        let typename_field = self.field::<String>("__typename");
 
-        Box::new(move |fs: &[Field]| {
-            let mut v = fs.to_vec();
-            v.push(typename_field.clone());
-            ObjectMeta::new(name, &v)
-        })
+        let mut v = fields.to_vec();
+        v.push(self.field::<String>("__typename"));
+        ObjectMeta::new(name, &v)
     }
 
     /// Create an enum meta type
-    pub fn build_enum_type<T>(&mut self)
-        -> Box<Fn(&[EnumValue]) -> EnumMeta>
+    pub fn build_enum_type<T>(&mut self, values: &[EnumValue]) -> EnumMeta<'r>
         where T: FromInputValue + GraphQLType
     {
         let name = T::name().expect("Enum types must be named. Implement name()");
 
-        Box::new(move |values: &[EnumValue]| EnumMeta::new::<T>(name, values))
+        EnumMeta::new::<T>(name, values)
     }
 
     /// Create an interface meta type builder
-    pub fn build_interface_type<T>(&mut self)
-        -> Box<Fn(&[Field]) -> InterfaceMeta>
+    pub fn build_interface_type<T>(&mut self, fields: &[Field<'r>]) -> InterfaceMeta<'r>
         where T: GraphQLType
     {
         let name = T::name().expect("Interface types must be named. Implement name()");
-        let typename_field = self.field::<String>("__typename");
 
-        Box::new(move |fs: &[Field]| {
-            let mut v = fs.to_vec();
-            v.push(typename_field.clone());
-            InterfaceMeta::new(name, &v)
-        })
+        let mut v = fields.to_vec();
+        v.push(self.field::<String>("__typename"));
+        InterfaceMeta::new(name, &v)
     }
 
     /// Create a union meta type builder
-    pub fn build_union_type<T>(&mut self)
-        -> Box<Fn(&[Type]) -> UnionMeta>
+    pub fn build_union_type<T>(&mut self, types: &[Type<'r>]) -> UnionMeta<'r>
         where T: GraphQLType
     {
         let name = T::name().expect("Union types must be named. Implement name()");
 
-        Box::new(move |ts: &[Type]| UnionMeta::new(name, ts))
+        UnionMeta::new(name, types)
     }
 
     /// Create an input object meta type builder
-    pub fn build_input_object_type<T>(&mut self)
-        -> Box<Fn(&[Argument]) -> InputObjectMeta>
+    pub fn build_input_object_type<T>(&mut self, args: &[Argument<'r>]) -> InputObjectMeta<'r>
         where T: FromInputValue + GraphQLType
     {
         let name = T::name().expect("Input object types must be named. Implement name()");
 
-        Box::new(move |args: &[Argument]| InputObjectMeta::new::<T>(name, args))
+        InputObjectMeta::new::<T>(name, args)
     }
 }

src/integrations/iron_handlers.rs

@@ -22,23 +22,23 @@ use ::{InputValue, GraphQLType, RootNode, execute};
 /// this endpoint containing the field `"query"` and optionally `"variables"`.
 /// The variables should be a JSON object containing the variable to value
 /// mapping.
-pub struct GraphQLHandler<CtxFactory, Query, Mutation, CtxT>
+pub struct GraphQLHandler<'a, CtxFactory, Query, Mutation, CtxT>
     where CtxFactory: Fn(&mut Request) -> CtxT + Send + Sync + 'static,
           CtxT: 'static,
           Query: GraphQLType<Context=CtxT> + Send + Sync + 'static,
           Mutation: GraphQLType<Context=CtxT> + Send + Sync + 'static,
 {
     context_factory: CtxFactory,
-    root_node: RootNode<Query, Mutation>,
+    root_node: RootNode<'a, Query, Mutation>,
 }
 
 /// Handler that renders GraphiQL - a graphical query editor interface
 pub struct GraphiQLHandler {
     graphql_url: String,
 }
 
-impl<CtxFactory, Query, Mutation, CtxT>
-    GraphQLHandler<CtxFactory, Query, Mutation, CtxT>
+impl<'a, CtxFactory, Query, Mutation, CtxT>
+    GraphQLHandler<'a, CtxFactory, Query, Mutation, CtxT>
     where CtxFactory: Fn(&mut Request) -> CtxT + Send + Sync + 'static,
           CtxT: 'static,
           Query: GraphQLType<Context=CtxT> + Send + Sync + 'static,
@@ -145,13 +145,13 @@ impl GraphiQLHandler {
     }
 }
 
-impl<CtxFactory, Query, Mutation, CtxT>
+impl<'a, CtxFactory, Query, Mutation, CtxT>
     Handler
-    for GraphQLHandler<CtxFactory, Query, Mutation, CtxT>
+    for GraphQLHandler<'a, CtxFactory, Query, Mutation, CtxT>
     where CtxFactory: Fn(&mut Request) -> CtxT + Send + Sync + 'static,
           CtxT: 'static,
           Query: GraphQLType<Context=CtxT> + Send + Sync + 'static,
-          Mutation: GraphQLType<Context=CtxT> + Send + Sync + 'static,
+          Mutation: GraphQLType<Context=CtxT> + Send + Sync + 'static, 'a: 'static,
 {
     fn handle(&self, req: &mut Request) -> IronResult<Response> {
         match req.method {

src/macros/enums.rs

@@ -66,10 +66,10 @@ macro_rules! graphql_enum {
                 Some(graphql_enum!(@as_expr, $outname))
             }
 
-            fn meta(registry: &mut $crate::Registry) -> $crate::meta::MetaType {
+            fn meta<'r>(registry: &mut $crate::Registry<'r>) -> $crate::meta::MetaType<'r> {
                 graphql_enum!(
                     @maybe_apply, $descr, description,
-                    registry.build_enum_type::<$name>()(&[
+                    registry.build_enum_type::<$name>(&[
                         $(
                             graphql_enum!(
                                 @maybe_apply,

src/macros/input_object.rs

@@ -155,12 +155,11 @@ macro_rules! graphql_input_object {
                 Some($outname)
             }
 
-            fn meta(registry: &mut $crate::Registry) -> $crate::meta::MetaType {
+            fn meta<'r>(registry: &mut $crate::Registry<'r>) -> $crate::meta::MetaType<'r> {
+                let fields = graphql_input_object!(@generate_meta_fields, registry, $fields);
                 graphql_input_object!(
                     @maybe_apply, $descr, description,
-                    registry.build_input_object_type::<$name>()(
-                        graphql_input_object!(@generate_meta_fields, registry, $fields)
-                    )).into_meta()
+                    registry.build_input_object_type::<$name>(fields)).into_meta()
             }
         }
     };

src/macros/interface.rs

@@ -236,11 +236,11 @@ macro_rules! graphql_interface {
 
             #[allow(unused_assignments)]
             #[allow(unused_mut)]
-            fn meta(registry: &mut $crate::Registry) -> $crate::meta::MetaType {
+            fn meta<'r>(registry: &mut $crate::Registry<'r>) -> $crate::meta::MetaType<'r> {
                 let mut fields = Vec::new();
                 let mut description = None;
                 graphql_interface!(@ gather_meta, (registry, fields, description), $($items)*);
-                let mut mt = registry.build_interface_type::<$name>()(&fields);
+                let mut mt = registry.build_interface_type::<$name>(&fields);
 
                 if let Some(description) = description {
                     mt = mt.description(description);