chore: add node ast parser

Author: appflowy

shared-lib/flowy-ast/src/ast.rs

@@ -1,21 +1,24 @@
 #![allow(clippy::all)]
 #![allow(unused_attributes)]
 #![allow(unused_assignments)]
-use crate::{attr, ty_ext::*, ASTResult, AttrsContainer};
+
+use crate::event_attrs::EventEnumAttrs;
+use crate::node_attrs::NodeStructAttrs;
+use crate::{is_recognizable_field, pb_attrs, ty_ext::*, ASTResult, PBAttrsContainer, PBStructAttrs};
 use syn::{self, punctuated::Punctuated};
 
 pub struct ASTContainer<'a> {
     /// The struct or enum name (without generics).
     pub ident: syn::Ident,
     /// Attributes on the structure.
-    pub attrs: AttrsContainer,
+    pub attrs: PBAttrsContainer,
     /// The contents of the struct or enum.
     pub data: ASTData<'a>,
 }
 
 impl<'a> ASTContainer<'a> {
     pub fn from_ast(ast_result: &ASTResult, ast: &'a syn::DeriveInput) -> Option<ASTContainer<'a>> {
-        let attrs = AttrsContainer::from_ast(ast_result, ast);
+        let attrs = PBAttrsContainer::from_ast(ast_result, ast);
         // syn::DeriveInput
         //  1. syn::DataUnion
         //  2. syn::DataStruct
@@ -55,7 +58,7 @@ impl<'a> ASTData<'a> {
         }
     }
 
-    pub fn all_variants(&'a self) -> Box<dyn Iterator<Item = &'a attr::ASTEnumAttrVariant> + 'a> {
+    pub fn all_variants(&'a self) -> Box<dyn Iterator<Item = &'a EventEnumAttrs> + 'a> {
         match self {
             ASTData::Enum(variants) => {
                 let iter = variants.iter().map(|variant| &variant.attrs);
@@ -85,7 +88,7 @@ impl<'a> ASTData<'a> {
 /// A variant of an enum.
 pub struct ASTEnumVariant<'a> {
     pub ident: syn::Ident,
-    pub attrs: attr::ASTEnumAttrVariant,
+    pub attrs: EventEnumAttrs,
     pub style: ASTStyle,
     pub fields: Vec<ASTField<'a>>,
     pub original: &'a syn::Variant,
@@ -106,7 +109,8 @@ pub enum BracketCategory {
 
 pub struct ASTField<'a> {
     pub member: syn::Member,
-    pub attrs: attr::ASTAttrField,
+    pub pb_attrs: PBStructAttrs,
+    pub node_attrs: NodeStructAttrs,
     pub ty: &'a syn::Type,
     pub original: &'a syn::Field,
     pub bracket_ty: Option<syn::Ident>,
@@ -161,7 +165,8 @@ impl<'a> ASTField<'a> {
                 Some(ident) => syn::Member::Named(ident.clone()),
                 None => syn::Member::Unnamed(index.into()),
             },
-            attrs: attr::ASTAttrField::from_ast(cx, index, field),
+            pb_attrs: PBStructAttrs::from_ast(cx, index, field),
+            node_attrs: NodeStructAttrs::from_ast(cx, index, field),
             ty: &field.ty,
             original: field,
             bracket_ty,
@@ -185,10 +190,6 @@ impl<'a> ASTField<'a> {
             None
         }
     }
-
-    pub fn is_option(&self) -> bool {
-        attr::is_option(self.ty)
-    }
 }
 
 #[derive(Copy, Clone)]
@@ -222,7 +223,7 @@ pub fn enum_from_ast<'a>(
     variants
         .iter()
         .flat_map(|variant| {
-            let attrs = attr::ASTEnumAttrVariant::from_ast(cx, ident, variant, enum_attrs);
+            let attrs = EventEnumAttrs::from_ast(cx, ident, variant, enum_attrs);
             let (style, fields) = struct_from_ast(cx, &variant.fields);
             Some(ASTEnumVariant {
                 ident: variant.ident.clone(),
@@ -239,6 +240,12 @@ fn fields_from_ast<'a>(cx: &ASTResult, fields: &'a Punctuated<syn::Field, Token!
     fields
         .iter()
         .enumerate()
-        .flat_map(|(index, field)| ASTField::new(cx, field, index).ok())
+        .flat_map(|(index, field)| {
+            if is_recognizable_field(field) {
+                ASTField::new(cx, field, index).ok()
+            } else {
+                None
+            }
+        })
         .collect()
 }

shared-lib/flowy-ast/src/event_attrs.rs

@@ -0,0 +1,147 @@
+use crate::{get_event_meta_items, parse_lit_str, symbol::*, ASTResult};
+
+
+use syn::{
+    self,
+    parse::{self, Parse},
+    Meta::{List, NameValue, Path},
+    NestedMeta::{Lit, Meta},
+};
+
+#[derive(Debug, Clone)]
+pub struct EventAttrs {
+    input: Option<syn::Path>,
+    output: Option<syn::Path>,
+    error_ty: Option<String>,
+    pub ignore: bool,
+}
+
+#[derive(Debug, Clone)]
+pub struct EventEnumAttrs {
+    pub enum_name: String,
+    pub enum_item_name: String,
+    pub value: String,
+    pub event_attrs: EventAttrs,
+}
+
+impl EventEnumAttrs {
+    pub fn from_ast(
+        ast_result: &ASTResult,
+        ident: &syn::Ident,
+        variant: &syn::Variant,
+        enum_attrs: &[syn::Attribute],
+    ) -> Self {
+        let enum_item_name = variant.ident.to_string();
+        let enum_name = ident.to_string();
+        let mut value = String::new();
+        if variant.discriminant.is_some() {
+            if let syn::Expr::Lit(ref expr_list) = variant.discriminant.as_ref().unwrap().1 {
+                let lit_int = if let syn::Lit::Int(ref int_value) = expr_list.lit {
+                    int_value
+                } else {
+                    unimplemented!()
+                };
+                value = lit_int.base10_digits().to_string();
+            }
+        }
+        let event_attrs = get_event_attrs_from(ast_result, &variant.attrs, enum_attrs);
+        EventEnumAttrs {
+            enum_name,
+            enum_item_name,
+            value,
+            event_attrs,
+        }
+    }
+
+    pub fn event_input(&self) -> Option<syn::Path> {
+        self.event_attrs.input.clone()
+    }
+
+    pub fn event_output(&self) -> Option<syn::Path> {
+        self.event_attrs.output.clone()
+    }
+
+    pub fn event_error(&self) -> String {
+        self.event_attrs.error_ty.as_ref().unwrap().clone()
+    }
+}
+
+fn get_event_attrs_from(
+    ast_result: &ASTResult,
+    variant_attrs: &[syn::Attribute],
+    enum_attrs: &[syn::Attribute],
+) -> EventAttrs {
+    let mut event_attrs = EventAttrs {
+        input: None,
+        output: None,
+        error_ty: None,
+        ignore: false,
+    };
+
+    enum_attrs
+        .iter()
+        .filter(|attr| attr.path.segments.iter().any(|s| s.ident == EVENT_ERR))
+        .for_each(|attr| {
+            if let Ok(NameValue(named_value)) = attr.parse_meta() {
+                if let syn::Lit::Str(s) = named_value.lit {
+                    event_attrs.error_ty = Some(s.value());
+                } else {
+                    eprintln!("❌ {} should not be empty", EVENT_ERR);
+                }
+            } else {
+                eprintln!("❌ Can not find any {} on attr: {:#?}", EVENT_ERR, attr);
+            }
+        });
+
+    let mut extract_event_attr = |attr: &syn::Attribute, meta_item: &syn::NestedMeta| match &meta_item {
+        Meta(NameValue(name_value)) => {
+            if name_value.path == EVENT_INPUT {
+                if let syn::Lit::Str(s) = &name_value.lit {
+                    let input_type = parse_lit_str(s)
+                        .map_err(|_| {
+                            ast_result
+                                .error_spanned_by(s, format!("failed to parse request deserializer {:?}", s.value()))
+                        })
+                        .unwrap();
+                    event_attrs.input = Some(input_type);
+                }
+            }
+
+            if name_value.path == EVENT_OUTPUT {
+                if let syn::Lit::Str(s) = &name_value.lit {
+                    let output_type = parse_lit_str(s)
+                        .map_err(|_| {
+                            ast_result
+                                .error_spanned_by(s, format!("failed to parse response deserializer {:?}", s.value()))
+                        })
+                        .unwrap();
+                    event_attrs.output = Some(output_type);
+                }
+            }
+        }
+        Meta(Path(word)) => {
+            if word == EVENT_IGNORE && attr.path == EVENT {
+                event_attrs.ignore = true;
+            }
+        }
+        Lit(s) => ast_result.error_spanned_by(s, "unexpected attribute"),
+        _ => ast_result.error_spanned_by(meta_item, "unexpected attribute"),
+    };
+
+    let attr_meta_items_info = variant_attrs
+        .iter()
+        .flat_map(|attr| match get_event_meta_items(ast_result, attr) {
+            Ok(items) => Some((attr, items)),
+            Err(_) => None,
+        })
+        .collect::<Vec<(&syn::Attribute, Vec<syn::NestedMeta>)>>();
+
+    for (attr, nested_metas) in attr_meta_items_info {
+        nested_metas
+            .iter()
+            .for_each(|meta_item| extract_event_attr(attr, meta_item))
+    }
+
+    // eprintln!("😁{:#?}", event_attrs);
+    event_attrs
+}

shared-lib/flowy-ast/src/lib.rs

@@ -5,12 +5,16 @@ extern crate syn;
 extern crate quote;
 
 mod ast;
-mod attr;
 mod ctxt;
+mod pb_attrs;
 
+mod event_attrs;
+mod node_attrs;
 pub mod symbol;
 pub mod ty_ext;
+
 pub use self::{symbol::*, ty_ext::*};
 pub use ast::*;
-pub use attr::*;
 pub use ctxt::ASTResult;
+pub use event_attrs::*;
+pub use pb_attrs::*;

shared-lib/flowy-ast/src/node_attrs.rs

@@ -0,0 +1,82 @@
+use crate::{get_node_meta_items, get_pb_meta_items, parse_lit_into_expr_path, symbol::*, ASTAttr, ASTResult};
+use proc_macro2::{Group, Span, TokenStream, TokenTree};
+use quote::ToTokens;
+use syn::{
+    self,
+    parse::{self, Parse},
+    Meta::{List, NameValue, Path},
+    NestedMeta::{Lit, Meta},
+};
+
+pub struct NodeStructAttrs {
+    node_index: Option<syn::LitInt>,
+    get_node_value_with: Option<syn::ExprPath>,
+    set_node_value_with: Option<syn::ExprPath>,
+}
+
+impl NodeStructAttrs {
+    /// Extract out the `#[node(...)]` attributes from a struct field.
+    pub fn from_ast(ast_result: &ASTResult, index: usize, field: &syn::Field) -> Self {
+        let mut node_index = ASTAttr::none(ast_result, NODE_INDEX);
+        let mut get_node_value_with = ASTAttr::none(ast_result, GET_NODE_VALUE_WITH);
+        let mut set_node_value_with = ASTAttr::none(ast_result, SET_NODE_VALUE_WITH);
+
+        let ident = match &field.ident {
+            Some(ident) => ident.to_string(),
+            None => index.to_string(),
+        };
+
+        for meta_item in field
+            .attrs
+            .iter()
+            .flat_map(|attr| get_node_meta_items(ast_result, attr))
+            .flatten()
+        {
+            match &meta_item {
+                // Parse '#[node(index = x)]'
+                Meta(NameValue(m)) if m.path == NODE_INDEX => {
+                    if let syn::Lit::Int(lit) = &m.lit {
+                        node_index.set(&m.path, lit.clone());
+                    }
+                }
+
+                // Parse `#[node(get_node_value_with = "...")]`
+                Meta(NameValue(m)) if m.path == GET_NODE_VALUE_WITH => {
+                    if let Ok(path) = parse_lit_into_expr_path(ast_result, GET_NODE_VALUE_WITH, &m.lit) {
+                        get_node_value_with.set(&m.path, path);
+                    }
+                }
+
+                // Parse `#[node(set_node_value_with= "...")]`
+                Meta(NameValue(m)) if m.path == SET_NODE_VALUE_WITH => {
+                    if let Ok(path) = parse_lit_into_expr_path(ast_result, SET_NODE_VALUE_WITH, &m.lit) {
+                        set_node_value_with.set(&m.path, path);
+                    }
+                }
+
+                Meta(meta_item) => {
+                    let path = meta_item.path().into_token_stream().to_string().replace(' ', "");
+                    ast_result.error_spanned_by(meta_item.path(), format!("unknown node field attribute `{}`", path));
+                }
+
+                Lit(lit) => {
+                    ast_result.error_spanned_by(lit, "unexpected literal in field attribute");
+                }
+            }
+        }
+
+        NodeStructAttrs {
+            node_index: node_index.get(),
+            get_node_value_with: get_node_value_with.get(),
+            set_node_value_with: set_node_value_with.get(),
+        }
+    }
+
+    pub fn set_node_value_with(&self) -> Option<&syn::ExprPath> {
+        self.set_node_value_with.as_ref()
+    }
+
+    pub fn get_node_value_with(&self) -> Option<&syn::ExprPath> {
+        self.get_node_value_with.as_ref()
+    }
+}