Improve TypeInfoQueryVisitor and support empty ref

added  FieldsOnCorrectType rule

Author: dotansimha

src/ast/ext.rs

@@ -1,7 +1,7 @@
 use crate::static_graphql::query::{self};
 use crate::static_graphql::schema::{self, Field, InterfaceType, ObjectType, UnionType};
 
-use super::get_named_type;
+use super::{get_named_type, TypeInfoElementRef};
 
 pub trait AstNodeWithFields {
     fn find_field(&self, name: String) -> Option<&Field>;
@@ -42,6 +42,15 @@ pub enum CompositeType {
     Union(schema::UnionType),
 }
 
+impl TypeInfoElementRef<CompositeType> {
+    pub fn find_field(&self, name: String) -> Option<&Field> {
+        match self {
+            TypeInfoElementRef::Empty => None,
+            TypeInfoElementRef::Ref(composite_type) => composite_type.find_field(name),
+        }
+    }
+}
+
 impl CompositeType {
     pub fn find_field(&self, name: String) -> Option<&Field> {
         match self {
@@ -68,6 +77,28 @@ pub trait TypeDefinitionExtension {
     fn name(&self) -> String;
 }
 
+impl TypeDefinitionExtension for CompositeType {
+    fn is_leaf_type(&self) -> bool {
+        false
+    }
+
+    fn is_composite_type(&self) -> bool {
+        true
+    }
+
+    fn is_input_type(&self) -> bool {
+        false
+    }
+
+    fn name(&self) -> String {
+        match self {
+            CompositeType::Object(o) => o.name.clone(),
+            CompositeType::Interface(i) => i.name.clone(),
+            CompositeType::Union(u) => u.name.clone(),
+        }
+    }
+}
+
 impl TypeDefinitionExtension for schema::TypeDefinition {
     fn name(&self) -> String {
         match self {

src/ast/type_info.rs

@@ -86,12 +86,19 @@ impl<'a> TypeInfoRegistry<'a> {
     }
 }
 
+/// This struct is used to mark a "node" or nothing (null, undefined). While tracking TypeInfo, we need to check if there was a node before or not.
+#[derive(Debug, Clone, Copy)]
+pub enum TypeInfoElementRef<T> {
+    Empty,
+    Ref(T),
+}
+
 pub struct TypeInfo {
-    pub type_stack: Vec<schema::Type>,
-    pub parent_type_stack: Vec<CompositeType>,
-    pub field_def_stack: Vec<schema::Field>,
-    pub input_type_stack: Vec<schema::InputObjectType>,
-    pub argument: Option<schema::InputValue>,
+    pub type_stack: Vec<TypeInfoElementRef<schema::Type>>,
+    pub parent_type_stack: Vec<TypeInfoElementRef<CompositeType>>,
+    pub field_def_stack: Vec<TypeInfoElementRef<schema::Field>>,
+    pub input_type_stack: Vec<TypeInfoElementRef<schema::InputObjectType>>,
+    pub argument: Option<TypeInfoElementRef<schema::InputValue>>,
 }
 
 impl TypeInfo {
@@ -105,59 +112,59 @@ impl TypeInfo {
         };
     }
 
-    pub fn get_argument(&self) -> Option<schema::InputValue> {
+    pub fn get_argument(&self) -> Option<TypeInfoElementRef<schema::InputValue>> {
         self.argument.clone()
     }
 
-    pub fn enter_argument(&mut self, input_value: schema::InputValue) {
+    pub fn enter_argument(&mut self, input_value: TypeInfoElementRef<schema::InputValue>) {
         self.argument = Some(input_value);
     }
 
     pub fn leave_argument(&mut self) {
         self.argument = None;
     }
 
-    pub fn get_type(&self) -> Option<schema::Type> {
+    pub fn get_type(&self) -> Option<TypeInfoElementRef<schema::Type>> {
         self.type_stack.last().cloned()
     }
 
-    pub fn enter_type(&mut self, object: schema::Type) {
+    pub fn enter_type(&mut self, object: TypeInfoElementRef<schema::Type>) {
         self.type_stack.push(object);
     }
 
     pub fn leave_type(&mut self) {
         self.type_stack.pop();
     }
 
-    pub fn get_input_type(&self) -> Option<schema::InputObjectType> {
+    pub fn get_input_type(&self) -> Option<TypeInfoElementRef<schema::InputObjectType>> {
         self.input_type_stack.last().cloned()
     }
 
-    pub fn enter_input_type(&mut self, object: schema::InputObjectType) {
+    pub fn enter_input_type(&mut self, object: TypeInfoElementRef<schema::InputObjectType>) {
         self.input_type_stack.push(object);
     }
 
     pub fn leave_input_type(&mut self) {
         self.input_type_stack.pop();
     }
 
-    pub fn get_parent_type(&self) -> Option<CompositeType> {
+    pub fn get_parent_type(&self) -> Option<TypeInfoElementRef<CompositeType>> {
         self.parent_type_stack.last().cloned()
     }
 
-    pub fn enter_parent_type(&mut self, object: CompositeType) {
+    pub fn enter_parent_type(&mut self, object: TypeInfoElementRef<CompositeType>) {
         self.parent_type_stack.push(object);
     }
 
     pub fn leave_parent_type(&mut self) {
         self.parent_type_stack.pop();
     }
 
-    pub fn get_field_def(&self) -> Option<schema::Field> {
+    pub fn get_field_def(&self) -> Option<TypeInfoElementRef<schema::Field>> {
         self.field_def_stack.last().cloned()
     }
 
-    pub fn enter_field_def(&mut self, field: schema::Field) {
+    pub fn enter_field_def(&mut self, field: TypeInfoElementRef<schema::Field>) {
         self.field_def_stack.push(field);
     }