Reduce allocations

Author: tomhoule

graphql_client_codegen/src/codegen.rs

@@ -9,7 +9,10 @@ use schema;
 use selection::Selection;
 
 /// Selects the first operation matching `struct_name` or the first one. Returns `None` when the query document defines no operation.
-pub(crate) fn select_operation(query: &query::Document, struct_name: &str) -> Option<Operation> {
+pub(crate) fn select_operation<'query>(
+    query: &'query query::Document,
+    struct_name: &str,
+) -> Option<Operation<'query>> {
     let operations = all_operations(query);
 
     operations
@@ -31,9 +34,9 @@ pub(crate) fn all_operations(query: &query::Document) -> Vec<Operation> {
 }
 
 /// The main code generation function.
-pub fn response_for_query(
-    schema: schema::Schema,
-    query: query::Document,
+pub(crate) fn response_for_query(
+    schema: &schema::Schema,
+    query: &query::Document,
     operation: &Operation,
     additional_derives: Option<String>,
     deprecation_strategy: deprecation::DeprecationStrategy,
@@ -47,17 +50,17 @@ pub fn response_for_query(
 
     let mut definitions = Vec::new();
 
-    for definition in query.definitions {
+    for definition in &query.definitions {
         match definition {
             query::Definition::Operation(_op) => (),
             query::Definition::Fragment(fragment) => {
-                let query::TypeCondition::On(on) = fragment.type_condition;
+                let &query::TypeCondition::On(ref on) = &fragment.type_condition;
                 context.fragments.insert(
-                    fragment.name.clone(),
+                    &fragment.name,
                     GqlFragment {
-                        name: fragment.name,
+                        name: &fragment.name,
                         selection: Selection::from(&fragment.selection_set),
-                        on,
+                        on: on,
                         is_required: false.into(),
                     },
                 );
@@ -67,7 +70,7 @@ pub fn response_for_query(
 
     let response_data_fields = {
         let opt_root_name = operation.root_name(&context.schema);
-        let root_name: String = if let Some(root_name) = opt_root_name {
+        let root_name: &str = if let Some(root_name) = opt_root_name {
             root_name
         } else {
             panic!(

graphql_client_codegen/src/constants.rs

@@ -4,19 +4,19 @@ use objects::GqlObjectField;
 
 pub(crate) const TYPENAME_FIELD: &str = "__typename";
 
-pub(crate) fn string_type() -> String {
-    "String".to_string()
+pub(crate) fn string_type() -> &'static str {
+    "String"
 }
 
 #[cfg(test)]
-pub(crate) fn float_type() -> String {
-    "Float".to_string()
+pub(crate) fn float_type() -> &'static str {
+    "Float"
 }
 
-pub(crate) fn typename_field() -> GqlObjectField {
+pub(crate) fn typename_field() -> GqlObjectField<'static> {
     GqlObjectField {
         description: None,
-        name: TYPENAME_FIELD.to_string(),
+        name: TYPENAME_FIELD,
         /// Non-nullable, see spec:
         /// https://github.com/facebook/graphql/blob/master/spec/Section%204%20--%20Introspection.md
         type_: FieldType::Named(string_type()),

graphql_client_codegen/src/enums.rs

@@ -4,20 +4,20 @@ use std::cell::Cell;
 pub const ENUMS_PREFIX: &str = "";
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct EnumVariant {
-    pub description: Option<String>,
-    pub name: String,
+pub struct EnumVariant<'schema> {
+    pub description: Option<&'schema str>,
+    pub name: &'schema str,
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct GqlEnum {
-    pub description: Option<String>,
-    pub name: String,
-    pub variants: Vec<EnumVariant>,
+pub struct GqlEnum<'schema> {
+    pub description: Option<&'schema str>,
+    pub name: &'schema str,
+    pub variants: Vec<EnumVariant<'schema>>,
     pub is_required: Cell<bool>,
 }
 
-impl GqlEnum {
+impl<'schema> GqlEnum<'schema> {
     pub(crate) fn to_rust(&self, query_context: &::query::QueryContext) -> TokenStream {
         let derives = query_context.response_enum_derives();
         let variant_names: Vec<TokenStream> = self
@@ -41,7 +41,7 @@ impl GqlEnum {
             })
             .collect();
         let constructors = &constructors;
-        let variant_str: Vec<&str> = self.variants.iter().map(|v| v.name.as_str()).collect();
+        let variant_str: Vec<&str> = self.variants.iter().map(|v| v.name).collect();
         let variant_str = &variant_str;
 
         let name = name_ident.clone();

graphql_client_codegen/src/field_type.rs

@@ -6,19 +6,19 @@ use query::QueryContext;
 use schema::DEFAULT_SCALARS;
 
 #[derive(Clone, Debug, PartialEq, Hash)]
-pub enum FieldType {
-    Named(String),
-    Optional(Box<FieldType>),
-    Vector(Box<FieldType>),
+pub enum FieldType<'a> {
+    Named(&'a str),
+    Optional(Box<FieldType<'a>>),
+    Vector(Box<FieldType<'a>>),
 }
 
-impl FieldType {
+impl<'a> FieldType<'a> {
     /// Takes a field type with its name
     pub(crate) fn to_rust(&self, context: &QueryContext, prefix: &str) -> TokenStream {
-        let prefix: String = if prefix.is_empty() {
-            self.inner_name_string()
+        let prefix: &str = if prefix.is_empty() {
+            self.inner_name_str()
         } else {
-            prefix.to_string()
+            prefix
         };
         match &self {
             FieldType::Named(ref name) => {
@@ -30,7 +30,7 @@ impl FieldType {
                     .is_some()
                     || DEFAULT_SCALARS.iter().any(|elem| elem == name)
                 {
-                    name.clone()
+                    name.to_string()
                 } else if context
                     .schema
                     .enums
@@ -43,7 +43,7 @@ impl FieldType {
                     if prefix.is_empty() {
                         panic!("Empty prefix for {:?}", self);
                     }
-                    prefix
+                    prefix.to_string()
                 };
                 let full_name = Ident::new(&full_name, Span::call_site());
 
@@ -61,11 +61,11 @@ impl FieldType {
     }
 
     /// Return the innermost name - we mostly use this for looking types up in our Schema struct.
-    pub fn inner_name_string(&self) -> String {
+    pub fn inner_name_str(&self) -> &str {
         match &self {
-            FieldType::Named(name) => name.to_string(),
-            FieldType::Optional(inner) => inner.inner_name_string(),
-            FieldType::Vector(inner) => inner.inner_name_string(),
+            FieldType::Named(name) => name,
+            FieldType::Optional(inner) => inner.inner_name_str(),
+            FieldType::Vector(inner) => inner.inner_name_str(),
         }
     }
 
@@ -77,16 +77,19 @@ impl FieldType {
     }
 }
 
-impl ::std::convert::From<graphql_parser::schema::Type> for FieldType {
-    fn from(schema_type: graphql_parser::schema::Type) -> FieldType {
+impl<'schema> ::std::convert::From<&'schema graphql_parser::schema::Type> for FieldType<'schema> {
+    fn from(schema_type: &'schema graphql_parser::schema::Type) -> FieldType<'schema> {
         from_schema_type_inner(schema_type, false)
     }
 }
 
-fn from_schema_type_inner(inner: graphql_parser::schema::Type, non_null: bool) -> FieldType {
+fn from_schema_type_inner<'schema>(
+    inner: &'schema graphql_parser::schema::Type,
+    non_null: bool,
+) -> FieldType<'schema> {
     match inner {
         graphql_parser::schema::Type::ListType(inner) => {
-            let inner = from_schema_type_inner(*inner, false);
+            let inner = from_schema_type_inner(&*inner, false);
             let f = FieldType::Vector(Box::new(inner));
             if non_null {
                 f
@@ -102,21 +105,21 @@ fn from_schema_type_inner(inner: graphql_parser::schema::Type, non_null: bool) -
                 FieldType::Optional(Box::new(f))
             }
         }
-        graphql_parser::schema::Type::NonNullType(inner) => from_schema_type_inner(*inner, true),
+        graphql_parser::schema::Type::NonNullType(inner) => from_schema_type_inner(&*inner, true),
     }
 }
 
 fn from_json_type_inner(inner: &introspection_response::TypeRef, non_null: bool) -> FieldType {
     use introspection_response::*;
-    let inner = inner.clone();
 
     match inner.kind {
-        Some(__TypeKind::NON_NULL) => {
-            from_json_type_inner(&inner.of_type.expect("inner type is missing"), true)
-        }
+        Some(__TypeKind::NON_NULL) => from_json_type_inner(
+            &inner.of_type.as_ref().expect("inner type is missing"),
+            true,
+        ),
         Some(__TypeKind::LIST) => {
             let f = FieldType::Vector(Box::new(from_json_type_inner(
-                &inner.of_type.expect("inner type is missing"),
+                &inner.of_type.as_ref().expect("inner type is missing"),
                 false,
             )));
             if non_null {
@@ -126,7 +129,7 @@ fn from_json_type_inner(inner: &introspection_response::TypeRef, non_null: bool)
             }
         }
         Some(_) => {
-            let f = FieldType::Named(inner.name.expect("type name").clone());
+            let f = FieldType::Named(&inner.name.as_ref().expect("type name"));
             if non_null {
                 f
             } else {
@@ -137,14 +140,18 @@ fn from_json_type_inner(inner: &introspection_response::TypeRef, non_null: bool)
     }
 }
 
-impl ::std::convert::From<introspection_response::FullTypeFieldsType> for FieldType {
-    fn from(schema_type: introspection_response::FullTypeFieldsType) -> FieldType {
+impl<'schema> ::std::convert::From<&'schema introspection_response::FullTypeFieldsType>
+    for FieldType<'schema>
+{
+    fn from(
+        schema_type: &'schema introspection_response::FullTypeFieldsType,
+    ) -> FieldType<'schema> {
         from_json_type_inner(&schema_type.type_ref, false)
     }
 }
 
-impl ::std::convert::From<introspection_response::InputValueType> for FieldType {
-    fn from(schema_type: introspection_response::InputValueType) -> FieldType {
+impl<'a> ::std::convert::From<&'a introspection_response::InputValueType> for FieldType<'a> {
+    fn from(schema_type: &'a introspection_response::InputValueType) -> FieldType<'a> {
         from_json_type_inner(&schema_type.type_ref, false)
     }
 }
@@ -157,29 +164,29 @@ mod tests {
 
     #[test]
     fn field_type_from_graphql_parser_schema_type_works() {
-        let ty = GqlParserType::NamedType("Cat".to_string());
+        let ty = GqlParserType::NamedType("Cat".to_owned());
         assert_eq!(
-            FieldType::from(ty),
-            FieldType::Optional(Box::new(FieldType::Named("Cat".to_string())))
+            FieldType::from(&ty),
+            FieldType::Optional(Box::new(FieldType::Named("Cat")))
         );
 
-        let ty = GqlParserType::NonNullType(Box::new(GqlParserType::NamedType("Cat".to_string())));
+        let ty = GqlParserType::NonNullType(Box::new(GqlParserType::NamedType("Cat".to_owned())));
 
-        assert_eq!(FieldType::from(ty), FieldType::Named("Cat".to_string()));
+        assert_eq!(FieldType::from(&ty), FieldType::Named("Cat"));
     }
 
     #[test]
     fn field_type_from_introspection_response_works() {
         let ty = FullTypeFieldsType {
             type_ref: TypeRef {
                 kind: Some(__TypeKind::OBJECT),
-                name: Some("Cat".to_string()),
+                name: Some("Cat".into()),
                 of_type: None,
             },
         };
         assert_eq!(
-            FieldType::from(ty),
-            FieldType::Optional(Box::new(FieldType::Named("Cat".to_string())))
+            FieldType::from(&ty),
+            FieldType::Optional(Box::new(FieldType::Named("Cat")))
         );
 
         let ty = FullTypeFieldsType {
@@ -188,11 +195,11 @@ mod tests {
                 name: None,
                 of_type: Some(Box::new(TypeRef {
                     kind: Some(__TypeKind::OBJECT),
-                    name: Some("Cat".to_string()),
+                    name: Some("Cat".into()),
                     of_type: None,
                 })),
             },
         };
-        assert_eq!(FieldType::from(ty), FieldType::Named("Cat".to_string()));
+        assert_eq!(FieldType::from(&ty), FieldType::Named("Cat"));
     }
 }

graphql_client_codegen/src/fragments.rs

@@ -5,18 +5,18 @@ use std::cell::Cell;
 
 /// Represents a fragment extracted from a query document.
 #[derive(Debug, PartialEq)]
-pub(crate) struct GqlFragment {
+pub(crate) struct GqlFragment<'query> {
     /// The name of the fragment, matching one-to-one with the name in the GraphQL query document.
-    pub name: String,
+    pub name: &'query str,
     /// The `on` clause of the fragment.
-    pub on: String,
+    pub on: &'query str,
     /// The selected fields.
-    pub selection: Selection,
-    /// Whether the fragment
+    pub selection: Selection<'query>,
+    /// Whether the fragment is used in the current query
     pub is_required: Cell<bool>,
 }
 
-impl GqlFragment {
+impl<'query> GqlFragment<'query> {
     /// Generate all the Rust code required by the fragment's selection.
     pub(crate) fn to_rust(&self, context: &QueryContext) -> Result<TokenStream, ::failure::Error> {
         if let Some(obj) = context.schema.objects.get(&self.on) {