// rustc_ast/src/ast.rs#
pub struct Crate {
    pub attrs: Vec<Attribute>,
    pub items: Vec<P<Item>>, //本crate下所有ast的root节点数组。
    pub spans: ModSpans,
    pub id: NodeId,
    pub is_placeholder: bool,
}
pub struct Item<K = ItemKind> { // ast上的节点Item， 
    pub attrs: Vec<Attribute>,
    pub id: NodeId,
    pub span: Span,
    pub vis: Visibility,
    pub ident: Ident,
    pub kind: K,     // 在ItemKind上定义节点Item之间的连接关系
    pub tokens: Option<LazyTokenStream>,
}
// 根据BNF中的语法规则定义每种语法的结构
pub enum ItemKind {
    /// An `extern crate` item, with the optional *original* crate name if the crate was renamed.
    ///
    /// E.g., `extern crate foo` or `extern crate foo_bar as foo`.
    ExternCrate(Option<Symbol>),
    /// A use declaration item (`use`).
    ///
    /// E.g., `use foo;`, `use foo::bar;` or `use foo::bar as FooBar;`.
    Use(UseTree),
    /// A static item (`static`).
    ///
    /// E.g., `static FOO: i32 = 42;` or `static FOO: &'static str = "bar";`.
    Static(P<Ty>, Mutability, Option<P<Expr>>),
    /// A constant item (`const`).
    ///
    /// E.g., `const FOO: i32 = 42;`.
    Const(Defaultness, P<Ty>, Option<P<Expr>>),
    /// A function declaration (`fn`).
    ///
    /// E.g., `fn foo(bar: usize) -> usize { .. }`.
    Fn(Box<Fn>),
    Mod(Unsafe, ModKind),
    ForeignMod(ForeignMod),
    Enum(EnumDef, Generics),
    Struct(VariantData, Generics),
    Union(VariantData, Generics),
    Trait(Box<Trait>),
    Impl(Box<Impl>),
}

trait Foo {...}
fn baz<T: Foo>(t: T) {...}

// 1. type checking, t should implz Foo trait
// 2. trait solving, which implementation of Foo to use 
baz(3); 
baz("hello");

fn main() {
    let source = "-11+2*(3+10)+2";
    let res = parser_expr(&mut Lexer::new(source.to_owned()));
    println!("{}={}", source, res); //17
}

/// E -> E + T | E - T | T
/// T -> T * F | T / F | F
/// F -> (E) | number
fn parser_expr(lexer: &mut Lexer) -> i32 {
    let mut i = parser_term(lexer);
    while lexer.ch == '+' || lexer.ch == '-' {
        if lexer.ch == '+' {
            lexer.read_char();
            let right = parser_term(lexer);
            i += right;
        } else {
            lexer.read_char();
            let right = parser_term(lexer);
            i -= right;
        }
    }
    i
}

fn parser_term(lexer: &mut Lexer) -> i32 {
    let mut i = parser_factor(lexer);
    while lexer.ch == '*' || lexer.ch == '/' {
        if lexer.ch == '*' {
            lexer.read_char();
            i *= parser_factor(lexer);
        } else {
            // assert!(lexer.expect_char(b'/'));
            lexer.read_char();
            i /= parser_factor(lexer);
        }
    }
    i
}

fn parser_factor(lexer: &mut Lexer) -> i32 {
    if lexer.ch == '(' {
        // assert!(lexer.expect_char('('));
        lexer.read_char();
        let res = parser_expr(lexer);
        lexer.read_char();
        res
    } else {
        let mut res = 0i32;
        while lexer.ch >= '0' && lexer.ch <= '9' {
            res = res * 10 + lexer.ch as i32 - '0' as i32;
            lexer.read_char();
        }
        // -11 时 处理为 0-11， 对于-11遇到-时返回0
        res
    }
}

struct Lexer {
    input: Vec<char>,
    cur_position: usize,
    ch: char,
    next_position: usize,
}
impl Lexer {
    pub fn new(input: String) -> Self {
        let mut lexer = Self {
            input: input.chars().collect(),
            cur_position: 0,
            ch: '0',
            next_position: 0,
        };
        lexer.read_char();
        lexer
    }

    pub fn read_char(&mut self) {
        self.ch = self.peek_char();
        self.cur_position = self.next_position;
        self.next_position += 1;
    }

    pub fn peek_char(&mut self) -> char {
        if self.next_position >= self.input.len() {
            return char::MAX;
        }
        self.input[self.next_position]
    }
}