[Rust] syn: Rust 코드 파서

syn은 Rust 코드 자체의 파싱을 위한 서드파티 crate다.

코드를 런타임이나 컴파일타임에 분석해서 메타프로그래밍이나 제너레이션을 수행할 필요가 있을 떄 유용하다.
특히, procedural macro의 보조도구로 사용하기 좋다.

설치

버전은 2로 박고, 원하는 기능만 피쳐 플래그에 넣어준다.

[dependencies]
syn = { version = "2", features = ["full"] }

그리고 플래그가 좀 혼란스러울 수 있는데, full은 진짜 full이 아니다.
extra-traits 같은 몇몇 플래그는 손으로 넣어줘야 한다. 저걸 넣어야 Debug가 된다.

기본 사용법

기본적인 사용법은 별게 없다.
그냥 코드 넣고 돌리면 AST가 뿅 나오는 것이다.

const SOME_CODE: &str = r#"
struct Foo {
    a: i32,
    b: String,
}

fn main() {
    println!("Hello, World!");
}
"#;

fn main() {
    let ast = syn::parse_file(SOME_CODE).unwrap();

    ast.items.iter().for_each(|item| match item {
        syn::Item::Fn(f) => {
            println!("Function: {}", f.sig.ident);
        }
        syn::Item::Struct(s) => {
            println!("Struct: {}", s.ident);

            s.fields.iter().for_each(|field| {
                println!("Field: {}", field.ident.as_ref().unwrap());
            });
        }
        _ => {}
    });
}

그렇다.
이 경우에는 전체 코드를 기준으로 파싱을 했는데

parse_str을 쓰고 어떤 타입으로 받을지를 지정하면 특정 표현에 대해서만 부분적으로 파싱을 할 수도 있다.
아래는 단일 표현식을 파싱하는 간단한 예제다.

use syn::Expr;

const SOME_CODE: &str = r#"
(1 + 20).to_string()
"#;

fn main() {
    let ast: Expr = syn::parse_str(SOME_CODE).unwrap();

    match ast {
        Expr::MethodCall(method_call) => {
            println!("Method call: {:?}", method_call.method);

            match *method_call.receiver {
                Expr::Paren(paren) => match *paren.expr {
                    Expr::Binary(binary) => {
                        if let Expr::Lit(lit) = *binary.left {
                            if let syn::Lit::Int(int) = lit.lit {
                                println!("Left: {:?}", int.base10_digits());
                            }
                        }

                        if let Expr::Lit(lit) = *binary.right {
                            if let syn::Lit::Int(int) = lit.lit {
                                println!("Right: {:?}", int.base10_digits());
                            }
                        }
                    }
                    _ => {
                        panic!("Not a binary");
                    }
                },
                _ => {
                    panic!("Not a paren");
                }
            }
        }
        _ => {
            panic!("Not a method call");
        }
    }
}

잘 된다.

proc 매크로와 함께 사용하기

이 라이브러리의 강력한 점 중 하나는, TokenStream에 대해서도 쓸만하게 재가공 기능을 제공해준다는 것이다.

procmacro로 뇌절을 해본 사람은 알겠지만, TokenStream을 통해서 어느정도 정리된 형태로 코드 형태를 내려주긴 하지만, 진짜 파싱된 AST가 아니라 lexing만 처리된 거의 순수한 Token 뭉치라서 응용하기가 까다롭다.

예를 들어 foo: Option 같은게 TokenStream에 들어오면 진짜 [Ident:"foo", Ident:'Option", "<", "i32", ">"] 이딴 식으로 나온다.

syn의 파싱 기능을 사용하면 이걸 간단하게 AST 수준까지 변환할 수 있다.

다음과 같이 parse_macro_input 매크로를 사용하면 된다. 이건 구조체에 대해서 사용할 procmacro다.

use proc_macro::TokenStream;
use syn::{parse_macro_input, ItemStruct};

#[proc_macro_attribute]
pub fn my_macro(_attribute: TokenStream, item: TokenStream) -> TokenStream {
    let copied = item.clone();

    // Parse the input tokens into a syntax tree
    let ast = parse_macro_input!(item as ItemStruct);

    println!("{:?}", ast);

    // Hand the output tokens back to the compiler
    TokenStream::from(copied)
}

그리고 구조체에 달아서 돌려보면

적당히 예쁘게 파싱해줄 것이다.

그럼 맛보고 즐기면 된다.