fn symbol(&mut self, tree: &Spanned<TokenTree>) -> Result<Spanned<AST>, Syntax> {
        let symbol = if let TokenTree::Iden(iden) = &tree.item {
            if let Some(keyword) = ResIden::try_new(iden) {
                // TODO: if there is a keyword left in the tree
                // during desugaring, that is an error
                return Ok(Spanned::new(
                    AST::Sugar(Sugar::Keyword(keyword)),
                    tree.span.clone(),
                ));
            }

            self.intern_symbol(iden)
        } else {
            return Err(Syntax::error(
                &format!("Expected an identifier, found {}", &tree.item),
                &tree.span,
            ));
        };

        Ok(Spanned::new(
            AST::Base(Base::Symbol(symbol)),
            tree.span.clone(),
        ))
    }
Constructs an AST for a symbol,
interning symbols with same names in the parser.
So, for instance, in the following snippet:
```ignore
x = 0
x -> x + 1
```
All `x`s would be interned to the same number,
even though they represent semantically different
things. Semantic names are resoled in a later
pass.
passerine/src/compiler/parse.rs