AppFlowy/frontend/rust-lib/flowy-ast/src/ty_ext.rs

use crate::ASTResult;
use syn::{self, AngleBracketedGenericArguments, PathSegment};

#[derive(Eq, PartialEq, Debug)]
pub enum PrimitiveTy {
    Map(MapInfo),
    Vec,
    Opt,
    Other,
}

#[derive(Debug)]
pub struct TyInfo<'a> {
    pub ident: &'a syn::Ident,
    pub ty: &'a syn::Type,
    pub primitive_ty: PrimitiveTy,
    pub bracket_ty_info: Box<Option<TyInfo<'a>>>,
}

#[derive(Debug, Eq, PartialEq)]
pub struct MapInfo {
    pub key: String,
    pub value: String,
}

impl MapInfo {
    fn new(key: String, value: String) -> Self {
        MapInfo { key, value }
    }
}

impl<'a> TyInfo<'a> {
    #[allow(dead_code)]
    pub fn bracketed_ident(&'a self) -> &'a syn::Ident {
        match self.bracket_ty_info.as_ref() {
            Some(b_ty) => b_ty.ident,
            None => {
                panic!()
            }
        }
    }
}

pub fn parse_ty<'a>(ast_result: &ASTResult, ty: &'a syn::Type) -> Result<Option<TyInfo<'a>>, String> {
    // Type -> TypePath -> Path -> PathSegment -> PathArguments ->
    // AngleBracketedGenericArguments -> GenericArgument -> Type.
    if let syn::Type::Path(ref p) = ty {
        if p.path.segments.len() != 1 {
            return Ok(None);
        }

        let seg = match p.path.segments.last() {
            Some(seg) => seg,
            None => return Ok(None),
        };

        let _is_option = seg.ident == "Option";

        return if let syn::PathArguments::AngleBracketed(ref bracketed) = seg.arguments {
            match seg.ident.to_string().as_ref() {
                "HashMap" => generate_hashmap_ty_info(ast_result, ty, seg, bracketed),
                "Vec" => generate_vec_ty_info(ast_result, seg, bracketed),
                "Option" => generate_option_ty_info(ast_result, ty, seg, bracketed),
                _ => {
                    let msg = format!("Unsupported type: {}", seg.ident);
                    ast_result.error_spanned_by(&seg.ident, &msg);
                    return Err(msg);
                }
            }
        } else {
            return Ok(Some(TyInfo {
                ident: &seg.ident,
                ty,
                primitive_ty: PrimitiveTy::Other,
                bracket_ty_info: Box::new(None),
            }));
        };
    }
    Err("Unsupported inner type, get inner type fail".to_string())
}

fn parse_bracketed(bracketed: &AngleBracketedGenericArguments) -> Vec<&syn::Type> {
    bracketed
        .args
        .iter()
        .flat_map(|arg| {
            if let syn::GenericArgument::Type(ref ty_in_bracket) = arg {
                Some(ty_in_bracket)
            } else {
                None
            }
        })
        .collect::<Vec<&syn::Type>>()
}

pub fn generate_hashmap_ty_info<'a>(
    ast_result: &ASTResult,
    ty: &'a syn::Type,
    path_segment: &'a PathSegment,
    bracketed: &'a AngleBracketedGenericArguments,
) -> Result<Option<TyInfo<'a>>, String> {
    // The args of map must greater than 2
    if bracketed.args.len() != 2 {
        return Ok(None);
    }
    let types = parse_bracketed(bracketed);
    let key = parse_ty(ast_result, types[0])?.unwrap().ident.to_string();
    let value = parse_ty(ast_result, types[1])?.unwrap().ident.to_string();
    let bracket_ty_info = Box::new(parse_ty(ast_result, types[1])?);
    Ok(Some(TyInfo {
        ident: &path_segment.ident,
        ty,
        primitive_ty: PrimitiveTy::Map(MapInfo::new(key, value)),
        bracket_ty_info,
    }))
}

fn generate_option_ty_info<'a>(
    ast_result: &ASTResult,
    ty: &'a syn::Type,
    path_segment: &'a PathSegment,
    bracketed: &'a AngleBracketedGenericArguments,
) -> Result<Option<TyInfo<'a>>, String> {
    assert_eq!(path_segment.ident.to_string(), "Option".to_string());
    let types = parse_bracketed(bracketed);
    let bracket_ty_info = Box::new(parse_ty(ast_result, types[0])?);
    Ok(Some(TyInfo {
        ident: &path_segment.ident,
        ty,
        primitive_ty: PrimitiveTy::Opt,
        bracket_ty_info,
    }))
}

fn generate_vec_ty_info<'a>(
    ast_result: &ASTResult,
    path_segment: &'a PathSegment,
    bracketed: &'a AngleBracketedGenericArguments,
) -> Result<Option<TyInfo<'a>>, String> {
    if bracketed.args.len() != 1 {
        return Ok(None);
    }
    if let syn::GenericArgument::Type(ref bracketed_type) = bracketed.args.first().unwrap() {
        let bracketed_ty_info = Box::new(parse_ty(ast_result, bracketed_type)?);
        return Ok(Some(TyInfo {
            ident: &path_segment.ident,
            ty: bracketed_type,
            primitive_ty: PrimitiveTy::Vec,
            bracket_ty_info: bracketed_ty_info,
        }));
    }
    Ok(None)
}