Separate semantic analysis from parsing

[jyn514]

I've meant to do this for a while. Code like this is just horrifying:

        self.left_associative_binary_op(next_grammar_func, tokens, |expr, next, token| {
            let non_scalar = if !expr.ctype.is_integral() {
                Some(&expr.ctype)
            } else if !next.ctype.is_integral() {
                Some(&next.ctype)
            } else {
                None
            };
            if let Some(ctype) = non_scalar {
                return Err((
                    Locatable {
                        data: format!(
                            "expected integer on both sides of '{}', got '{}'",
                            token.data, ctype
                        ),
                        location: token.location,
                    },
                    *expr,
                ));
            }
            let (promoted_expr, next) = Expr::binary_promote(*expr, *next).map_err(flatten)?;
            expr_func(promoted_expr, next, token)
        })

It obscures what the function's actually doing and also makes the error handling really complicated. Type checking should go in a separate pass.

[jyn514]

Things this would improve:

• stack size in the heavily recursive part of the parser would go down by a lot
• the code would hopefully be easier to read/more modular
• the code would be more reusable (e.g. Binary promotion for complex assignment #25)
• hopefully left_associative_binary_op could be refactored to not need to take a closure

[jyn514]

Made a start on this in https://github.com/jyn514/rcc/tree/semantic-analysis and it's going to be even more work than I thought :(

[jyn514]

Work on this is ongoing in https://github.com/jyn514/rcc/tree/pratt-parsing.