Skip to content

Commit 853c92a

Browse files
mhallinmhallin
committed
Use borrowed string references in all AST nodes
1 parent f066fca commit 853c92a

25 files changed

+121
-127
lines changed

‎src/ast.rs‎

Lines changed: 37 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -55,35 +55,35 @@ pub struct VariableDefinition<'a> {
5555
}
5656

5757
#[derive(Clone, PartialEq, Debug)]
58-
pub struct Arguments {
59-
pub items: Vec<(Spanning<String>, Spanning<InputValue>)>,
58+
pub struct Arguments<'a> {
59+
pub items: Vec<(Spanning<&'a str>, Spanning<InputValue>)>,
6060
}
6161

6262
#[derive(Clone, PartialEq, Debug)]
6363
pub struct VariableDefinitions<'a> {
64-
pub items: Vec<(Spanning<String>, VariableDefinition<'a>)>,
64+
pub items: Vec<(Spanning<&'a str>, VariableDefinition<'a>)>,
6565
}
6666

6767
#[derive(Clone, PartialEq, Debug)]
68-
pub struct Field {
69-
pub alias: Option<Spanning<String>>,
70-
pub name: Spanning<String>,
71-
pub arguments: Option<Spanning<Arguments>>,
72-
pub directives: Option<Vec<Spanning<Directive>>>,
73-
pub selection_set: Option<Vec<Selection>>,
68+
pub struct Field<'a> {
69+
pub alias: Option<Spanning<&'a str>>,
70+
pub name: Spanning<&'a str>,
71+
pub arguments: Option<Spanning<Arguments<'a>>>,
72+
pub directives: Option<Vec<Spanning<Directive<'a>>>>,
73+
pub selection_set: Option<Vec<Selection<'a>>>,
7474
}
7575

7676
#[derive(Clone, PartialEq, Debug)]
77-
pub struct FragmentSpread {
78-
pub name: Spanning<String>,
79-
pub directives: Option<Vec<Spanning<Directive>>>,
77+
pub struct FragmentSpread<'a> {
78+
pub name: Spanning<&'a str>,
79+
pub directives: Option<Vec<Spanning<Directive<'a>>>>,
8080
}
8181

8282
#[derive(Clone, PartialEq, Debug)]
83-
pub struct InlineFragment {
84-
pub type_condition: Option<Spanning<String>>,
85-
pub directives: Option<Vec<Spanning<Directive>>>,
86-
pub selection_set: Vec<Selection>,
83+
pub struct InlineFragment<'a> {
84+
pub type_condition: Option<Spanning<&'a str>>,
85+
pub directives: Option<Vec<Spanning<Directive<'a>>>>,
86+
pub selection_set: Vec<Selection<'a>>,
8787
}
8888

8989
/// Entry in a GraphQL selection set
@@ -103,16 +103,16 @@ pub struct InlineFragment {
103103
/// ```
104104
#[derive(Clone, PartialEq, Debug)]
105105
#[allow(missing_docs)]
106-
pub enum Selection {
107-
Field(Spanning<Field>),
108-
FragmentSpread(Spanning<FragmentSpread>),
109-
InlineFragment(Spanning<InlineFragment>),
106+
pub enum Selection<'a> {
107+
Field(Spanning<Field<'a>>),
108+
FragmentSpread(Spanning<FragmentSpread<'a>>),
109+
InlineFragment(Spanning<InlineFragment<'a>>),
110110
}
111111

112112
#[derive(Clone, PartialEq, Debug)]
113-
pub struct Directive {
114-
pub name: Spanning<String>,
115-
pub arguments: Option<Spanning<Arguments>>,
113+
pub struct Directive<'a> {
114+
pub name: Spanning<&'a str>,
115+
pub arguments: Option<Spanning<Arguments<'a>>>,
116116
}
117117

118118
#[derive(Clone, PartialEq, Debug)]
@@ -124,24 +124,24 @@ pub enum OperationType {
124124
#[derive(Clone, PartialEq, Debug)]
125125
pub struct Operation<'a> {
126126
pub operation_type: OperationType,
127-
pub name: Option<Spanning<String>>,
127+
pub name: Option<Spanning<&'a str>>,
128128
pub variable_definitions: Option<Spanning<VariableDefinitions<'a>>>,
129-
pub directives: Option<Vec<Spanning<Directive>>>,
130-
pub selection_set: Vec<Selection>,
129+
pub directives: Option<Vec<Spanning<Directive<'a>>>>,
130+
pub selection_set: Vec<Selection<'a>>,
131131
}
132132

133133
#[derive(Clone, PartialEq, Debug)]
134-
pub struct Fragment {
135-
pub name: Spanning<String>,
136-
pub type_condition: Spanning<String>,
137-
pub directives: Option<Vec<Spanning<Directive>>>,
138-
pub selection_set: Vec<Selection>,
134+
pub struct Fragment<'a> {
135+
pub name: Spanning<&'a str>,
136+
pub type_condition: Spanning<&'a str>,
137+
pub directives: Option<Vec<Spanning<Directive<'a>>>>,
138+
pub selection_set: Vec<Selection<'a>>,
139139
}
140140

141141
#[derive(Clone, PartialEq, Debug)]
142142
pub enum Definition<'a> {
143143
Operation(Spanning<Operation<'a>>),
144-
Fragment(Spanning<Fragment>),
144+
Fragment(Spanning<Fragment<'a>>),
145145
}
146146

147147
pub type Document<'a> = Vec<Definition<'a>>;
@@ -417,23 +417,19 @@ impl ToJson for InputValue {
417417
}
418418
}
419419

420-
impl Arguments {
421-
pub fn into_iter(self) -> vec::IntoIter<(Spanning<String>, Spanning<InputValue>)> {
420+
impl<'a> Arguments<'a> {
421+
pub fn into_iter(self) -> vec::IntoIter<(Spanning<&'a str>, Spanning<InputValue>)> {
422422
self.items.into_iter()
423423
}
424424

425-
pub fn iter(&self) -> slice::Iter<(Spanning<String>, Spanning<InputValue>)> {
425+
pub fn iter(&self) -> slice::Iter<(Spanning<&'a str>, Spanning<InputValue>)> {
426426
self.items.iter()
427427
}
428428

429-
pub fn iter_mut(&mut self) -> slice::IterMut<(Spanning<String>, Spanning<InputValue>)> {
429+
pub fn iter_mut(&mut self) -> slice::IterMut<(Spanning<&'a str>, Spanning<InputValue>)> {
430430
self.items.iter_mut()
431431
}
432432

433-
pub fn drain<'a>(&'a mut self) -> vec::Drain<'a, (Spanning<String>, Spanning<InputValue>)> {
434-
self.items.drain(..)
435-
}
436-
437433
pub fn len(&self) -> usize {
438434
self.items.len()
439435
}
@@ -448,7 +444,7 @@ impl Arguments {
448444
}
449445

450446
impl<'a> VariableDefinitions<'a> {
451-
pub fn iter(&self) -> slice::Iter<(Spanning<String>, VariableDefinition)> {
447+
pub fn iter(&self) -> slice::Iter<(Spanning<&'a str>, VariableDefinition)> {
452448
self.items.iter()
453449
}
454450
}

‎src/executor.rs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -35,9 +35,9 @@ pub enum FieldPath<'a> {
3535
/// The executor helps drive the query execution in a schema. It keeps track
3636
/// of the current field stack, context, variables, and errors.
3737
pub struct Executor<'a, CtxT> where CtxT: 'a {
38-
fragments: &'a HashMap<&'a str, &'a Fragment>,
38+
fragments: &'a HashMap<&'a str, &'a Fragment<'a>>,
3939
variables: &'a HashMap<String, InputValue>,
40-
current_selection_set: Option<&'a [Selection]>,
40+
current_selection_set: Option<&'a [Selection<'a>]>,
4141
schema: &'a SchemaType<'a>,
4242
context: &'a CtxT,
4343
errors: &'a RwLock<Vec<ExecutionError>>,
@@ -332,7 +332,7 @@ pub fn execute_validated_query<'a, QueryT, MutationT, CtxT>(
332332

333333
{
334334
let executor = Executor {
335-
fragments: &fragments.iter().map(|f| (f.item.name.item.as_str(), &f.item)).collect(),
335+
fragments: &fragments.iter().map(|f| (f.item.name.item, &f.item)).collect(),
336336
variables: variables,
337337
current_selection_set: Some(&op.item.selection_set[..]),
338338
schema: &root_node.schema,

‎src/parser/document.rs‎

Lines changed: 22 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -54,7 +54,7 @@ fn parse_operation_definition<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, Op
5454
let start_pos = parser.peek().start.clone();
5555
let operation_type = try!(parse_operation_type(parser));
5656
let name = match parser.peek().item {
57-
Token::Name(_) => Some(try!(parser.expect_name()).map(|s| s.to_owned())),
57+
Token::Name(_) => Some(try!(parser.expect_name())),
5858
_ => None
5959
};
6060
let variable_definitions = try!(parse_variable_definitions(parser));
@@ -74,7 +74,7 @@ fn parse_operation_definition<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, Op
7474
}
7575
}
7676

77-
fn parse_fragment_definition<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, Fragment> {
77+
fn parse_fragment_definition<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, Fragment<'a>> {
7878
let Spanning { start: start_pos, .. } = try!(parser.expect(&Token::Name("fragment")));
7979
let name = match parser.expect_name() {
8080
Ok(n) => if n.item == "on" {
@@ -95,14 +95,14 @@ fn parse_fragment_definition<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, Fra
9595
&start_pos,
9696
&selection_set.end,
9797
Fragment {
98-
name: name.map(|s| s.to_owned()),
99-
type_condition: type_cond.map(|s| s.to_owned()),
98+
name: name,
99+
type_condition: type_cond,
100100
directives: directives.map(|s| s.item),
101101
selection_set: selection_set.item,
102102
}))
103103
}
104104

105-
fn parse_optional_selection_set<'a>(parser: &mut Parser<'a>) -> OptionParseResult<'a, Vec<Selection>> {
105+
fn parse_optional_selection_set<'a>(parser: &mut Parser<'a>) -> OptionParseResult<'a, Vec<Selection<'a>>> {
106106
if parser.peek().item == Token::CurlyOpen {
107107
Ok(Some(try!(parse_selection_set(parser))))
108108
}
@@ -111,21 +111,21 @@ fn parse_optional_selection_set<'a>(parser: &mut Parser<'a>) -> OptionParseResul
111111
}
112112
}
113113

114-
fn parse_selection_set<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, Vec<Selection>> {
114+
fn parse_selection_set<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, Vec<Selection<'a>>> {
115115
parser.unlocated_delimited_nonempty_list(
116116
&Token::CurlyOpen,
117117
parse_selection,
118118
&Token::CurlyClose)
119119
}
120120

121-
fn parse_selection<'a>(parser: &mut Parser<'a>) -> UnlocatedParseResult<'a, Selection> {
121+
fn parse_selection<'a>(parser: &mut Parser<'a>) -> UnlocatedParseResult<'a, Selection<'a>> {
122122
match parser.peek().item {
123123
Token::Ellipsis => parse_fragment(parser),
124124
_ => parse_field(parser).map(Selection::Field),
125125
}
126126
}
127127

128-
fn parse_fragment<'a>(parser: &mut Parser<'a>) -> UnlocatedParseResult<'a, Selection> {
128+
fn parse_fragment<'a>(parser: &mut Parser<'a>) -> UnlocatedParseResult<'a, Selection<'a>> {
129129
let Spanning { start: ref start_pos, .. } = try!(parser.expect(&Token::Ellipsis));
130130

131131
match parser.peek().item {
@@ -140,7 +140,7 @@ fn parse_fragment<'a>(parser: &mut Parser<'a>) -> UnlocatedParseResult<'a, Selec
140140
&start_pos.clone(),
141141
&selection_set.end,
142142
InlineFragment {
143-
type_condition: Some(name.map(|s| s.to_owned())),
143+
type_condition: Some(name),
144144
directives: directives.map(|s| s.item),
145145
selection_set: selection_set.item,
146146
})))
@@ -167,7 +167,7 @@ fn parse_fragment<'a>(parser: &mut Parser<'a>) -> UnlocatedParseResult<'a, Selec
167167
&start_pos.clone(),
168168
&directives.as_ref().map_or(&frag_name.end, |s| &s.end).clone(),
169169
FragmentSpread {
170-
name: frag_name.map(|s| s.to_owned()),
170+
name: frag_name,
171171
directives: directives.map(|s| s.item),
172172
})))
173173
},
@@ -189,11 +189,11 @@ fn parse_fragment<'a>(parser: &mut Parser<'a>) -> UnlocatedParseResult<'a, Selec
189189
}
190190
}
191191

192-
fn parse_field<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, Field> {
193-
let mut alias = Some(try!(parser.expect_name()).map(|s| s.to_owned()));
192+
fn parse_field<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, Field<'a>> {
193+
let mut alias = Some(try!(parser.expect_name()));
194194

195195
let name = if try!(parser.skip(&Token::Colon)).is_some() {
196-
try!(parser.expect_name()).map(|s| s.to_owned())
196+
try!(parser.expect_name())
197197
}
198198
else {
199199
alias.take().unwrap()
@@ -212,14 +212,14 @@ fn parse_field<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, Field> {
212212
.clone(),
213213
Field {
214214
alias: alias,
215-
name: name.map(|s| s.to_owned()),
215+
name: name,
216216
arguments: arguments,
217217
directives: directives.map(|s| s.item),
218218
selection_set: selection_set.map(|s| s.item),
219219
}))
220220
}
221221

222-
fn parse_arguments<'a>(parser: &mut Parser<'a>) -> OptionParseResult<'a, Arguments> {
222+
fn parse_arguments<'a>(parser: &mut Parser<'a>) -> OptionParseResult<'a, Arguments<'a>> {
223223
if parser.peek().item != Token::ParenOpen {
224224
Ok(None)
225225
} else {
@@ -231,15 +231,15 @@ fn parse_arguments<'a>(parser: &mut Parser<'a>) -> OptionParseResult<'a, Argumen
231231
}
232232
}
233233

234-
fn parse_argument<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, (Spanning<String>, Spanning<InputValue>)> {
234+
fn parse_argument<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, (Spanning<&'a str>, Spanning<InputValue>)> {
235235
let name = try!(parser.expect_name());
236236
try!(parser.expect(&Token::Colon));
237237
let value = try!(parse_value_literal(parser, false));
238238

239239
Ok(Spanning::start_end(
240240
&name.start.clone(),
241241
&value.end.clone(),
242-
(name.map(|s| s.to_owned()), value)))
242+
(name, value)))
243243
}
244244

245245
fn parse_operation_type<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, OperationType> {
@@ -263,7 +263,7 @@ fn parse_variable_definitions<'a>(parser: &mut Parser<'a>) -> OptionParseResult<
263263
}
264264
}
265265

266-
fn parse_variable_definition<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, (Spanning<String>, VariableDefinition<'a>)> {
266+
fn parse_variable_definition<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, (Spanning<&'a str>, VariableDefinition<'a>)> {
267267
let Spanning { start: start_pos, .. } = try!(parser.expect(&Token::Dollar));
268268
let var_name = try!(parser.expect_name());
269269
try!(parser.expect(&Token::Colon));
@@ -283,7 +283,7 @@ fn parse_variable_definition<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, (Sp
283283
Spanning::start_end(
284284
&start_pos,
285285
&var_name.end,
286-
var_name.item.to_owned(),
286+
var_name.item,
287287
),
288288
VariableDefinition {
289289
var_type: var_type,
@@ -292,7 +292,7 @@ fn parse_variable_definition<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, (Sp
292292
)))
293293
}
294294

295-
fn parse_directives<'a>(parser: &mut Parser<'a>) -> OptionParseResult<'a, Vec<Spanning<Directive>>> {
295+
fn parse_directives<'a>(parser: &mut Parser<'a>) -> OptionParseResult<'a, Vec<Spanning<Directive<'a>>>> {
296296
if parser.peek().item != Token::At {
297297
Ok(None)
298298
}
@@ -306,7 +306,7 @@ fn parse_directives<'a>(parser: &mut Parser<'a>) -> OptionParseResult<'a, Vec<Sp
306306
}
307307
}
308308

309-
fn parse_directive<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, Directive> {
309+
fn parse_directive<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, Directive<'a>> {
310310
let Spanning { start: start_pos, .. } = try!(parser.expect(&Token::At));
311311
let name = try!(parser.expect_name());
312312
let arguments = try!(parse_arguments(parser));
@@ -315,7 +315,7 @@ fn parse_directive<'a>(parser: &mut Parser<'a>) -> ParseResult<'a, Directive> {
315315
&start_pos,
316316
&arguments.as_ref().map_or(&name.end, |s| &s.end).clone(),
317317
Directive {
318-
name: name.map(|s| s.to_owned()),
318+
name: name,
319319
arguments: arguments,
320320
}))
321321
}

‎src/parser/tests/document.rs‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -44,7 +44,7 @@ fn simple_ast() {
4444
name: Spanning::start_end(
4545
&SourcePosition::new(31, 2, 16),
4646
&SourcePosition::new(35, 2, 20),
47-
"node".to_owned()),
47+
"node"),
4848
arguments: Some(Spanning::start_end(
4949
&SourcePosition::new(35, 2, 20),
5050
&SourcePosition::new(42, 2, 27),
@@ -54,7 +54,7 @@ fn simple_ast() {
5454
Spanning::start_end(
5555
&SourcePosition::new(36, 2, 21),
5656
&SourcePosition::new(38, 2, 23),
57-
"id".to_owned()),
57+
"id"),
5858
Spanning::start_end(
5959
&SourcePosition::new(40, 2, 25),
6060
&SourcePosition::new(41, 2, 26),
@@ -73,7 +73,7 @@ fn simple_ast() {
7373
name: Spanning::start_end(
7474
&SourcePosition::new(65, 3, 20),
7575
&SourcePosition::new(67, 3, 22),
76-
"id".to_owned()),
76+
"id"),
7777
arguments: None,
7878
directives: None,
7979
selection_set: None,
@@ -87,7 +87,7 @@ fn simple_ast() {
8787
name: Spanning::start_end(
8888
&SourcePosition::new(88, 4, 20),
8989
&SourcePosition::new(92, 4, 24),
90-
"name".to_owned()),
90+
"name"),
9191
arguments: None,
9292
directives: None,
9393
selection_set: None,

0 commit comments

Comments
 (0)