Refactor all Ast types to use Cow<'_, str> instead of String

This enhances performance for users that do not want to clone everything,
while still making  owned use easy with the 'static lifetime.

Author: theduke

src/common.rs

@@ -1,4 +1,5 @@
 use std::collections::BTreeMap;
+use std::borrow::Cow;
 
 use combine::{parser, ParseResult, Parser};
 use combine::easy::Error;
@@ -11,13 +12,14 @@ use position::Pos;
 
 
 /// An alias for string, used where graphql expects a name
-pub type Name = String;
+pub type BorrowedStr<'a> = Cow<'a, str>;
+pub type Name<'a> = BorrowedStr<'a>;
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct Directive {
+pub struct Directive<'a> {
     pub position: Pos,
-    pub name: Name,
-    pub arguments: Vec<(Name, Value)>,
+    pub name: Name<'a>,
+    pub arguments: Vec<(Name<'a>, Value<'a>)>,
 }
 
 /// This represents integer number
@@ -32,23 +34,23 @@ pub struct Directive {
 pub struct Number(pub(crate) i64);
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum Value {
-    Variable(Name),
+pub enum Value<'a> {
+    Variable(Name<'a>),
     Int(Number),
     Float(f64),
-    String(String),
+    String(BorrowedStr<'a>),
     Boolean(bool),
     Null,
-    Enum(Name),
-    List(Vec<Value>),
-    Object(BTreeMap<Name, Value>),
+    Enum(Name<'a>),
+    List(Vec<Value<'a>>),
+    Object(BTreeMap<Name<'a>, Value<'a>>),
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum Type {
-    NamedType(Name),
-    ListType(Box<Type>),
-    NonNullType(Box<Type>),
+pub enum Type<'a> {
+    NamedType(Name<'a>),
+    ListType(Box<Type<'a>>),
+    NonNullType(Box<Type<'a>>),
 }
 
 impl Number {
@@ -65,7 +67,7 @@ impl From<i32> for Number {
 }
 
 pub fn directives<'a>(input: &mut TokenStream<'a>)
-    -> ParseResult<Vec<Directive>, TokenStream<'a>>
+    -> ParseResult<Vec<Directive<'a>>, TokenStream<'a>>
 {
     many(position()
         .skip(punct("@"))
@@ -78,7 +80,7 @@ pub fn directives<'a>(input: &mut TokenStream<'a>)
 }
 
 pub fn arguments<'a>(input: &mut TokenStream<'a>)
-    -> ParseResult<Vec<(String, Value)>, TokenStream<'a>>
+    -> ParseResult<Vec<(BorrowedStr<'a>, Value<'a>)>, TokenStream<'a>>
 {
     optional(
         punct("(")
@@ -93,22 +95,22 @@ pub fn arguments<'a>(input: &mut TokenStream<'a>)
 }
 
 pub fn int_value<'a>(input: &mut TokenStream<'a>)
-    -> ParseResult<Value, TokenStream<'a>>
+    -> ParseResult<Value<'a>, TokenStream<'a>>
 {
     kind(T::IntValue).and_then(|tok| tok.value.parse())
             .map(Number).map(Value::Int)
     .parse_stream(input)
 }
 
 pub fn float_value<'a>(input: &mut TokenStream<'a>)
-    -> ParseResult<Value, TokenStream<'a>>
+    -> ParseResult<Value<'a>, TokenStream<'a>>
 {
     kind(T::FloatValue).and_then(|tok| tok.value.parse())
             .map(Value::Float)
     .parse_stream(input)
 }
 
-fn unquote_block_string(src: &str) -> Result<String, Error<Token, Token>> {
+fn unquote_block_string<'a>(src: &'a str) -> Result<BorrowedStr<'a>, Error<Token<'a>, Token<'a>>> {
     debug_assert!(src.starts_with("\"\"\"") && src.ends_with("\"\"\""));
     let indent = src[3..src.len()-3].lines().skip(1)
         .filter_map(|line| {
@@ -141,10 +143,11 @@ fn unquote_block_string(src: &str) -> Result<String, Error<Token, Token>> {
         result.truncate(last_line);
     }
 
-    Ok(result)
+    // FIXME: prevent clone
+    Ok(std::borrow::Cow::Owned(result))
 }
 
-fn unquote_string(s: &str) -> Result<String, Error<Token, Token>> {
+fn unquote_string<'a>(s: &str) -> Result<Cow<'a, str>, Error<Token, Token>> {
     let mut res = String::with_capacity(s.len());
     debug_assert!(s.starts_with('"') && s.ends_with('"'));
     let mut chars = s[1..s.len()-1].chars();
@@ -171,11 +174,12 @@ fn unquote_string(s: &str) -> Result<String, Error<Token, Token>> {
         }
     }
 
-    Ok(res)
+    // FIXME: prevent clone
+    Ok(std::borrow::Cow::Owned(res))
 }
 
 pub fn string<'a>(input: &mut TokenStream<'a>)
-    -> ParseResult<String, TokenStream<'a>>
+    -> ParseResult<BorrowedStr<'a>, TokenStream<'a>>
 {
     choice((
         kind(T::StringValue).and_then(|tok| unquote_string(tok.value)),
@@ -184,23 +188,23 @@ pub fn string<'a>(input: &mut TokenStream<'a>)
 }
 
 pub fn string_value<'a>(input: &mut TokenStream<'a>)
-    -> ParseResult<Value, TokenStream<'a>>
+    -> ParseResult<Value<'a>, TokenStream<'a>>
 {
     kind(T::StringValue).and_then(|tok| unquote_string(tok.value))
         .map(Value::String)
     .parse_stream(input)
 }
 
 pub fn block_string_value<'a>(input: &mut TokenStream<'a>)
-    -> ParseResult<Value, TokenStream<'a>>
+    -> ParseResult<Value<'a>, TokenStream<'a>>
 {
     kind(T::BlockString).and_then(|tok| unquote_block_string(tok.value))
         .map(Value::String)
     .parse_stream(input)
 }
 
 pub fn plain_value<'a>(input: &mut TokenStream<'a>)
-    -> ParseResult<Value, TokenStream<'a>>
+    -> ParseResult<Value<'a>, TokenStream<'a>>
 {
     ident("true").map(|_| Value::Boolean(true))
     .or(ident("false").map(|_| Value::Boolean(false)))
@@ -214,7 +218,7 @@ pub fn plain_value<'a>(input: &mut TokenStream<'a>)
 }
 
 pub fn value<'a>(input: &mut TokenStream<'a>)
-    -> ParseResult<Value, TokenStream<'a>>
+    -> ParseResult<Value<'a>, TokenStream<'a>>
 {
     parser(plain_value)
     .or(punct("$").with(name()).map(Value::Variable))
@@ -228,7 +232,7 @@ pub fn value<'a>(input: &mut TokenStream<'a>)
 }
 
 pub fn default_value<'a>(input: &mut TokenStream<'a>)
-    -> ParseResult<Value, TokenStream<'a>>
+    -> ParseResult<Value<'a>, TokenStream<'a>>
 {
     parser(plain_value)
     .or(punct("[").with(many(parser(default_value))).skip(punct("]"))
@@ -241,7 +245,7 @@ pub fn default_value<'a>(input: &mut TokenStream<'a>)
 }
 
 pub fn parse_type<'a>(input: &mut TokenStream<'a>)
-    -> ParseResult<Type, TokenStream<'a>>
+    -> ParseResult<Type<'a>, TokenStream<'a>>
 {
     name().map(Type::NamedType)
     .or(punct("[")

src/format.rs

@@ -147,4 +147,14 @@ macro_rules! impl_display {
             }
         )+
     };
+
+    ('a $($typ: ident, )+) => {
+        $(
+            impl<'a> fmt::Display for $typ<'a> {
+                fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                    f.write_str(&to_string(self))
+                }
+            }
+        )+
+    };
 }

src/helpers.rs

@@ -7,6 +7,8 @@ use combine::stream::easy::{Error, Errors, Info};
 use tokenizer::{TokenStream, Kind, Token};
 use position::Pos;
 
+use super::common::BorrowedStr;
+
 
 #[derive(Debug, Clone)]
 pub struct TokenMatch<'a> {
@@ -99,15 +101,15 @@ impl<'a> Parser for Value<'a> {
 
 impl<'a> Parser for NameMatch<'a> {
     type Input = TokenStream<'a>;
-    type Output = String;
+    type Output = BorrowedStr<'a>;
     type PartialState = ();
 
     #[inline]
     fn parse_lazy(&mut self, input: &mut Self::Input)
         -> ConsumedResult<Self::Output, Self::Input>
     {
         satisfy(|c: Token<'a>| c.kind == Kind::Name)
-        .map(|t: Token<'a>| t.value.to_string())
+        .map(|t: Token<'a>| t.value.into())
         .parse_lazy(input)
     }
 

src/query/ast.rs

@@ -6,111 +6,111 @@
 //! [graphql grammar]: http://facebook.github.io/graphql/October2016/#sec-Appendix-Grammar-Summary
 //!
 use position::Pos;
-pub use common::{Directive, Number, Value, Name, Type};
+pub use common::{Directive, Number, Value, BorrowedStr, Name, Type};
 
 /// Root of query data
 #[derive(Debug, Clone, PartialEq)]
-pub struct Document {
-    pub definitions: Vec<Definition>,
+pub struct Document<'a> {
+    pub definitions: Vec<Definition<'a>>,
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum Definition {
-    Operation(OperationDefinition),
-    Fragment(FragmentDefinition),
+pub enum Definition<'a> {
+    Operation(OperationDefinition<'a>),
+    Fragment(FragmentDefinition<'a>),
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct FragmentDefinition {
+pub struct FragmentDefinition<'a> {
     pub position: Pos,
-    pub name: Name,
-    pub type_condition: TypeCondition,
-    pub directives: Vec<Directive>,
-    pub selection_set: SelectionSet,
+    pub name: Name<'a>,
+    pub type_condition: TypeCondition<'a>,
+    pub directives: Vec<Directive<'a>>,
+    pub selection_set: SelectionSet<'a>,
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum OperationDefinition {
-    SelectionSet(SelectionSet),
-    Query(Query),
-    Mutation(Mutation),
-    Subscription(Subscription),
+pub enum OperationDefinition<'a> {
+    SelectionSet(SelectionSet<'a>),
+    Query(Query<'a>),
+    Mutation(Mutation<'a>),
+    Subscription(Subscription<'a>),
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct Query {
+pub struct Query<'a> {
     pub position: Pos,
-    pub name: Option<Name>,
-    pub variable_definitions: Vec<VariableDefinition>,
-    pub directives: Vec<Directive>,
-    pub selection_set: SelectionSet,
+    pub name: Option<Name<'a>>,
+    pub variable_definitions: Vec<VariableDefinition<'a>>,
+    pub directives: Vec<Directive<'a>>,
+    pub selection_set: SelectionSet<'a>,
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct Mutation {
+pub struct Mutation<'a> {
     pub position: Pos,
-    pub name: Option<Name>,
-    pub variable_definitions: Vec<VariableDefinition>,
-    pub directives: Vec<Directive>,
-    pub selection_set: SelectionSet,
+    pub name: Option<Name<'a>>,
+    pub variable_definitions: Vec<VariableDefinition<'a>>,
+    pub directives: Vec<Directive<'a>>,
+    pub selection_set: SelectionSet<'a>,
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct Subscription {
+pub struct Subscription<'a> {
     pub position: Pos,
-    pub name: Option<Name>,
-    pub variable_definitions: Vec<VariableDefinition>,
-    pub directives: Vec<Directive>,
-    pub selection_set: SelectionSet,
+    pub name: Option<Name<'a>>,
+    pub variable_definitions: Vec<VariableDefinition<'a>>,
+    pub directives: Vec<Directive<'a>>,
+    pub selection_set: SelectionSet<'a>,
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct SelectionSet {
+pub struct SelectionSet<'a> {
     pub span: (Pos, Pos),
-    pub items: Vec<Selection>,
+    pub items: Vec<Selection<'a>>,
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct VariableDefinition {
+pub struct VariableDefinition<'a> {
     pub position: Pos,
-    pub name: Name,
-    pub var_type: Type,
-    pub default_value: Option<Value>,
+    pub name: Name<'a>,
+    pub var_type: Type<'a>,
+    pub default_value: Option<Value<'a>>,
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum Selection {
-    Field(Field),
-    FragmentSpread(FragmentSpread),
-    InlineFragment(InlineFragment),
+pub enum Selection<'a> {
+    Field(Field<'a>),
+    FragmentSpread(FragmentSpread<'a>),
+    InlineFragment(InlineFragment<'a>),
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct Field {
+pub struct Field<'a> {
     pub position: Pos,
-    pub alias: Option<Name>,
-    pub name: Name,
-    pub arguments: Vec<(Name, Value)>,
-    pub directives: Vec<Directive>,
-    pub selection_set: SelectionSet,
+    pub alias: Option<Name<'a>>,
+    pub name: Name<'a>,
+    pub arguments: Vec<(Name<'a>, Value<'a>)>,
+    pub directives: Vec<Directive<'a>>,
+    pub selection_set: SelectionSet<'a>,
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct FragmentSpread {
+pub struct FragmentSpread<'a> {
     pub position: Pos,
-    pub fragment_name: Name,
-    pub directives: Vec<Directive>,
+    pub fragment_name: Name<'a>,
+    pub directives: Vec<Directive<'a>>,
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub enum TypeCondition {
-    On(Name),
+pub enum TypeCondition<'a> {
+    On(Name<'a>),
 }
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct InlineFragment {
+pub struct InlineFragment<'a> {
     pub position: Pos,
-    pub type_condition: Option<TypeCondition>,
-    pub directives: Vec<Directive>,
-    pub selection_set: SelectionSet,
+    pub type_condition: Option<TypeCondition<'a>>,
+    pub directives: Vec<Directive<'a>>,
+    pub selection_set: SelectionSet<'a>,
 }