bluejay-parser: performance optimizations

bluejay-parser/benches/parse.rs

@@ -1,5 +1,6 @@
 use bluejay_parser::ast::{
     definition::{DefaultContext, DefinitionDocument},
+    executable::ExecutableDocument,
     Parse,
 };
 use criterion::{criterion_group, criterion_main, Criterion};
@@ -13,7 +14,12 @@ fn parse(c: &mut Criterion) {
 
     let s = std::fs::read_to_string("../data/kitchen_sink.graphql").unwrap();
     c.bench_function("parse kitchen sink executable document", |b| {
-        b.iter(|| DefinitionDocument::<DefaultContext>::parse(black_box(s.as_str())))
+        b.iter(|| ExecutableDocument::parse(black_box(s.as_str())))
+    });
+
+    let s = std::fs::read_to_string("../data/large_executable.graphql").unwrap();
+    c.bench_function("parse large executable document", |b| {
+        b.iter(|| ExecutableDocument::parse(black_box(s.as_str())))
     });
 }
 

bluejay-parser/src/ast/definition/custom_scalar_type_definition.rs

@@ -53,8 +53,7 @@ impl<'a, C: Context> FromTokens<'a> for CustomScalarTypeDefinition<'a, C> {
         let description = tokens.next_if_string_value();
         let scalar_identifier_span = tokens.expect_name_value(Self::SCALAR_IDENTIFIER)?;
         let name = tokens.expect_name()?;
-        let directives =
-            ConstDirectives::try_from_tokens(tokens, depth_limiter.bump()?).transpose()?;
+        let directives = ConstDirectives::try_from_tokens(tokens, depth_limiter.bump()?)?;
         Ok(Self {
             description,
             _scalar_identifier_span: scalar_identifier_span,

bluejay-parser/src/ast/definition/definition_document.rs

@@ -158,19 +158,21 @@ impl<'a, C: Context> Parse<'a> for DefinitionDocument<'a, C> {
 
 impl<'a, C: Context> DefinitionDocument<'a, C> {
     fn new() -> Self {
+        let mut type_definitions = Vec::with_capacity(64);
+        type_definitions.extend([
+            ObjectTypeDefinition::__schema().into(),
+            ObjectTypeDefinition::__type().into(),
+            ObjectTypeDefinition::__field().into(),
+            ObjectTypeDefinition::__input_value().into(),
+            ObjectTypeDefinition::__enum_value().into(),
+            ObjectTypeDefinition::__directive().into(),
+            EnumTypeDefinition::__type_kind().into(),
+            EnumTypeDefinition::__directive_location().into(),
+        ]);
         Self {
             schema_definitions: Vec::new(),
-            directive_definitions: Vec::new(),
-            type_definitions: vec![
-                ObjectTypeDefinition::__schema().into(),
-                ObjectTypeDefinition::__type().into(),
-                ObjectTypeDefinition::__field().into(),
-                ObjectTypeDefinition::__input_value().into(),
-                ObjectTypeDefinition::__enum_value().into(),
-                ObjectTypeDefinition::__directive().into(),
-                EnumTypeDefinition::__type_kind().into(),
-                EnumTypeDefinition::__directive_location().into(),
-            ],
+            directive_definitions: Vec::with_capacity(8),
+            type_definitions,
         }
     }
 

bluejay-parser/src/ast/definition/definition_document/definition_document_error.rs

@@ -84,7 +84,7 @@ impl<C: Context> From<DefinitionDocumentError<'_, C>> for Error {
                         .map(|definition| {
                             Annotation::new(
                                 format!("Directive definition with name `@{name}`"),
-                                definition.name_token().span().clone(),
+                                *definition.name_token().span(),
                             )
                         })
                         .collect(),
@@ -101,7 +101,7 @@ impl<C: Context> From<DefinitionDocumentError<'_, C>> for Error {
                     .map(|rotd| {
                         Annotation::new(
                             format!("Root operation type definition for `{operation_type}`"),
-                            rotd.name_token().span().clone(),
+                            *rotd.name_token().span(),
                         )
                     })
                     .collect(),
@@ -115,7 +115,7 @@ impl<C: Context> From<DefinitionDocumentError<'_, C>> for Error {
                         .map(|definition| {
                             Annotation::new(
                                 "Schema definition",
-                                definition.schema_identifier_span().clone(),
+                                *definition.schema_identifier_span(),
                             )
                         })
                         .collect(),
@@ -140,7 +140,7 @@ impl<C: Context> From<DefinitionDocumentError<'_, C>> for Error {
                         .map(|definition| {
                             Annotation::new(
                                 format!("Type definition with name `{name}`"),
-                                definition.name_token().unwrap().span().clone(),
+                                *definition.name_token().unwrap().span(),
                             )
                         })
                         .collect(),
@@ -155,7 +155,7 @@ impl<C: Context> From<DefinitionDocumentError<'_, C>> for Error {
                 ),
                 Some(Annotation::new(
                     "No definition for referenced type",
-                    root_operation_type_definition.name_token().span().clone(),
+                    *root_operation_type_definition.name_token().span(),
                 )),
                 Vec::new(),
             ),
@@ -164,7 +164,7 @@ impl<C: Context> From<DefinitionDocumentError<'_, C>> for Error {
                     "Schema definition does not contain a query",
                     Some(Annotation::new(
                         "Does not contain a query",
-                        definition.root_operation_type_definitions_span().clone(),
+                        *definition.root_operation_type_definitions_span(),
                     )),
                     Vec::new(),
                 )
@@ -181,28 +181,28 @@ impl<C: Context> From<DefinitionDocumentError<'_, C>> for Error {
                 format!("Referenced type `{}` does not exist", name.as_ref()),
                 Some(Annotation::new(
                     "No definition for referenced type",
-                    name.span().clone(),
+                    *name.span(),
                 )),
                 Vec::new(),
             ),
             DefinitionDocumentError::ReferencedTypeIsNotAnInputType { name } => Error::new(
                 format!("Referenced type `{}` is not an input type", name.as_ref()),
-                Some(Annotation::new("Not an input type", name.span().clone())),
+                Some(Annotation::new("Not an input type", *name.span())),
                 Vec::new(),
             ),
             DefinitionDocumentError::ReferencedTypeIsNotAnInterface { name } => Error::new(
                 format!("Referenced type `{}` is not an interface", name.as_ref()),
-                Some(Annotation::new("Not an interface", name.span().clone())),
+                Some(Annotation::new("Not an interface", *name.span())),
                 Vec::new(),
             ),
             DefinitionDocumentError::ReferencedTypeIsNotAnOutputType { name } => Error::new(
                 format!("Referenced type `{}` is not an output type", name.as_ref()),
-                Some(Annotation::new("Not an output type", name.span().clone())),
+                Some(Annotation::new("Not an output type", *name.span())),
                 Vec::new(),
             ),
             DefinitionDocumentError::ReferencedUnionMemberTypeIsNotAnObject { name } => Error::new(
                 format!("Referenced type `{}` is not an object", name.as_ref()),
-                Some(Annotation::new("Not an object type", name.span().clone())),
+                Some(Annotation::new("Not an object type", *name.span())),
                 Vec::new(),
             ),
             DefinitionDocumentError::ImplicitRootOperationTypeNotAnObject { definition } => {
@@ -214,14 +214,14 @@ impl<C: Context> From<DefinitionDocumentError<'_, C>> for Error {
                     Some(Annotation::new(
                         "Not an object type",
                         // ok to unwrap because builtin scalar cannot be an implicit schema definition member
-                        definition.name_token().unwrap().span().clone(),
+                        *definition.name_token().unwrap().span(),
                     )),
                     Vec::new(),
                 )
             }
             DefinitionDocumentError::ExplicitRootOperationTypeNotAnObject { name } => Error::new(
                 format!("Referenced type `{}` is not an object", name.as_ref()),
-                Some(Annotation::new("Not an object type", name.span().clone())),
+                Some(Annotation::new("Not an object type", *name.span())),
                 Vec::new(),
             ),
             DefinitionDocumentError::ReferencedDirectiveDoesNotExist { directive } => Error::new(
@@ -231,7 +231,7 @@ impl<C: Context> From<DefinitionDocumentError<'_, C>> for Error {
                 ),
                 Some(Annotation::new(
                     "No definition for referenced directive",
-                    directive.span().clone(),
+                    *directive.span(),
                 )),
                 Vec::new(),
             ),

bluejay-parser/src/ast/definition/directive_definition.rs

@@ -113,7 +113,7 @@ impl<'a, C: Context> FromTokens<'a> for DirectiveDefinition<'a, C> {
         tokens.expect_punctuator(PunctuatorType::At)?;
         let name = tokens.expect_name()?;
         let arguments_definition =
-            ArgumentsDefinition::try_from_tokens(tokens, depth_limiter.bump()?).transpose()?;
+            ArgumentsDefinition::try_from_tokens(tokens, depth_limiter.bump()?)?;
         let is_repeatable = tokens
             .next_if_name_matches(Self::REPEATABLE_IDENTIFIER)
             .is_some();

bluejay-parser/src/ast/definition/enum_type_definition.rs

@@ -95,8 +95,7 @@ impl<'a, C: Context> FromTokens<'a> for EnumTypeDefinition<'a, C> {
         let description = tokens.next_if_string_value();
         tokens.expect_name_value(Self::ENUM_IDENTIFIER)?;
         let name = tokens.expect_name()?;
-        let directives =
-            ConstDirectives::try_from_tokens(tokens, depth_limiter.bump()?).transpose()?;
+        let directives = ConstDirectives::try_from_tokens(tokens, depth_limiter.bump()?)?;
         let enum_value_definitions =
             EnumValueDefinitions::from_tokens(tokens, depth_limiter.bump()?)?;
         Ok(Self {

bluejay-parser/src/ast/definition/enum_value_definition.rs

@@ -41,13 +41,12 @@ impl<'a, C: Context> FromTokens<'a> for EnumValueDefinition<'a, C> {
         let name = tokens.expect_name()?;
         if matches!(name.as_str(), "null" | "true" | "false") {
             return Err(ParseError::InvalidEnumValue {
-                span: name.span().clone(),
+                span: *name.span(),
                 value: name.as_str().to_string(),
             });
         }
 
-        let directives =
-            ConstDirectives::try_from_tokens(tokens, depth_limiter.bump()?).transpose()?;
+        let directives = ConstDirectives::try_from_tokens(tokens, depth_limiter.bump()?)?;
         Ok(Self {
             description,
             name,

bluejay-parser/src/ast/definition/explicit_schema_definition.rs

@@ -49,8 +49,7 @@ impl<'a, C: Context> FromTokens<'a> for ExplicitSchemaDefinition<'a, C> {
 
         let schema_identifier_span = tokens.expect_name_value(Self::SCHEMA_IDENTIFIER)?;
 
-        let directives =
-            ConstDirectives::try_from_tokens(tokens, depth_limiter.bump()?).transpose()?;
+        let directives = ConstDirectives::try_from_tokens(tokens, depth_limiter.bump()?)?;
 
         let mut root_operation_type_definitions = Vec::new();
 

bluejay-parser/src/ast/definition/field_definition.rs

@@ -72,11 +72,10 @@ impl<'a, C: Context> FromTokens<'a> for FieldDefinition<'a, C> {
         let description = tokens.next_if_string_value();
         let name = tokens.expect_name()?;
         let arguments_definition =
-            ArgumentsDefinition::try_from_tokens(tokens, depth_limiter.bump()?).transpose()?;
+            ArgumentsDefinition::try_from_tokens(tokens, depth_limiter.bump()?)?;
         tokens.expect_punctuator(PunctuatorType::Colon)?;
         let r#type = OutputType::from_tokens(tokens, depth_limiter.bump()?)?;
-        let directives =
-            ConstDirectives::try_from_tokens(tokens, depth_limiter.bump()?).transpose()?;
+        let directives = ConstDirectives::try_from_tokens(tokens, depth_limiter.bump()?)?;
         Ok(Self {
             description,
             name,

bluejay-parser/src/ast/definition/input_object_type_definition.rs

@@ -45,8 +45,7 @@ impl<'a, C: Context> FromTokens<'a> for InputObjectTypeDefinition<'a, C> {
         let description = tokens.next_if_string_value();
         tokens.expect_name_value(Self::INPUT_IDENTIFIER)?;
         let name = tokens.expect_name()?;
-        let directives =
-            ConstDirectives::try_from_tokens(tokens, depth_limiter.bump()?).transpose()?;
+        let directives = ConstDirectives::try_from_tokens(tokens, depth_limiter.bump()?)?;
         let input_fields_definition =
             InputFieldsDefinition::from_tokens(tokens, depth_limiter.bump()?)?;
         Ok(Self {

bluejay-parser/src/ast/definition/input_type.rs

@@ -110,7 +110,7 @@ impl<'a, C: Context + 'a> FromTokens<'a> for InputType<'a, C> {
             let span = if let Some(bang_span) = &bang_span {
                 base_name.span().merge(bang_span)
             } else {
-                base_name.span().clone()
+                *base_name.span()
             };
             let base = BaseInputType {
                 name: base_name,

bluejay-parser/src/ast/definition/interface_type_definition.rs

@@ -52,9 +52,8 @@ impl<'a, C: Context> FromTokens<'a> for InterfaceTypeDefinition<'a, C> {
         tokens.expect_name_value(Self::INTERFACE_IDENTIFIER)?;
         let name = tokens.expect_name()?;
         let interface_implementations =
-            InterfaceImplementations::try_from_tokens(tokens, depth_limiter.bump()?).transpose()?;
-        let directives =
-            ConstDirectives::try_from_tokens(tokens, depth_limiter.bump()?).transpose()?;
+            InterfaceImplementations::try_from_tokens(tokens, depth_limiter.bump()?)?;
+        let directives = ConstDirectives::try_from_tokens(tokens, depth_limiter.bump()?)?;
         let fields_definition = FieldsDefinition::from_tokens(tokens, depth_limiter.bump()?)?;
         Ok(Self {
             description,

bluejay-parser/src/ast/definition/object_type_definition.rs

@@ -145,9 +145,8 @@ impl<'a, C: Context> FromTokens<'a> for ObjectTypeDefinition<'a, C> {
         tokens.expect_name_value(Self::TYPE_IDENTIFIER)?;
         let name = tokens.expect_name()?;
         let interface_implementations =
-            InterfaceImplementations::try_from_tokens(tokens, depth_limiter.bump()?).transpose()?;
-        let directives =
-            ConstDirectives::try_from_tokens(tokens, depth_limiter.bump()?).transpose()?;
+            InterfaceImplementations::try_from_tokens(tokens, depth_limiter.bump()?)?;
+        let directives = ConstDirectives::try_from_tokens(tokens, depth_limiter.bump()?)?;
         let fields_definition = FieldsDefinition::from_tokens(tokens, depth_limiter.bump()?)?;
         Ok(Self {
             description,

bluejay-parser/src/ast/definition/output_type.rs

@@ -122,7 +122,7 @@ impl<'a, C: Context + 'a> FromTokens<'a> for OutputType<'a, C> {
             let span = if let Some(bang_span) = &bang_span {
                 base_name.span().merge(bang_span)
             } else {
-                base_name.span().clone()
+                *base_name.span()
             };
             let base = BaseOutputType::new(base_name);
             Ok(Self::Base(base, bang_span.is_some(), span))

bluejay-parser/src/ast/definition/union_type_definition.rs

@@ -49,8 +49,7 @@ impl<'a, C: Context> FromTokens<'a> for UnionTypeDefinition<'a, C> {
         let description = tokens.next_if_string_value();
         tokens.expect_name_value(Self::UNION_IDENTIFIER)?;
         let name = tokens.expect_name()?;
-        let directives =
-            ConstDirectives::try_from_tokens(tokens, depth_limiter.bump()?).transpose()?;
+        let directives = ConstDirectives::try_from_tokens(tokens, depth_limiter.bump()?)?;
         tokens.expect_punctuator(PunctuatorType::Equals)?;
         let member_types = UnionMemberTypes::from_tokens(tokens, depth_limiter.bump()?)?;
         Ok(Self {

bluejay-parser/src/ast/depth_limiter.rs

@@ -26,6 +26,7 @@ impl DepthLimiter {
         }
     }
 
+    #[inline]
     pub fn bump(&self) -> Result<Self, ParseError> {
         if self.current_depth >= self.max_depth {
             Err(ParseError::MaxDepthExceeded)

bluejay-parser/src/ast/directive.rs

@@ -27,7 +27,7 @@ impl<'a, const CONST: bool> FromTokens<'a> for Directive<'a, CONST> {
     ) -> Result<Self, ParseError> {
         let at_span = tokens.expect_punctuator(PunctuatorType::At)?;
         let name = tokens.expect_name()?;
-        let arguments = Arguments::try_from_tokens(tokens, depth_limiter.bump()?).transpose()?;
+        let arguments = Arguments::try_from_tokens(tokens, depth_limiter.bump()?)?;
         let span = match &arguments {
             Some(arguments) => at_span.merge(arguments.span()),
             None => at_span.merge(name.span()),

bluejay-parser/src/ast/directives.rs

@@ -20,12 +20,12 @@ impl<'a, const CONST: bool> FromTokens<'a> for Directives<'a, CONST> {
         depth_limiter: DepthLimiter,
     ) -> Result<Self, ParseError> {
         let mut directives: Vec<Directive<'a, CONST>> = Vec::new();
-        while let Some(directive) = Directive::try_from_tokens(tokens, depth_limiter.bump()?) {
-            directives.push(directive?);
+        while let Some(directive) = Directive::try_from_tokens(tokens, depth_limiter.bump()?)? {
+            directives.push(directive);
         }
         let span = match directives.as_slice() {
             [] => None,
-            [first] => Some(first.span().clone()),
+            [first] => Some(*first.span()),
             [first, .., last] => Some(first.span().merge(last.span())),
         };
         Ok(Self { directives, span })